25 changed files with 1228 additions and 23 deletions
+11
View File
@@ -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"]
+27
View File
@@ -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 описывает решение.
+143 -23
View File
@@ -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=<hostname API из docker inspect> 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 различны.
+21
View File
@@ -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")
+20
View File
@@ -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
+481
View File
@@ -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)
+64
View File
@@ -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
+2
View File
@@ -0,0 +1,2 @@
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+59
View File
@@ -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"
}
]
+4
View File
@@ -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.
+72
View File
@@ -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
}
}
+62
View File
@@ -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
}
}
+6
View File
@@ -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
+3
View File
@@ -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.
+27
View File
@@ -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
}
}
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
+4
View File
@@ -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.
+26
View File
@@ -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
+13
View File
@@ -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);
+8
View File
@@ -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)
);
+22
View File
@@ -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)")
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose restart postgres valkey api lb
+33
View File
@@ -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}))
+13
View File
@@ -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
+101
View File
@@ -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))