diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..7c847c47 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,11 @@ +FROM python:3.12.7-slim-bookworm +WORKDIR /srv +COPY app/requirements.txt app/requirements.txt +RUN pip install --no-cache-dir -r app/requirements.txt && useradd --uid 10001 --create-home app +COPY app app +COPY migrations migrations +USER 10001:10001 +ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 +EXPOSE 8080 +HEALTHCHECK --interval=5s --timeout=4s --start-period=20s CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready', timeout=3)" || exit 1 +CMD ["python", "app/server.py"] diff --git a/PR_DESCRIPTION.md b/PR_DESCRIPTION.md new file mode 100644 index 00000000..c287a7c8 --- /dev/null +++ b/PR_DESCRIPTION.md @@ -0,0 +1,27 @@ +## Лабораторная 3 + +Автор / группа: Шурман А.Р., БПИ2302. +Целевая оценка: **4**. Треки 5 не заявлены. + +На основе собственной лабораторной 2 добавлены две взаимозаменяемые API-реплики +за HAProxy и общая идемпотентность в PostgreSQL. Повтор сообщения, в том числе +одновременно через разные реплики, возвращает тот же результат без дубликатов. +Сохранены общие сессии, Argon2, миграции и необязательный кэш профилей Valkey. + +Запуск: `python3 scripts/bootstrap.py`, `docker compose up -d --build`, затем +`make test` после готовности LB. Полные инструкции — [REPORT.md](REPORT.md). + +Проверено: check, OpenAPI validate, smoke, persistence всех сервисов, публичный +failover, гонка 16 одинаковых ключей, последовательный отказ каждой реплики, +поочерёдная замена контейнеров под нагрузкой. Выводы сохранены в `evidence/`. +При обнаружении отказов есть краткие ошибки; подтверждённые данные не потеряны. + +Ограничения: один хост/LB/БД, локальный HTTP, нет защиты от отказа диска/узла, +нет исследований на 5. Источники: skeleton и собственная lab2; помощь Codex. + +- [x] Обязательные возможности предыдущей работы сохранены. +- [x] Контракт и публичные тесты не ослаблены. +- [x] make check и make test выполнены; реальный вывод приложен. +- [x] Сценарии уровня 4 воспроизведены. +- [x] Секреты и tokens отсутствуют в Git и отчёте. +- [x] README задания сохранён, REPORT.md описывает решение. diff --git a/REPORT.md b/REPORT.md index c2679005..2436ce88 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,157 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор: Шурман А.Р., БПИ2302 (как в лабораторной 2). +- Целевая оценка: **4**, без треков на 5 и без UI. +- Ветка: `solution/bpi2302-shurman`. [PR #142](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/142) из `aliska/mtusi2026lab3-fork` в исходный репозиторий. Реализация и проверки: `7da0348`. +- Основа: собственная лабораторная 2 (`mtusi2026lab2-fork`), исходный контракт и публичные тесты лабораторной 3. Помощь OpenAI Codex: реализация, проверки, отчёт. +- Библиотеки: FastAPI, Uvicorn, psycopg/pool, Argon2, redis-py; версии в `app/requirements.txt`. -## Запуск из чистого clone +## Запуск -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Desktop/Engine с Compose и Python 3.9+ для проверок. +Из корня этого репозитория: -## Архитектура и решения +```sh +python3 scripts/bootstrap.py +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +make check +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +docker compose start api +python3 student-tests/verify.py +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +После `up` дождаться ответа 200 от `http://localhost:8080/health/ready`. +После публичного failover запустить остановленную реплику командой `start api`; +собственный сценарий дожидается готовности обеих реплик перед экспериментами. +Публичный failover сам передаёт `TARGET_INSTANCE_ID` action-скрипту. +Ручная остановка: `TARGET_INSTANCE_ID= scripts/stop-one.sh`. -## Доказательства критериев +OpenAPI: `python3 -m venv .venv`, затем +`.venv/bin/python -m pip install -r requirements-dev.txt` и +`make validate PYTHON=.venv/bin/python`. +Безопасная остановка: `docker compose down` (volumes остаются). +Преднамеренное удаление учебных данных: `docker compose down -v` — только если +нужен полный сброс. При проверках эта команда не используется. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +API и Swagger доступны через LB: http://localhost:8080/docs. +Порты API/БД/Valkey на хост не публикуются. Порт LB привязан к loopback. +Версии образов: Python 3.12.7, PostgreSQL 16.6, Valkey 8.0.2, HAProxy 3.0.5. +Bootstrap создаёт новые локальные secrets, не копирует пароли лабораторной 2, +не перезаписывает существующие файлы. Secrets и `.env` исключены из Git/build. +В `.env` используются `HOST_PORT` и `SESSION_TTL_SECONDS`. +Адреса БД/кэша передаются через `DATABASE_URL_FILE`/`CACHE_URL_FILE`. +Сессии всегда PostgreSQL, срок идемпотентности фиксирован 24 часа. +Число реплик задаётся `deploy.replicas: 2`; для изменения — `--scale api=N`. +Остальные переменные исходного `.env.example` — описание интерфейсов skeleton, +а не переключатели реализации. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +## Архитектура -## Эксперименты и отказы +Клиент → HAProxy → две реплики одного Compose-service `api` → PostgreSQL. +Valkey — общий необязательный кэш неизменяемых профилей, как в лабораторной 2. +PostgreSQL хранит пользователей, чаты, участников, сообщения, сессии и ключи +идемпотентности. Локального состояния, влияющего на корректность, в API нет. +Пароли — Argon2id; токены 256 бит, в БД только hash и абсолютный expiry. +Сессия проверяется в БД при каждом запросе; недоступность Valkey даёт fallback. +История не кэшируется: подтверждённый COMMIT виден следующему чтению любой реплики. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Каждый ответ API (включая ошибки/health) имеет X-Request-Id и X-Instance-Id. +Instance ID — hostname реального контейнера. Один Uvicorn-процесс на контейнер. +HAProxy round-robin без sticky sessions; заголовки сопоставляются с docker inspect. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +POST сообщения требует ключ ASCII длиной 1–128. Область ключа — пользователь, +чат и единственный endpoint POST сообщения. PostgreSQL advisory transaction lock +сериализует одинаковый ключ между процессами. Сообщение и результат ключа +сохраняются в одной транзакции; сбой откатывает оба изменения. Повтор возвращает +тот же Message/201, другой текст — 409. Проверка сессии/доступа выполняется снова. +5xx не сохраняются. Коллизия 64-битного lock только сериализует посторонние ключи, +но не смешивает данные: поиск/UNIQUE используют полную тройку значений. +Контракт lab3 принимает только `text`; вложения относятся к lab4. -## Ограничения и следующие шаги +## Готовность, таймауты и обновление -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Liveness проверяет процесс; readiness — доступность PostgreSQL и таблицы миграций. +- HAProxy: проверка раз в 1 s, timeout 1 s, `fall 2`, `rise 1`. + Консервативный бюджет обнаружения недоступного backend — до 4 s при нормальном + планировании. Это не гарантия при зависании хоста. DNS Docker обновляется с + `hold valid/obsolete 1s`, адреса не зафиксированы в конфигурации. +- HAProxy connect timeout 1 s, server timeout 10 s, client 15 s. Автоматических + повторов нет (`retries 0`), чтобы не дублировать POST создания чата/регистрации. +- Pool 1–8, ожидание до 3 s, SQL timeout 3 s, lock timeout 2 s. Кэш timeout 0.2 s. +- Uvicorn получает SIGTERM напрямую, закрывает listener, завершает активные + запросы (до 8 s), затем закрывает pool/cache. Docker даёт 10 s на остановку. + При попадании в закрывающийся backend допустима краткая ошибка; клиент повторяет + сообщение с прежним ключом. Исключение backend контролирует HAProxy, а не Compose. +- Docker healthcheck: каждые 5 s, timeout 4 s; он нужен для запуска/наблюдения. + Проверки маршрутизации независимо выполняет HAProxy каждую секунду. + +Лимиты: каждая API/migrate 0.5 CPU/256 MiB, PostgreSQL 1 CPU/512 MiB, +Valkey 0.25 CPU/128 MiB, LB 0.5 CPU/128 MiB. `container_name` нет. +API non-root. Пароль PostgreSQL получает только БД; URL БД/кэша — API и мигратор. +LB не получает secrets. Сетевые зависимости доступны только в сети проекта. + +Мигратор — отдельный завершённый сервис, до запуска API, с advisory lock и +checksum применённых SQL. Повторный запуск безопасен. Миграция 002 добавляет +таблицу, не меняя старые структуры. Для обновления: собрать новый образ, +`docker compose run --rm migrate`, затем `python3 scripts/rolling.py`. +Скрипт поочерёдно останавливает/заменяет каждую старую API-реплику и ждёт здоровья +новой, пока другая работает. Проверен эквивалент rolling update: замена обоих +контейнеров текущим образом под нагрузкой. Совместимость произвольных будущих +версий не заявляется: нужны обратно совместимые миграции; удаление колонок +потребует отдельного плана. В этой работе destructive migration нет. + +## Проверки и результаты + +Измерения 12.11.2026 на локальном Docker Desktop arm64, только синтетические данные. +Публичные `tests/`, `contracts/`, README и COURSE не изменены. + +| Критерий | Проверка | Доказательство | +|---|---|---| +| Структура, OpenAPI, обязательный API | make check/validate/test | evidence/check.txt, validate.txt, smoke.txt | +| Данные и прежний токен после рестарта всех сервисов | test-persistence | evidence/persistence.txt, restart-containers.json | +| Две реальные реплики и отказ через LB | публичный test-failover | evidence/failover.txt | +| Один ключ одновременно на двух репликах | 16 параллельных POST, 1 Message | evidence/grade4.json | +| Последовательный отказ каждой реплики | 4 потока чтения/записи, восстановление предыдущей | evidence/grade4.json | +| Поочерёдная замена под нагрузкой | новые container IDs, чтение/запись продолжаются | evidence/grade4.json | +| Лимиты и отсутствие обходных портов | compose + inspect | evidence/containers.json | + +`student-tests/verify.py` создаёт отдельный чат, проверяет гонку одного ключа, +затем поочерёдный отказ каждой реплики и замену обеих. Каждый эксперимент: +4 закрытых клиентских потока, прогрев 2 s, воздействие, ещё 5 s нагрузки; +одна итерация — POST сообщения + GET пользователя, пауза 20 ms. +RPS в `grade4.json` — успешные пары записи/чтения в секунду, не максимум системы. +При неопределённом результате повторяется тот же ключ. После каждого сценария +проверяется сохранность всех подтверждённых сообщений и отсутствие дубликатов. +`max_success_gap_seconds` — максимальный промежуток без успешных пар; +`first_success_after_action_seconds` отсчитывается от завершения action. +Публичный failover отдельно измеряет восстановление от начала action (бюджет 10 s). +Ошибки учитываются, процентили/throughput не объявляются production SLA. + +Фактический прогон: + +| Воздействие | Успешных пар/с | Ошибок | Максимальный разрыв между успехами | +|---|---:|---:|---:| +| Остановка первой API | 87.66 | 24 | 1.051 s | +| Остановка второй API | 81.78 | 25 | 1.055 s | +| Замена обеих API | 99.08 | 50 | 1.025 s | + +Ошибки кратковременны во время обнаружения остановки, нулевая потеря HTTP-запросов +не заявляется. Все подтверждённые сообщения сохранены; повтор с прежним ключом +не создал дубликатов. Продолжительность экспериментов: 7.974 / 7.459 / 28.603 s. +Это один функциональный прогон, а не исследование масштабирования уровня 5. +Публичный failover: 2 наблюдаемых реплики, 116 успешных записей, 2 неудачные +попытки, восстановление за 1.682 s от начала action. Persistence прошёл с прежним +токеном; StartedAt всех пяти работающих контейнеров изменился. +Повторный запуск мигратора: Migrations OK (`evidence/migrations.txt`). + +## Ограничения + +Один LB, PostgreSQL и хост остаются точками отказа; отказ узла/диска не проверен. +HTTP разрешён только локально для учебных данных, для удалённого стенда нужен TLS. +Нет UI, файлов, брокера, треков на 5, фоновой очистки истёкших ключей/сессий. +Keyset pagination сортирует по `(created_at,id)`; на неизменной истории повторов +нет, но поздний COMMIT с более ранним временем может остаться за уже пройденным +cursor. Между страницами snapshot не сохраняется. Часы и порядок commit различны. diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..6a654534 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,21 @@ +"""Atomic, serialized, versioned migrations; changed applied files are rejected.""" +import hashlib +import os +from pathlib import Path +import psycopg + +with psycopg.connect(Path(os.environ["DATABASE_URL_FILE"]).read_text().strip()) as conn: + conn.execute("SELECT pg_advisory_xact_lock(20260002)") + conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations(version text PRIMARY KEY, checksum text NOT NULL)") + for path in sorted(Path("migrations").glob("*.sql")): + sql = path.read_text() + digest = hashlib.sha256(sql.encode()).hexdigest() + row = conn.execute("SELECT checksum FROM schema_migrations WHERE version=%s", (path.name,)).fetchone() + if row: + if row[0] != digest: + raise RuntimeError("Applied migration changed: " + path.name) + continue + conn.execute(sql) + conn.execute("INSERT INTO schema_migrations VALUES (%s,%s)", (path.name,digest)) + print("Applied", path.name) +print("Migrations OK") diff --git a/app/requirements.txt b/app/requirements.txt new file mode 100644 index 00000000..e60c27f2 --- /dev/null +++ b/app/requirements.txt @@ -0,0 +1,20 @@ +annotated-types==0.8.0 +anyio==4.15.1 +argon2-cffi==23.1.0 +argon2-cffi-bindings==26.1.0 +cffi==2.1.1 +click==8.5.0 +fastapi==0.115.6 +h11==0.16.0 +idna==3.20 +psycopg==3.2.6 +psycopg-binary==3.2.6 +psycopg-pool==3.3.3 +pycparser==3.12 +pydantic==2.14.1 +pydantic_core==2.50.1 +redis==5.2.1 +starlette==0.41.3 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +uvicorn==0.34.0 diff --git a/app/server.py b/app/server.py new file mode 100644 index 00000000..4847c08a --- /dev/null +++ b/app/server.py @@ -0,0 +1,481 @@ +#!/usr/bin/env python3 +"""Lab 3 PostgreSQL messenger, adapted from the author's lab 1.""" + +from __future__ import annotations + +import base64 +import binascii +import json +import logging +import os +import re +import hashlib +import secrets +from pathlib import Path +from contextlib import asynccontextmanager +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool, PoolTimeout, TooManyRequests +import redis +from argon2 import PasswordHasher +from argon2.exceptions import VerificationError +import uuid +from datetime import datetime, timezone +from typing import Any, Optional, Tuple + +import uvicorn +from fastapi import Depends, FastAPI, Header, Query, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse, Response +from pydantic import BaseModel, ConfigDict, Field, field_validator +from starlette.exceptions import HTTPException as StarletteHTTPException + + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +LOG = logging.getLogger("messenger") + + +def env_int(name: str, default: int, minimum: int = 0) -> int: + try: + value = int(os.environ.get(name, str(default))) + except ValueError as exc: + raise SystemExit("%s must be an integer" % name) from exc + if value < minimum: + raise SystemExit("%s must be at least %s" % (name, minimum)) + return value + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str) -> None: + super().__init__(message) + self.status = status + self.code = code + self.message = message + + +class StrictModel(BaseModel): + model_config = ConfigDict(extra="forbid") + + +class Health(StrictModel): + status: str = Field(pattern="^ok$") + + +class User(StrictModel): + id: uuid.UUID + username: str = Field(pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(min_length=1, max_length=100) + created_at: datetime + + +class CreateUser(StrictModel): + password: str = Field(min_length=12, max_length=128) + + @field_validator("password") + @classmethod + def non_blank_password(cls, value: str) -> str: + if not value.strip(): + raise ValueError("password must not be blank") + return value + + username: str = Field(pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(min_length=1, max_length=100) + + @field_validator("display_name") + @classmethod + def non_blank_display_name(cls, value: str) -> str: + if not value.strip(): + raise ValueError("display_name must not be blank") + return value + + +class Chat(StrictModel): + id: uuid.UUID + title: str = Field(min_length=1, max_length=100) + member_ids: list[uuid.UUID] = Field(min_length=1, max_length=100) + created_at: datetime + + +class CreateChat(StrictModel): + 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 non_blank_title(cls, value: str) -> str: + if not value.strip(): + raise ValueError("title must not be blank") + return value + + @field_validator("member_ids") + @classmethod + def unique_members(cls, value: list[uuid.UUID]) -> list[uuid.UUID]: + if len(set(value)) != len(value): + raise ValueError("member_ids must be unique") + return value + + +class Message(StrictModel): + id: uuid.UUID + chat_id: uuid.UUID + sender_id: uuid.UUID + text: str = Field(min_length=1, max_length=4000) + created_at: datetime + + +class CreateMessage(StrictModel): + text: str = Field(min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def non_blank_text(cls, value: str) -> str: + if not value.strip(): + raise ValueError("text must not be blank") + return value + + +class ChatPage(StrictModel): + items: list[Chat] + next_cursor: Optional[str] + + +class MessagePage(StrictModel): + items: list[Message] + next_cursor: Optional[str] + + +class ErrorDetails(StrictModel): + code: str + message: str + request_id: str + + +class ErrorResponse(StrictModel): + error: ErrorDetails + + +def valid_uuid(value: Any) -> bool: + if not isinstance(value, str): + return False + try: + return str(uuid.UUID(value)) == value.lower() + except (ValueError, AttributeError): + return False + + +def make_cursor(scope: str, item: dict[str, Any]) -> str: + raw = json.dumps( + {"v": 1, "scope": scope, "created_at": item["created_at"], "id": item["id"]}, + separators=(",", ":"), + ).encode("utf-8") + return base64.urlsafe_b64encode(raw).rstrip(b"=").decode("ascii") + + +def read_cursor(value: str, scope: str) -> Tuple[str, str]: + try: + raw = base64.urlsafe_b64decode(value + "=" * (-len(value) % 4)) + data = json.loads(raw) + if set(data) != {"v", "scope", "created_at", "id"}: + raise ValueError + if data["v"] != 1 or data["scope"] != scope or not valid_uuid(data["id"]): + raise ValueError + datetime.fromisoformat(data["created_at"].replace("Z", "+00:00")) + return data["created_at"], data["id"] + except (ValueError, TypeError, AttributeError, UnicodeError, json.JSONDecodeError, binascii.Error): + raise ApiError(400, "invalid_request", "Invalid cursor") from None + + + +def secret(name): + return Path(os.environ[name + "_FILE"]).read_text().strip() + +POOL = ConnectionPool(secret("DATABASE_URL"), min_size=1, max_size=8, timeout=3, + max_waiting=32, open=False, check=ConnectionPool.check_connection, + kwargs={"row_factory": dict_row, "connect_timeout": 3, + "options": "-c statement_timeout=3000 -c lock_timeout=2000"}) +CACHE = redis.Redis.from_url(secret("CACHE_URL"), socket_connect_timeout=0.2, + socket_timeout=0.2, decode_responses=True) +HASHER = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) +DUMMY_HASH = HASHER.hash(secrets.token_urlsafe(32)) +INSTANCE_ID = os.environ.get("HOSTNAME", str(uuid.uuid4())) +TTL = env_int("SESSION_TTL_SECONDS", 3600, 1) + +@asynccontextmanager +async def lifespan(app): + POOL.open() + try: + yield + finally: + POOL.close() + CACHE.close() + +app = FastAPI(title="MTUSI Messenger — Lab 3", version="3.0.0", lifespan=lifespan) + + +def wire(row): + return {k: (v.isoformat(timespec="microseconds").replace("+00:00", "Z") + if isinstance(v, datetime) else str(v) if isinstance(v, uuid.UUID) else v) + for k, v in row.items()} + + +def query(sql, params=()): + with POOL.connection() as conn: + return [wire(row) for row in conn.execute(sql, params).fetchall()] + + +def profile(user_id): + key = "user:" + user_id + try: + value = CACHE.get(key) + if value: + return json.loads(value) + except (redis.RedisError, ValueError): + pass + rows = query("SELECT id, username, display_name, created_at FROM users WHERE id=%s", (user_id,)) + if not rows: + raise ApiError(401, "unauthorized", "Invalid session") + user = rows[0] + try: + CACHE.setex(key, 60, json.dumps(user)) + except redis.RedisError: + pass + return user + + +def token_hash(token): + return hashlib.sha256(token.encode()).hexdigest() + + +def bearer(authorization): + if not authorization or not authorization.startswith("Bearer "): + raise ApiError(401, "unauthorized", "Bearer session required") + token = authorization[7:] + if not re.fullmatch(r"[A-Za-z0-9_-]{43}", token): + raise ApiError(401, "unauthorized", "Invalid session") + return token_hash(token) + + +def current_user(authorization: Optional[str] = Header(default=None)): + digest = bearer(authorization) + rows = query("SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()", (digest,)) + if not rows: + raise ApiError(401, "unauthorized", "Invalid session") + return profile(rows[0]["user_id"]) + + +def visible_chat(chat_id, actor_id): + if not valid_uuid(chat_id): + raise ApiError(400, "invalid_request", "Invalid chat id") + rows = query("SELECT c.* FROM chats c JOIN members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s", (chat_id, actor_id)) + if not rows: + raise ApiError(404, "not_found", "Chat not found") + return chat_members(rows)[0] + + +def chat_members(rows): + if rows: + members = query("SELECT chat_id, user_id FROM members WHERE chat_id=ANY(%s::uuid[]) ORDER BY user_id", ([r["id"] for r in rows],)) + grouped = {r["id"]: [] for r in rows} + for m in members: + grouped[m["chat_id"]].append(m["user_id"]) + for row in rows: + row["member_ids"] = grouped[row["id"]] + return rows + + +def page_args(request, scope, limit, cursor): + if set(request.query_params).difference({"limit", "cursor"}): + raise ApiError(400, "invalid_request", "Invalid query parameters") + return limit, read_cursor(cursor, scope) if cursor is not None else None + + +def page(rows, limit, scope): + return {"items": rows[:limit], "next_cursor": make_cursor(scope, rows[limit-1]) if len(rows)>limit else None} +def request_id(request: Request) -> str: + return getattr(request.state, "request_id", str(uuid.uuid4())) + + +def error_response(request: Request, status: int, code: str, message: str) -> JSONResponse: + rid = request_id(request) + response = JSONResponse( + status_code=status, + content={"error": {"code": code, "message": message, "request_id": rid}}, + ) + response.headers["X-Request-Id"] = rid + if status == 401: + response.headers["WWW-Authenticate"] = ('Basic realm="messenger", charset="UTF-8"' + if request.url.path == "/api/v1/auth/sessions" else 'Bearer realm="messenger"') + return response + + +@app.middleware("http") +async def request_envelope(request: Request, call_next: Any) -> JSONResponse: + request.state.request_id = str(uuid.uuid4()) + try: + response = await call_next(request) + except Exception: + LOG.error("request_id=%s unexpected error", request_id(request)) + response = error_response(request, 500, "internal_error", "Internal server error") + response.headers["X-Request-Id"] = request_id(request) + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +@app.exception_handler(ApiError) +async def api_error_handler(request: Request, error: ApiError) -> JSONResponse: + return error_response(request, error.status, error.code, error.message) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(request: Request, _error: RequestValidationError) -> JSONResponse: + return error_response(request, 400, "invalid_request", "Request validation failed") + + +@app.exception_handler(StarletteHTTPException) +async def http_error_handler(request: Request, error: StarletteHTTPException) -> JSONResponse: + if error.status_code == 404: + return error_response(request, 404, "not_found", "Resource not found") + return error_response(request, error.status_code, "invalid_request", "Request failed") + + +async def require_json(request: Request) -> None: + content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower() + if content_type != "application/json": + raise ApiError(415, "unsupported_media_type", "Content-Type must be application/json") + + + +@app.exception_handler(psycopg.Error) +@app.exception_handler(PoolTimeout) +@app.exception_handler(TooManyRequests) +async def database_error(request, error): + return error_response(request, 503, "unavailable", "Database temporarily unavailable") + +@app.get("/health/live", response_model=Health) +def health_live(): + return {"status": "ok"} + +@app.get("/health/ready", response_model=Health) +def health_ready(): + query("SELECT 1 FROM schema_migrations LIMIT 1") + return {"status": "ok"} + +@app.post("/api/v1/users", response_model=User, status_code=201, dependencies=[Depends(require_json)]) +def create_user(payload: CreateUser): + password_hash = HASHER.hash(payload.password) + try: + return query("INSERT INTO users (id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING id,username,display_name,created_at", + (uuid.uuid4(), payload.username, payload.display_name, password_hash))[0] + except psycopg.errors.UniqueViolation: + raise ApiError(409, "conflict", "Username already exists") from None + +@app.post("/api/v1/auth/sessions", status_code=201) +async def login(request: Request, authorization: Optional[str] = Header(default=None)): + # CPU/SQL work runs in FastAPI's worker pool, not in the event loop. + from starlette.concurrency import run_in_threadpool + if await request.body(): + raise ApiError(400, "invalid_request", "Session request must not have a body") + return await run_in_threadpool(login_sync, authorization) + + +def login_sync(authorization): + try: + if not authorization or not authorization.startswith("Basic "): + raise ValueError + username, password = base64.b64decode(authorization[6:], validate=True).decode("utf-8").split(":", 1) + if not USERNAME_RE.fullmatch(username) or not 12 <= len(password) <= 128: + raise ValueError + except (ValueError, UnicodeError, binascii.Error): + raise ApiError(401, "unauthorized", "Invalid credentials") from None + users = query("SELECT * FROM users WHERE username=%s", (username,)) + try: + HASHER.verify(users[0]["password_hash"] if users else DUMMY_HASH, password) + except VerificationError: + raise ApiError(401, "unauthorized", "Invalid credentials") from None + if not users: + raise ApiError(401, "unauthorized", "Invalid credentials") + token = secrets.token_urlsafe(32) + expiry = query("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at", + (token_hash(token), users[0]["id"], TTL))[0]["expires_at"] + user = users[0] + del user["password_hash"] + return {"token": token, "token_type": "Bearer", "expires_at": expiry, "user": user} + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def logout(actor=Depends(current_user), authorization: Optional[str] = Header(default=None)): + query("DELETE FROM sessions WHERE token_hash=%s RETURNING user_id", (bearer(authorization),)) + return Response(status_code=204) + +@app.get("/api/v1/users/me", response_model=User) +def get_me(actor=Depends(current_user)): + return actor + +@app.post("/api/v1/chats", response_model=Chat, status_code=201, dependencies=[Depends(require_json)]) +def create_chat(payload: CreateChat, actor=Depends(current_user)): + members = [str(m) for m in payload.member_ids] + if actor["id"] not in members: + raise ApiError(400, "invalid_request", "The current user must be a member") + try: + with POOL.connection() as conn: + chat = wire(conn.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING *", (uuid.uuid4(),payload.title)).fetchone()) + with conn.cursor() as cur: + cur.executemany("INSERT INTO members(chat_id,user_id) VALUES (%s,%s)", [(chat["id"],m) for m in members]) + chat["member_ids"] = members + return chat + except psycopg.errors.ForeignKeyViolation: + raise ApiError(400, "invalid_request", "All chat members must exist") from None + +@app.get("/api/v1/chats", response_model=ChatPage) +def list_chats(request: Request, limit: int = Query(50,ge=1,le=100), cursor: Optional[str] = Query(None,min_length=1), actor=Depends(current_user)): + scope = "chats:" + actor["id"] + limit, after = page_args(request,scope,limit,cursor) + sql = "SELECT c.* FROM chats c JOIN members m ON c.id=m.chat_id WHERE m.user_id=%s" + params = [actor["id"]] + if after: + sql += " AND (c.created_at,c.id) > (%s,%s)" + params.extend(after) + rows = query(sql + " ORDER BY c.created_at,c.id LIMIT %s", params + [limit+1]) + return page(chat_members(rows),limit,scope) + +@app.get("/api/v1/chats/{chat_id}", response_model=Chat) +def get_chat(chat_id: str, actor=Depends(current_user)): + return visible_chat(chat_id,actor["id"]) + +@app.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201, dependencies=[Depends(require_json)]) +def create_message(chat_id: str, payload: CreateMessage, actor=Depends(current_user), + idempotency_key: Optional[str] = Header(default=None)): + visible_chat(chat_id, actor["id"]) + if not idempotency_key or not re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", idempotency_key): + raise ApiError(400, "invalid_request", "Valid Idempotency-Key required") + # A transaction-scoped lock serializes this key across all API processes. + scope = actor["id"] + ":" + str(uuid.UUID(chat_id)) + ":" + idempotency_key + lock = int.from_bytes(hashlib.sha256(scope.encode()).digest()[:8], "big", signed=True) + with POOL.connection() as conn: + conn.execute("SELECT pg_advisory_xact_lock(%s)", (lock,)) + row = conn.execute("SELECT m.*, i.expires_at FROM idempotency i JOIN messages m ON m.id=i.message_id WHERE i.user_id=%s AND i.chat_id=%s AND i.key=%s AND i.expires_at>clock_timestamp()", + (actor["id"], chat_id, idempotency_key)).fetchone() + if row: + row.pop("expires_at") + if row["text"] != payload.text: + raise ApiError(409, "conflict", "Key already used for another message") + return wire(row) + message = conn.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *", + (uuid.uuid4(),chat_id,actor["id"],payload.text)).fetchone() + conn.execute("INSERT INTO idempotency(user_id,chat_id,key,message_id,expires_at) VALUES (%s,%s,%s,%s,clock_timestamp()+interval '24 hours') ON CONFLICT (user_id,chat_id,key) DO UPDATE SET message_id=EXCLUDED.message_id, expires_at=EXCLUDED.expires_at", + (actor["id"],chat_id,idempotency_key,message["id"])) + return wire(message) + +@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) +def list_messages(request: Request, chat_id: str, limit: int = Query(50,ge=1,le=100), cursor: Optional[str] = Query(None,min_length=1), actor=Depends(current_user)): + visible_chat(chat_id,actor["id"]) + scope = "messages:" + chat_id + limit,after = page_args(request,scope,limit,cursor) + sql = "SELECT * FROM messages WHERE chat_id=%s" + params = [chat_id] + if after: + sql += " AND (created_at,id) > (%s,%s)" + params.extend(after) + return page(query(sql+" ORDER BY created_at,id LIMIT %s",params+[limit+1]),limit,scope) + +if __name__ == "__main__": + uvicorn.run(app, host=os.environ.get("APP_HOST","0.0.0.0"), port=env_int("APP_PORT",8080,1), timeout_graceful_shutdown=8, timeout_keep_alive=2) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..1e6e0cdf --- /dev/null +++ b/compose.yaml @@ -0,0 +1,64 @@ +name: mtusi-lab3 +x-app: &app + build: . + image: mtusi-messenger:lab3 + cpus: 0.5 + mem_limit: 256m + environment: + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + secrets: [database_url, cache_url] +services: + postgres: + image: postgres:16.6-bookworm + cpus: 1 + mem_limit: 512m + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: [postgres_password] + volumes: [postgres-data:/var/lib/postgresql/data] + healthcheck: + test: [CMD-SHELL, 'pg_isready -U messenger -d messenger'] + interval: 2s + timeout: 3s + retries: 30 + valkey: + image: valkey/valkey:8.0.2-alpine + cpus: 0.25 + mem_limit: 128m + command: [valkey-server, --appendonly, 'yes', --maxmemory, 64mb, --maxmemory-policy, allkeys-lru] + volumes: [valkey-data:/data] + migrate: + <<: *app + command: [python, app/migrate.py] + depends_on: + postgres: {condition: service_healthy} + api: + <<: *app + deploy: + replicas: 2 + stop_grace_period: 10s + depends_on: + migrate: {condition: service_completed_successfully} + valkey: {condition: service_started} + lb: + image: haproxy:3.0.5-alpine + cpus: 0.5 + mem_limit: 128m + ports: ['127.0.0.1:${HOST_PORT:-8080}:8080'] + volumes: ['./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro'] + depends_on: + api: {condition: service_healthy} +volumes: + postgres-data: + valkey-data: +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 00000000..9a553306 --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,2 @@ +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/containers.json b/evidence/containers.json new file mode 100644 index 00000000..46896de8 --- /dev/null +++ b/evidence/containers.json @@ -0,0 +1,59 @@ +[ + { + "name": "/mtusi-lab3-api-3", + "id": "066038d89cfde897fa86e495a6a5da9ef5f034246ed24068126e61bfaa5b575f", + "hostname": "066038d89cfd", + "image": "mtusi-messenger:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "published_ports": {}, + "status": "running" + }, + { + "name": "/mtusi-lab3-api-4", + "id": "383e40bbffdbc40d6b1616ce3047113cd0b1e5485d119bbb6faf82f429636d51", + "hostname": "383e40bbffdb", + "image": "mtusi-messenger:lab3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "published_ports": {}, + "status": "running" + }, + { + "name": "/mtusi-lab3-lb-1", + "id": "0a6d71637d552b19eeed1c4297aa4820e9c716de1834aa66dd069aa8c1bb0e12", + "hostname": "0a6d71637d55", + "image": "haproxy:3.0.5-alpine", + "nano_cpus": 500000000, + "memory_bytes": 134217728, + "published_ports": { + "8080/tcp": [ + { + "HostIp": "127.0.0.1", + "HostPort": "8080" + } + ] + }, + "status": "running" + }, + { + "name": "/mtusi-lab3-postgres-1", + "id": "7ca801989874fd05198a44e8766306706bb5bcde897b117c4be80c67d63dda17", + "hostname": "7ca801989874", + "image": "postgres:16.6-bookworm", + "nano_cpus": 1000000000, + "memory_bytes": 536870912, + "published_ports": {}, + "status": "running" + }, + { + "name": "/mtusi-lab3-valkey-1", + "id": "1c38b117111eb5e0e46338828bd03fc02d851548dce91f52332f4c000658a43b", + "hostname": "1c38b117111e", + "image": "valkey/valkey:8.0.2-alpine", + "nano_cpus": 250000000, + "memory_bytes": 134217728, + "published_ports": {}, + "status": "running" + } +] diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 00000000..470c896d --- /dev/null +++ b/evidence/failover.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 116, "failed_attempts": 2, "first_recovery_seconds": 1.682} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/grade4-run.txt b/evidence/grade4-run.txt new file mode 100644 index 00000000..10fd33ae --- /dev/null +++ b/evidence/grade4-run.txt @@ -0,0 +1,72 @@ + Container mtusi-lab3-api-2 Running + Container mtusi-lab3-api-3 Creating + Container mtusi-lab3-api-3 Created + Container mtusi-lab3-api-3 Starting + Container mtusi-lab3-api-3 Started + Container mtusi-lab3-api-3 Running + Container mtusi-lab3-api-4 Creating + Container mtusi-lab3-api-4 Created + Container mtusi-lab3-api-4 Starting + Container mtusi-lab3-api-4 Started +{ + "parallel_idempotency": { + "requests": 16, + "instances": [ + "5b0b704c3534", + "7c17ba154623" + ], + "messages": 1 + }, + "failures": [ + { + "duration_seconds": 7.974, + "successful_write_read_pairs": 699, + "successful_pairs_rps": 87.66, + "errors": 24, + "first_success_after_action_seconds": 0.997, + "max_success_gap_seconds": 1.051, + "action_seconds": 0.926, + "containers": { + "stopped": "7c17ba154623ae02d42f50ff1c64b391c7487a45e9cc90f8535a9e98801a2f99", + "hostname": "7c17ba154623", + "running": false + }, + "confirmed_messages_preserved": true + }, + { + "duration_seconds": 7.459, + "successful_write_read_pairs": 610, + "successful_pairs_rps": 81.78, + "errors": 25, + "first_success_after_action_seconds": 0.999, + "max_success_gap_seconds": 1.055, + "action_seconds": 0.421, + "containers": { + "stopped": "5b0b704c3534d18e438338ed89290ac8bc7636ad8abf492833548e385d2ffd19", + "hostname": "5b0b704c3534", + "running": false + }, + "confirmed_messages_preserved": true + } + ], + "rolling": { + "duration_seconds": 28.603, + "successful_write_read_pairs": 2834, + "successful_pairs_rps": 99.08, + "errors": 50, + "first_success_after_action_seconds": 0.013, + "max_success_gap_seconds": 1.025, + "action_seconds": 21.55, + "containers": { + "old_containers": [ + "7c17ba154623ae02d42f50ff1c64b391c7487a45e9cc90f8535a9e98801a2f99", + "5b0b704c3534d18e438338ed89290ac8bc7636ad8abf492833548e385d2ffd19" + ], + "new_containers": [ + "066038d89cfde897fa86e495a6a5da9ef5f034246ed24068126e61bfaa5b575f", + "383e40bbffdbc40d6b1616ce3047113cd0b1e5485d119bbb6faf82f429636d51" + ] + }, + "confirmed_messages_preserved": true + } +} diff --git a/evidence/grade4.json b/evidence/grade4.json new file mode 100644 index 00000000..6ba0fa48 --- /dev/null +++ b/evidence/grade4.json @@ -0,0 +1,62 @@ +{ + "parallel_idempotency": { + "requests": 16, + "instances": [ + "5b0b704c3534", + "7c17ba154623" + ], + "messages": 1 + }, + "failures": [ + { + "duration_seconds": 7.974, + "successful_write_read_pairs": 699, + "successful_pairs_rps": 87.66, + "errors": 24, + "first_success_after_action_seconds": 0.997, + "max_success_gap_seconds": 1.051, + "action_seconds": 0.926, + "containers": { + "stopped": "7c17ba154623ae02d42f50ff1c64b391c7487a45e9cc90f8535a9e98801a2f99", + "hostname": "7c17ba154623", + "running": false + }, + "confirmed_messages_preserved": true + }, + { + "duration_seconds": 7.459, + "successful_write_read_pairs": 610, + "successful_pairs_rps": 81.78, + "errors": 25, + "first_success_after_action_seconds": 0.999, + "max_success_gap_seconds": 1.055, + "action_seconds": 0.421, + "containers": { + "stopped": "5b0b704c3534d18e438338ed89290ac8bc7636ad8abf492833548e385d2ffd19", + "hostname": "5b0b704c3534", + "running": false + }, + "confirmed_messages_preserved": true + } + ], + "rolling": { + "duration_seconds": 28.603, + "successful_write_read_pairs": 2834, + "successful_pairs_rps": 99.08, + "errors": 50, + "first_success_after_action_seconds": 0.013, + "max_success_gap_seconds": 1.025, + "action_seconds": 21.55, + "containers": { + "old_containers": [ + "7c17ba154623ae02d42f50ff1c64b391c7487a45e9cc90f8535a9e98801a2f99", + "5b0b704c3534d18e438338ed89290ac8bc7636ad8abf492833548e385d2ffd19" + ], + "new_containers": [ + "066038d89cfde897fa86e495a6a5da9ef5f034246ed24068126e61bfaa5b575f", + "383e40bbffdbc40d6b1616ce3047113cd0b1e5485d119bbb6faf82f429636d51" + ] + }, + "confirmed_messages_preserved": true + } +} diff --git a/evidence/migrations.txt b/evidence/migrations.txt new file mode 100644 index 00000000..a78ef62b --- /dev/null +++ b/evidence/migrations.txt @@ -0,0 +1,6 @@ + Container mtusi-lab3-postgres-1 Running + Container mtusi-lab3-postgres-1 Waiting + Container mtusi-lab3-postgres-1 Healthy + Container mtusi-lab3-migrate-run-d2961d8a585a Creating + Container mtusi-lab3-migrate-run-d2961d8a585a Created +Migrations OK diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..933c59c7 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/restart-containers.json b/evidence/restart-containers.json new file mode 100644 index 00000000..109e73b5 --- /dev/null +++ b/evidence/restart-containers.json @@ -0,0 +1,27 @@ +{ + "/mtusi-lab3-api-3": { + "before": "2026-11-12T19:02:20.076228592Z", + "after": "2026-11-12T19:03:15.056269715Z", + "changed": true + }, + "/mtusi-lab3-api-4": { + "before": "2026-11-12T19:02:29.221614722Z", + "after": "2026-11-12T19:03:15.067598256Z", + "changed": true + }, + "/mtusi-lab3-lb-1": { + "before": "2026-11-12T19:01:18.778681508Z", + "after": "2026-11-12T19:03:14.902540756Z", + "changed": true + }, + "/mtusi-lab3-postgres-1": { + "before": "2026-11-12T19:01:09.981673754Z", + "after": "2026-11-12T19:03:14.91825534Z", + "changed": true + }, + "/mtusi-lab3-valkey-1": { + "before": "2026-11-12T19:01:10.057038421Z", + "after": "2026-11-12T19:03:14.933475131Z", + "changed": true + } +} diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..88517e6f --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/validate.txt b/evidence/validate.txt new file mode 100644 index 00000000..933ee48e --- /dev/null +++ b/evidence/validate.txt @@ -0,0 +1,4 @@ +.venv/bin/python scripts/validate_openapi.py +/Users/sleepy13/Documents/Codex/2026-11-12/referenced-chatgpt-conversation-this-is-an/outputs/mtusi2026lab3/.venv/lib/python3.9/site-packages/urllib3/__init__.py:35: NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020 + warnings.warn( +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..06075f2c --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,26 @@ +global + log stdout format raw local0 + maxconn 256 +defaults + log global + mode http + timeout connect 1s + timeout client 15s + timeout server 10s + timeout check 1s + retries 0 +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + hold obsolete 1s +frontend public + bind :8080 + default_backend api +backend api + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + server-template replica 10 api:8080 check inter 1s fall 2 rise 1 resolvers docker init-addr libc,none diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..4b0c2805 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,13 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name varchar(100) NOT NULL CHECK (length(trim(display_name))>0), + password_hash text NOT NULL, created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chats (id uuid PRIMARY KEY, title varchar(100) NOT NULL CHECK(length(trim(title))>0), created_at timestamptz NOT NULL DEFAULT clock_timestamp()); +CREATE TABLE members (chat_id uuid REFERENCES chats(id), user_id uuid REFERENCES users(id), PRIMARY KEY(chat_id,user_id)); +CREATE INDEX members_user_chat ON members(user_id,chat_id); +CREATE TABLE messages (id uuid PRIMARY KEY, chat_id uuid NOT NULL REFERENCES chats(id), sender_id uuid NOT NULL REFERENCES users(id), text varchar(4000) NOT NULL CHECK(length(trim(text))>0), created_at timestamptz NOT NULL DEFAULT clock_timestamp(), FOREIGN KEY(chat_id,sender_id) REFERENCES members(chat_id,user_id)); +CREATE INDEX messages_history ON messages(chat_id,created_at,id); +CREATE INDEX chats_order ON chats(created_at,id); +CREATE TABLE sessions (token_hash char(64) PRIMARY KEY, user_id uuid NOT NULL REFERENCES users(id), expires_at timestamptz NOT NULL); +CREATE INDEX sessions_expiry ON sessions(expires_at); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..241d18cd --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,8 @@ +CREATE TABLE idempotency ( + user_id uuid NOT NULL REFERENCES users(id), + chat_id uuid NOT NULL REFERENCES chats(id), + key varchar(128) NOT NULL, + message_id uuid NOT NULL REFERENCES messages(id), + expires_at timestamptz NOT NULL, + PRIMARY KEY(user_id, chat_id, key) +); diff --git a/scripts/bootstrap.py b/scripts/bootstrap.py new file mode 100644 index 00000000..26ef5035 --- /dev/null +++ b/scripts/bootstrap.py @@ -0,0 +1,22 @@ +"""Generate local-only synthetic credentials once; never overwrite them.""" +import os +import secrets +from pathlib import Path +root = Path(__file__).resolve().parents[1] +os.umask(0o077) +(root / "secrets").mkdir(exist_ok=True) +p = root / "secrets/postgres_password" +if not p.exists(): + p.write_text(secrets.token_hex(32)) +values = {"database_url": "postgresql://messenger:" + p.read_text().strip() + "@postgres:5432/messenger", "cache_url": "redis://valkey:6379/0"} +for name, value in values.items(): + dest = root / "secrets" / name + if not dest.exists(): + dest.write_text(value) +# Docker Desktop bind-mounted secrets need read permission for container UID 10001. +for name in ["postgres_password", "database_url", "cache_url"]: + (root / "secrets" / name).chmod(0o644) +env = root / ".env" +if not env.exists(): + env.write_text("SESSION_TTL_SECONDS=3600\nHOST_PORT=8080\n") +print("Local configuration ready (secrets not printed)") diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..e00184ad --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose restart postgres valkey api lb diff --git a/scripts/rolling.py b/scripts/rolling.py new file mode 100644 index 00000000..b0d07ff4 --- /dev/null +++ b/scripts/rolling.py @@ -0,0 +1,33 @@ +"""Replace each original API container, keeping its peer available.""" +import json +import subprocess +import time +from pathlib import Path +import os +os.chdir(Path(__file__).resolve().parents[1]) + +def command(*args): + return subprocess.check_output(args, text=True) + +def ready(): + deadline = time.monotonic() + 60 + while time.monotonic() < deadline: + ids = command('docker','compose','ps','-q','api').split() + states = json.loads(command('docker','inspect',*ids)) if ids else [] + if len(states) == 2 and all(x['State'].get('Health',{}).get('Status')=='healthy' for x in states): + time.sleep(3) # allow HAProxy readiness/DNS to converge + return + time.sleep(.5) + raise RuntimeError('API did not become healthy') + +if __name__ == '__main__': + ready() + old = command('docker','compose','ps','-q','api').split() + for container in old: + command('docker','stop','-t','8',container) + command('docker','rm',container) + command('docker','compose','up','-d','--no-deps','--no-build','--scale','api=2','api') + ready() + new = command('docker','compose','ps','-q','api').split() + assert not set(old) & set(new) + print(json.dumps({'old_containers':old,'new_containers':new})) diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..6213272d --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,13 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +: "${TARGET_INSTANCE_ID:?Set TARGET_INSTANCE_ID to an API hostname}" +for id in $(docker compose ps -q api); do + hostname=$(docker inspect -f '{{.Config.Hostname}}' "$id") + if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then + docker stop -t 8 "$id" + exit 0 + fi +done +echo 'Target is not a running API replica in this project' >&2 +exit 1 diff --git a/student-tests/verify.py b/student-tests/verify.py new file mode 100644 index 00000000..42527d1a --- /dev/null +++ b/student-tests/verify.py @@ -0,0 +1,101 @@ +"""Grade-4 evidence: shared idempotency, each replica failure, rolling load.""" +import concurrent.futures +import json +import os +from pathlib import Path +import subprocess +import sys +import threading +import time +import uuid +ROOT = Path(__file__).resolve().parents[1] +os.chdir(ROOT) +sys.path.insert(0,str(ROOT/'tests')) +sys.path.insert(0,str(ROOT/'scripts')) +from client import Client, Failure +from resilience import history +from rolling import command, ready +base = os.environ.get('BASE_URL','http://localhost:8080') +ready() +c = Client(base) +a,b,_,chat = c.bootstrap() +key = uuid.uuid4().hex +barrier = threading.Barrier(16) +def duplicate(_): + barrier.wait() + return Client(base).message(a,chat,'Одна запись при гонке',key=key) +with concurrent.futures.ThreadPoolExecutor(16) as pool: + replies = list(pool.map(duplicate,range(16))) +assert len({r['json']['id'] for r in replies})==1 +instances = {r['headers']['X-Instance-Id'] for r in replies} +assert len(instances)==2 +assert len(history(c,b,chat))==1 +# Auth and conflict are still checked on replay. +c.call('POST','/api/v1/chats/'+chat['id']+'/messages',409,actor=a,body={'text':'different'},headers={'Idempotency-Key':key}) +result={'parallel_idempotency':{'requests':16,'instances':sorted(instances),'messages':1}, 'failures':[]} + +def workload(action): + stop = threading.Event() + started=time.monotonic() + confirmed=[] + times=[] + errors=[] + latencies=[] + lock=threading.Lock() + def worker(n): + local=Client(base,timeout=2) + pending=uuid.uuid4().hex + while not stop.is_set(): + t=time.monotonic() + try: + msg=local.message(a,chat,pending,key=pending)['json'] + local.call('GET','/api/v1/users/me',actor=a,schema='User') + with lock: + confirmed.append(msg); times.append(time.monotonic()); latencies.append(time.monotonic()-t) + pending=uuid.uuid4().hex + except Failure: + with lock: errors.append(time.monotonic()) + time.sleep(.02) + with concurrent.futures.ThreadPoolExecutor(4) as pool: + workers=[pool.submit(worker,n) for n in range(4)] + time.sleep(2) + action_start=time.monotonic() + try: + details=action() + action_end=time.monotonic() + time.sleep(5) + finally: + stop.set() + for w in workers: w.result() + elapsed=time.monotonic()-started + data=history(c,b,chat) + ids={m['id'] for m in data} + assert all(m['id'] in ids for m in confirmed) + assert len({m['text'] for m in data})==len(data), 'duplicate message after retry' + after=[t for t in times if t>=action_end] + assert after + gaps=[y-x for x,y in zip(sorted(times),sorted(times)[1:])] + assert max(gaps,default=0)<10 + return {'duration_seconds':round(elapsed,3),'successful_write_read_pairs':len(times), + 'successful_pairs_rps':round(len(times)/elapsed,2),'errors':len(errors), + 'first_success_after_action_seconds':round(min(after)-action_end,3), + 'max_success_gap_seconds':round(max(gaps,default=0),3), + 'action_seconds':round(action_end-action_start,3),'containers':details, + 'confirmed_messages_preserved':True} + +original=command('docker','compose','ps','-q','api').split() +for container in original: + hostname=json.loads(command('docker','inspect',container))[0]['Config']['Hostname'] + def stop_one(): + subprocess.run(['scripts/stop-one.sh'],check=True,env=dict(os.environ,TARGET_INSTANCE_ID=hostname),stdout=subprocess.DEVNULL) + state=json.loads(command('docker','inspect',container))[0]['State'] + assert not state['Running'] + return {'stopped':container,'hostname':hostname,'running':state['Running']} + try: + result['failures'].append(workload(stop_one)) + finally: + command('docker','start',container) + ready() +result['rolling']=workload(lambda:json.loads(command(sys.executable,'scripts/rolling.py'))) +Path('evidence/grade4.json').write_text(json.dumps(result,ensure_ascii=False,indent=2)+'\n') +print(json.dumps(result,ensure_ascii=False,indent=2))