forked from mtusi2026/mtusi2026lab3
Compare commits
4
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9160e89a01 | ||
|
|
9783f4cbcd | ||
|
|
ddbc011e2c | ||
|
|
7da034885f |
+11
@@ -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"]
|
||||
@@ -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 описывает решение.
|
||||
@@ -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 различны.
|
||||
|
||||
@@ -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")
|
||||
@@ -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
@@ -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)
|
||||
@@ -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
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
@@ -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"
|
||||
}
|
||||
]
|
||||
@@ -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.
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -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.
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -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.
|
||||
@@ -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
|
||||
@@ -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);
|
||||
@@ -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)
|
||||
);
|
||||
@@ -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)")
|
||||
Executable
+4
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose restart postgres valkey api lb
|
||||
@@ -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}))
|
||||
Executable
+13
@@ -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
|
||||
@@ -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))
|
||||
Reference in New Issue
Block a user