ЛР 2 — БВТ2301 — Чиняева — на 4 #157

Closed
aliror wants to merge 4 commits from aliror/mtusi2026lab2-Chinyaeva:solution/BVT2301-Chinyaeva into master
43 changed files with 2048 additions and 22 deletions
+21 -7
View File
@@ -1,11 +1,25 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Copy to .env for a LOCAL synthetic test environment; never commit .env.
# These values are examples for an isolated stand, not real credentials.
APP_HOST=0.0.0.0
APP_PORT=8080
API_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
POSTGRES_DB=messenger
POSTGRES_USER=messenger
# Replace this local-only value before starting the stand; use the SAME value
# inside DATABASE_URL below (kept explicit for readability of the example).
POSTGRES_PASSWORD=change-me-local-synthetic-password
DATABASE_URL=postgresql://messenger:change-me-local-synthetic-password@postgres:5432/messenger
CACHE_URL=redis://redis:6379/0
# Bounded PostgreSQL pool and timeouts.
DB_POOL_MIN=1
DB_POOL_MAX=10
DB_POOL_ACQUIRE_TIMEOUT_SECONDS=3
DB_CONNECT_TIMEOUT_SECONDS=3
DB_STATEMENT_TIMEOUT_MS=5000
REDIS_CONNECT_TIMEOUT_SECONDS=2
REDIS_SOCKET_TIMEOUT_SECONDS=2
MAX_BODY_BYTES=1048576
+6
View File
@@ -0,0 +1,6 @@
* text=auto
*.sh text eol=lf
*.cmd text eol=crlf
Dockerfile text eol=lf
Makefile text eol=lf
*.sql text eol=lf
+31
View File
@@ -0,0 +1,31 @@
# Runtime image for the lab2 API. The base tag is pinned; dependencies are
# installed from requirements.txt, never from a mutable latest tag.
FROM python:3.12.7-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /app
RUN groupadd --system --gid 10001 app \
&& useradd --system --uid 10001 --gid app --home-dir /app --shell /usr/sbin/nologin app
COPY requirements.txt ./
RUN python -m pip install --requirement requirements.txt
COPY app ./app
COPY migrations ./migrations
COPY student-tests ./student-tests
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=6 \
CMD ["python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()"]
# One process with a bounded thread pool is enough for lab2. The database
# pool itself fixes the number of PostgreSQL connections.
CMD ["gunicorn", "--bind=0.0.0.0:8080", "--workers=1", "--threads=8", "--timeout=30", "--graceful-timeout=10", "--access-logfile=-", "--error-logfile=-", "app.main:app"]
+15 -1
View File
@@ -4,10 +4,17 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence up down test-student test-expiry
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "up/down: local compose stack; test-student: negative/race checks; test-expiry: short-TTL check"
up:
docker compose --env-file .env up -d --build
down:
docker compose --env-file .env down
check:
$(PYTHON) scripts/check_contract.py
@@ -24,3 +31,10 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-student:
$(PYTHON) student-tests/auth_negative.py --base-url "$(BASE_URL)"
$(PYTHON) student-tests/race_username.py --base-url "$(BASE_URL)"
test-expiry:
$(PYTHON) student-tests/expiry.py --base-url "$(BASE_URL)"
+137 -14
View File
@@ -1,37 +1,160 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Чиняева, БВТ2301
- Целевая оценка: **4**; трек 5 не заявлен.
- Commit/PR: ветка `solution/BVT2301-Chinyaeva` в форке; PR #157 в исходный
репозиторий курса — https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/157.
Основной коммит реализации: `df31f4a`.
- Использованные источники, библиотеки и помощь ИИ: официальная документация PostgreSQL
(транзакции, EXPLAIN, keyset pagination), Redis (AOF/expiry), RFC 7617 (Basic), Flask,
psycopg 3, redis-py, argon2-cffi, gunicorn. ИИ-ассистент использовался для генерации
черновика кода, проверки контракта и подготовки отчёта; все команды и результаты ниже
воспроизведены на локальном стенде.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Стенд проверялся на Windows 11 + Docker Desktop 29.9.2 (16 logical CPU, ~15.2 GiB
доступно Docker). Образы закреплены тегами, `latest` не используется:
| Роль | Образ/рантайм | Порт/volume |
| --- | --- | --- |
| API | `python:3.12.7-slim-bookworm`, gunicorn 23.0.0, Flask 3.1.0 | `8080` (публикуется Docker) |
| PostgreSQL | `postgres:16.4-alpine` | `5432` внутри сети, `pgdata` |
| Redis | `redis:7.4.0-alpine`, AOF `everysec` | `6379` внутри сети, `redisdata` |
```sh
git clone <fork-url>
cd mtusi2026lab2-Chinyaeva
# Локальные синтетические credentials; .env находится в .gitignore.
cp .env.example .env
docker compose --env-file .env up -d --build
# ждать готовности, не только /health/live:
until curl -fsS http://localhost:8080/health/ready; do sleep 1; done
make test BASE_URL=http://localhost:8080
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080
```
На проверочной машине порт 8080 был занят WSL, поэтому локально использовался
`API_PORT=18080` в `.env`; это единственное отличие от команд выше. `restart.sh`
предназначен для Linux/macOS, `restart.cmd` — эквивалент для Windows. Оба выполняют
`docker compose restart` и **не удаляют volumes**.
Остановка и намеренное удаление учебных данных:
```sh
docker compose --env-file .env down # остановка, данные сохраняются
docker compose --env-file .env down -v # ТОЛЬКО осознанный сброс volumes
rm .env # локальные credentials
```
Секреты не попадают в Git: `.env`, `secrets/`, `*.key`, `*.pem` уже перечислены в
`.gitignore`; `compose.yaml` получает `DATABASE_URL`/`CACHE_URL` из окружения.
`postgres` и `redis` не публикуют порты на хост, API общается с ними по внутренней сети.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
client --HTTP--> api (gunicorn/Flask, 1 process, 8 threads)
|-- PostgreSQL: users, chats, chat_members, messages (источник истины)
'-- Redis: session:<sha256(token)> -> {user_id, expires_at}, TTL
```
- **PostgreSQL — источник истины** для пользователей, чатов, членства и сообщений.
Все запросы параметризованы (`%s`), SQL собирается только из фиксированных фрагментов.
- **Redis — хранилище активных сессий.** В ключ пишется SHA-256 от bearer-токена, сам
токен в Redis не хранится. `SESSION_TTL_SECONDS` (по умолчанию 3600) — единственная
политика продления: TTL не скользит и не продлевается рестартом. Logout удаляет ключ.
Источник истины для сессий — Redis; для пользователей/сообщений — PostgreSQL. Если
Redis потеряет данные, пользователи и сообщения останутся, но сессии станут
недействительными (401). AOF `appendfsync everysec` + `redisdata` переживают
штатный рестарт; при потере питания возможна потеря до ~1 секунды последних записей.
- **Миграции** лежат в `migrations/001_init.sql` и применяются при старте API под
`pg_advisory_lock`; версия фиксируется в `schema_migrations`, повторный запуск
пропускает уже применённую миграцию и не дублирует данные.
- **Транзакционные границы.** Создание чата и всех `chat_members` — одна транзакция;
сбой вставки участника откатывает чат (проверено инъекцией trigger). Регистрация
опирается на `UNIQUE(username)`; конкурентная гонка даёт один `201`, остальные `409`.
- **Пул и таймауты.** `psycopg_pool` 1–10 соединений, acquire timeout 3 с;
`statement_timeout=5s`, `idle_in_transaction_session_timeout=10s`,
`lock_timeout=3s`; Redis socket/connect timeout 2 с. При недоступности зависимости
API возвращает ограниченный `503 unavailable`, а не `200`/`401` с анонимным доступом.
- **Индексы.** `messages(chat_id, created_at, id)` обслуживает keyset-запрос
`WHERE chat_id=? AND (created_at,id)>(?,?) ORDER BY created_at,id LIMIT ?`.
`chats(created_at,id)` — порядок списка чатов; `chat_members(user_id,chat_id)` —
выборка чатов пользователя; `users.username` уникален.
- **Ошибки и заголовки.** Каждый ответ, включая 204/health/ошибки, содержит
`X-Request-Id`; тело ошибки — `{"error":{"code","message","request_id"}}` с тем же
`request_id`. Basic принимается только на `POST /auth/sessions`; бизнес-endpoint
требуют Bearer. `X-User-Id` игнорируется. Пароли — Argon2id (argon2-cffi), не SHA-256.
## Доказательства критериев
Все команды выполнялись 2026-11-06 на указанном стенде; файлы лежат в `evidence/`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Offline-структура и синтаксис | `python scripts/check_contract.py` (`make check`) | `PASS: offline skeleton structure...` | `evidence/check.txt` |
| Публичный smoke уровня 3 | `python tests/smoke.py --base-url http://localhost:18080` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` |
| Все данные и сессия переживают рестарт API+БД+Redis | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:18080` | `PASS: persistence preserved confirmed data and existing session`; контейнеры до/после рестарта | `evidence/persistence.txt`, `evidence/containers-before-restart.txt`, `evidence/containers-after-restart.txt` |
| PostgreSQL: таблицы, PK/FK, уникальность, миграции | `psql`-запросы к `information_schema`/`pg_indexes`/`schema_migrations` | 5 таблиц, 9 индексов, `001_init`; повторный старт не дублирует | `evidence/schema.txt` |
| Redis/Valkey с TTL и persistence | `redis-cli INFO persistence`, `DBSIZE`, `TTL session:*` | `aof_enabled:1`, `aof_last_write_status:ok`, TTL сессии ~3486 с | `evidence/redis.txt` |
| Ограниченный пул и SQL-таймауты | `docker compose exec -T api python student-tests/pool_settings.py` | `statement_timeout=5s`, pool 1–10, acquire timeout 3 с | `evidence/pool_settings.txt` |
| Гонка регистрации username | `python student-tests/race_username.py --workers 8` | ровно один `201`, семь `409`, затем успешный вход | `evidence/race_username.txt` |
| Откат составной операции | `docker compose exec -T api python student-tests/rollback_chat.py` | после сбоя вставки участника чата нет; следующий чат создаётся | `evidence/rollback_chat.txt` |
| Индекс истории и EXPLAIN на ≥10 000 сообщений | `docker compose exec -T api python student-tests/explain_history.py` | `Index Scan using messages_chat_created_at_id_idx`, `rows=51`, `shared hit=4`, 0.124 ms | `evidence/explain_history.txt` |
| Expiry при коротком TTL | API с `SESSION_TTL_SECONDS=10`, `python student-tests/expiry.py --wait 12` | свежая сессия `200`, через 12 с — `401` + Bearer challenge | `evidence/expiry.txt` |
| Неверный пароль, Basic на бизнес-endpoint, logout | `python student-tests/auth_negative.py` | `401 Basic` / `401 Bearer` / `204`, повторный logout `401` | `evidence/auth_negative.txt` |
| Недоступность Redis и PostgreSQL | `python student-tests/fault_matrix.py` | в обоих случаях `503 unavailable`; после старта Redis readiness 0.48 с, PostgreSQL 3.01 с; тот же токен снова `200` | `evidence/fault_matrix.txt` |
| Граничные случаи контракта | локальный edge-сценарий | extra fields/пустое тело/неизвестный участник/чужой cursor/4001 символ — `400`; лимит ровно `limit` даёт `next_cursor=null` | `evidence/edge_cases.txt` |
| Нагрузочный профиль (не доказательство capacity) | `python tests/load.py --duration 15 --concurrency 4 --output evidence/load.json` | 2599 успешных POST, 0 ошибок, 172.7 RPS, p50 22.96 ms / p95 38.87 ms / p99 44.76 ms | `evidence/load.json`, `evidence/load.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Комментарии к доказательствам
- `explain_history.txt` получен после `ANALYZE` на 10 000 сообщениях в одном чате.
План — `Index Scan`, а не `Seq Scan`; на страницу читается 51 строка, а не вся история.
Это подтверждает отсутствие полного скана на каждую страницу.
- `fault_matrix.txt` отдельно показывает, что при отказе Redis уже выданный bearer-токен
не превращается в анонимный доступ: запрос возвращает `503`, а после восстановления
AOF тот же токен снова даёт `200`.
- `persistence.txt` дополнен `containers-*.txt`: в `after` все три контейнера имеют
статус `Up` с малым временем работы, то есть hook действительно перезапустил API,
PostgreSQL и Redis, а не только приложение.
- `evidence/redis.txt` содержит только хэш ключа сессии (`session:<sha256>`), не токен.
В отчёте и evidence нет паролей, токенов и приватных ключей.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Стенд: один Docker host, API + PostgreSQL + Redis в одной Compose-сети; синтетические
пользователи и сообщения. Это не проверка HA и не production-сертификат.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose restart` (API+PostgreSQL+Redis), volumes сохранены | данные и прежний токен живы | `PASS` persistence; контейнеры перезапущены | данные не потеряны; TTL сессии не продлён рестартом |
| Остановка Redis | readiness/запросы с Bearer — `503`, не `200` и не доверенный аноним | `503 unavailable` на `/health/ready` и `/users/me` | после `start redis` readiness 0.48 с; тот же токен `200` (AOF) |
| Остановка PostgreSQL | readiness/запросы — `503` | `503 unavailable` на `/health/ready` и `/users/me` | после `start postgres` readiness 3.01 с; тот же токен `200` |
| Инъекция ошибки во вставку `chat_members` | чат не должен остаться | API вернул ограниченный `500 internal_error`, строки чата нет | целостность восстановлена откатом транзакции |
| 8 одновременных регистраций одного username | ровно один пользователь | один `201`, семь `409 conflict` | дубликатов нет |
Ограничения измерения нагрузки: `tests/load.py` — closed-loop генератор, клиент и
сервер на одном хосте; 172.7 RPS отражают HTTP-подтверждения в этом стенде, а не
предел PostgreSQL. В отчёте нет универсального проходного RPS.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один API-процесс и один Docker host: отказ хоста, потеря БД или единственного Redis
не компенсируются. Горизонтальное масштабирование и LB — задача lab3.
- Redis хранит только сессии; при полной потере AOF активные сессии исчезнут, но
пользователи, чаты и сообщения в PostgreSQL останутся. Это осознанная граница:
сессия — не бизнес-данные.
- AOF `everysec` допускает потерю до ~1 секунды последних сессионных записей при
аварийном завершении хоста; штатный рестарт проверен. Для production нужен
отдельный анализ durability/backup.
- HTTP без TLS допустим только для локального изолированного стенда с синтетическими
данными; для удалённой демонстрации нужен TLS (lab7).
- Нет rate limiting, публичного поиска пользователей, WebSocket и UI — они не входят
в обязательный минимум lab2.
- Следующий шаг для lab3: ≥2 API-реплики, общий LB, `Idempotency-Key` и `X-Instance-Id`,
проверка failover и отсутствия дублей.
+1
View File
@@ -0,0 +1 @@
# Messenger API for MTUSI high-load course, laboratory 2.
+72
View File
@@ -0,0 +1,72 @@
"""Runtime configuration.
The application never embeds credentials. Local Compose passes environment
variables from an ignored .env file; *_FILE variants are accepted as well so a
container platform can mount secrets without copying them into the image.
"""
from __future__ import annotations
import os
from dataclasses import dataclass
from pathlib import Path
def _value(name: str, fallback_name: str | None = None, default: str | None = None) -> str:
raw = os.environ.get(name)
if raw:
return raw
if fallback_name:
filename = os.environ.get(fallback_name)
if filename:
path = Path(filename)
text = path.read_text(encoding="utf-8").strip()
if text:
return text
if default is not None:
return default
raise RuntimeError(f"missing required configuration: {name}")
def _positive_int(name: str, default: int) -> int:
raw = os.environ.get(name, str(default))
try:
value = int(raw)
except ValueError as exc:
raise RuntimeError(f"{name} must be an integer") from exc
if value < 1:
raise RuntimeError(f"{name} must be positive")
return value
@dataclass(frozen=True)
class Settings:
database_url: str
cache_url: str
session_ttl_seconds: int
db_pool_min: int
db_pool_max: int
db_pool_acquire_timeout: float
db_connect_timeout: int
db_statement_timeout_ms: int
redis_connect_timeout: float
redis_socket_timeout: float
max_body_bytes: int
def load_settings() -> Settings:
return Settings(
database_url=_value("DATABASE_URL", "DATABASE_URL_FILE"),
cache_url=_value("CACHE_URL", "CACHE_URL_FILE"),
session_ttl_seconds=_positive_int("SESSION_TTL_SECONDS", 3600),
db_pool_min=_positive_int("DB_POOL_MIN", 1),
db_pool_max=_positive_int("DB_POOL_MAX", 10),
db_pool_acquire_timeout=float(os.environ.get("DB_POOL_ACQUIRE_TIMEOUT_SECONDS", "3")),
db_connect_timeout=_positive_int("DB_CONNECT_TIMEOUT_SECONDS", 3),
db_statement_timeout_ms=_positive_int("DB_STATEMENT_TIMEOUT_MS", 5000),
redis_connect_timeout=float(os.environ.get("REDIS_CONNECT_TIMEOUT_SECONDS", "2")),
redis_socket_timeout=float(os.environ.get("REDIS_SOCKET_TIMEOUT_SECONDS", "2")),
max_body_bytes=_positive_int("MAX_BODY_BYTES", 1024 * 1024),
)
settings = load_settings()
+118
View File
@@ -0,0 +1,118 @@
"""PostgreSQL access: bounded pool, timeouts, and versioned migrations."""
from __future__ import annotations
import logging
import threading
import time
from pathlib import Path
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
from .config import settings
log = logging.getLogger("messenger.db")
MIGRATIONS_DIR = Path(__file__).resolve().parents[1] / "migrations"
LOCK_ID = 0x4D545553 # stable application-wide advisory lock
_pool: ConnectionPool | None = None
_pool_lock = threading.Lock()
_migrated = threading.Event()
_started = False
_start_lock = threading.Lock()
def _create_pool() -> ConnectionPool:
options = (
f"-c statement_timeout={settings.db_statement_timeout_ms} "
"-c idle_in_transaction_session_timeout=10000 "
"-c lock_timeout=3000"
)
return ConnectionPool(
conninfo=settings.database_url,
min_size=settings.db_pool_min,
max_size=settings.db_pool_max,
timeout=settings.db_pool_acquire_timeout,
open=False,
kwargs={
"row_factory": dict_row,
"connect_timeout": settings.db_connect_timeout,
"application_name": "mtusi-messenger-lab2",
"options": options,
},
)
def pool() -> ConnectionPool:
global _pool
with _pool_lock:
if _pool is None:
_pool = _create_pool()
return _pool
def apply_migrations() -> None:
"""Apply every migration exactly once.
A session-level advisory lock serialises concurrent API workers/restarts.
Each migration and its schema_migrations row share one transaction.
"""
with pool().connection() as conn:
conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
try:
conn.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT clock_timestamp()
)
"""
)
applied = {
row["version"]
for row in conn.execute("SELECT version FROM schema_migrations").fetchall()
}
for path in sorted(MIGRATIONS_DIR.glob("*.sql")):
version = path.stem
if version in applied:
continue
log.info("applying migration %s", version)
conn.execute(path.read_text(encoding="utf-8"))
conn.execute(
"INSERT INTO schema_migrations(version) VALUES (%s)", (version,)
)
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,))
def start_background_initialisation() -> None:
"""Open the pool and migrate without making /health/live depend on PostgreSQL."""
global _started
with _start_lock:
if _started:
return
_started = True
def run() -> None:
backoff = 0.5
opened = False
while True:
try:
if not opened:
pool().open(wait=True, timeout=5)
opened = True
apply_migrations()
_migrated.set()
log.info("database pool is ready and schema is migrated")
return
except Exception as exc: # startup is retried; request path stays bounded
log.warning("database initialisation is not ready: %s", type(exc).__name__)
time.sleep(backoff)
backoff = min(backoff * 2, 5.0)
threading.Thread(target=run, name="db-init", daemon=True).start()
def is_migrated() -> bool:
return _migrated.is_set()
+36
View File
@@ -0,0 +1,36 @@
"""Typed public errors. Internal details never cross the HTTP boundary."""
from __future__ import annotations
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers: dict[str, str] | None = None):
super().__init__(message)
self.status = status
self.code = code
self.message = message
self.headers = headers or {}
def bad_request(message: str = "Некорректный запрос") -> ApiError:
return ApiError(400, "invalid_request", message)
def unauthorized(*, basic: bool = False) -> ApiError:
challenge = (
'Basic realm="messenger", charset="UTF-8"'
if basic
else 'Bearer realm="messenger"'
)
return ApiError(401, "unauthorized", "Требуется аутентификация", {"WWW-Authenticate": challenge})
def not_found(message: str = "Объект не найден") -> ApiError:
return ApiError(404, "not_found", message)
def conflict(message: str = "Конфликт") -> ApiError:
return ApiError(409, "conflict", message)
def unavailable(message: str = "Сервис временно недоступен") -> ApiError:
return ApiError(503, "unavailable", message)
+491
View File
@@ -0,0 +1,491 @@
"""HTTP API for laboratory 2 (PostgreSQL + opaque sessions in Redis)."""
from __future__ import annotations
import json
import logging
import time
import uuid
from datetime import datetime, timezone
import psycopg
import psycopg_pool
import redis
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerifyMismatchError
from flask import Flask, Response, g, request
from . import db, sessions
from .config import settings
from .errors import ApiError, bad_request, conflict, not_found, unauthorized, unavailable
from .validation import (
cursor_time,
decode_cursor,
display_name,
encode_cursor,
exact_keys,
json_object,
limit_arg,
message_text,
non_blank,
password,
username,
uuid_list,
uuid_value,
)
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
log = logging.getLogger("messenger.api")
app = Flask(__name__)
app.config["MAX_CONTENT_LENGTH"] = settings.max_body_bytes
hasher = PasswordHasher()
# ---------------------------------------------------------------------------
# Response helpers and middleware
# ---------------------------------------------------------------------------
def _json(payload: object, status: int = 200, headers: dict[str, str] | None = None) -> Response:
body = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
response = Response(body, status=status, mimetype="application/json")
for key, value in (headers or {}).items():
response.headers[key] = value
return response
def _error_response(error: ApiError, request_id: str) -> Response:
return _json(
{
"error": {
"code": error.code,
"message": error.message,
"request_id": request_id,
}
},
error.status,
error.headers,
)
@app.before_request
def _request_context() -> None:
g.request_id = uuid.uuid4().hex
g.started_at = time.monotonic()
db.start_background_initialisation()
@app.after_request
def _response_headers(response: Response) -> Response:
response.headers["X-Request-Id"] = g.get("request_id", uuid.uuid4().hex)
response.headers["Cache-Control"] = "no-store"
return response
@app.errorhandler(ApiError)
def _handle_api_error(error: ApiError) -> Response:
return _error_response(error, g.get("request_id", uuid.uuid4().hex))
@app.errorhandler(413)
def _handle_too_large(_error: object) -> Response:
return _error_response(
ApiError(413, "payload_too_large", "Тело запроса слишком велико"),
g.get("request_id", uuid.uuid4().hex),
)
@app.errorhandler(404)
def _handle_not_found(_error: object) -> Response:
return _error_response(not_found(), g.get("request_id", uuid.uuid4().hex))
@app.errorhandler(405)
def _handle_method(_error: object) -> Response:
return _error_response(bad_request("Метод не поддерживается"), g.get("request_id", uuid.uuid4().hex))
@app.errorhandler(Exception)
def _handle_unexpected(error: Exception) -> Response:
request_id = g.get("request_id", uuid.uuid4().hex)
if isinstance(error, (psycopg.OperationalError, psycopg_pool.PoolTimeout, psycopg_pool.PoolClosed)):
log.warning("database unavailable on %s %s: %s", request.method, request.path, type(error).__name__)
return _error_response(unavailable("База данных недоступна"), request_id)
if isinstance(error, redis.RedisError):
log.warning("session store unavailable on %s %s: %s", request.method, request.path, type(error).__name__)
return _error_response(unavailable("Хранилище сессий недоступно"), request_id)
log.exception("unhandled error on %s %s", request.method, request.path)
return _error_response(
ApiError(500, "internal_error", "Внутренняя ошибка сервера"), request_id
)
# ---------------------------------------------------------------------------
# Serialisation
# ---------------------------------------------------------------------------
def format_time(value: datetime) -> str:
return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def user_json(row: dict) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": format_time(row["created_at"]),
}
def chat_json(row: dict) -> dict:
member_ids = sorted(str(item) for item in (row.get("member_ids") or []))
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": member_ids,
"created_at": format_time(row["created_at"]),
}
def message_json(row: dict) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": format_time(row["created_at"]),
}
# ---------------------------------------------------------------------------
# Authentication
# ---------------------------------------------------------------------------
def _bearer_token() -> str:
header = request.headers.get("Authorization", "")
parts = header.split(None, 1)
if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1].strip():
raise unauthorized()
return parts[1].strip()
def current_user() -> dict:
cached = g.get("current_user")
if cached is not None:
return cached
token = _bearer_token()
user_id, token_digest = sessions.resolve(token)
if not user_id:
raise unauthorized()
try:
parsed = uuid.UUID(user_id)
except ValueError as exc:
raise unauthorized() from exc
with db.pool().connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
(parsed,),
).fetchone()
if row is None:
sessions.revoke(token_digest)
raise unauthorized()
g.current_user = row
g.session_token_digest = token_digest
return row
def _basic_credentials() -> tuple[str, str]:
header = request.headers.get("Authorization", "")
parts = header.split(None, 1)
if len(parts) != 2 or parts[0].lower() != "basic":
raise unauthorized(basic=True)
import base64
try:
decoded = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8")
except (ValueError, UnicodeError) as exc:
raise unauthorized(basic=True) from exc
name, separator, secret = decoded.partition(":")
if not separator or not name or not secret:
raise unauthorized(basic=True)
if len(name) > 32 or any(ord(char) > 127 for char in name):
raise unauthorized(basic=True)
return name, secret
def _authenticate_basic() -> dict:
name, secret = _basic_credentials()
with db.pool().connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s",
(name,),
).fetchone()
if row is None:
raise unauthorized(basic=True)
try:
hasher.verify(row["password_hash"], secret)
except (VerifyMismatchError, InvalidHashError):
raise unauthorized(basic=True)
return row
# ---------------------------------------------------------------------------
# Health
# ---------------------------------------------------------------------------
@app.get("/health/live")
def health_live() -> Response:
return _json({"status": "ok"})
@app.get("/health/ready")
def health_ready() -> Response:
if not db.is_migrated():
raise unavailable("База данных ещё не готова")
try:
with db.pool().connection(timeout=1.0) as conn:
conn.execute("SELECT 1")
except Exception as exc:
raise unavailable("База данных недоступна") from exc
sessions.ping()
return _json({"status": "ok"})
# ---------------------------------------------------------------------------
# Users and sessions
# ---------------------------------------------------------------------------
@app.post("/api/v1/users")
def register_user() -> Response:
body = json_object(request, settings.max_body_bytes)
exact_keys(body, ("username", "display_name", "password"))
name = username(body["username"])
shown_name = display_name(body["display_name"])
secret = password(body["password"])
user_id = uuid.uuid4()
try:
with db.pool().connection() as conn:
row = conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash)
VALUES (%s, %s, %s, %s)
RETURNING id, username, display_name, created_at
""",
(user_id, name, shown_name, hasher.hash(secret)),
).fetchone()
except psycopg.errors.UniqueViolation as exc:
raise conflict("Username уже занят") from exc
return _json(user_json(row), 201)
@app.post("/api/v1/auth/sessions")
def create_session() -> Response:
row = _authenticate_basic()
token, expires_at = sessions.create(str(row["id"]))
return _json(
{
"token": token,
"token_type": "Bearer",
"expires_at": format_time(expires_at),
"user": user_json(row),
},
201,
)
@app.delete("/api/v1/auth/sessions/current")
def revoke_session() -> Response:
current_user() # authentication must happen before revocation
sessions.revoke(g.session_token_digest)
return Response(status=204)
@app.get("/api/v1/users/me")
def current_user_endpoint() -> Response:
return _json(user_json(current_user()))
# ---------------------------------------------------------------------------
# Chats
# ---------------------------------------------------------------------------
def _require_chat_member(chat_id: uuid.UUID, user_id: uuid.UUID) -> None:
with db.pool().connection() as conn:
row = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, user_id),
).fetchone()
if row is None:
raise not_found()
@app.post("/api/v1/chats")
def create_chat() -> Response:
actor = current_user()
body = json_object(request, settings.max_body_bytes)
exact_keys(body, ("title", "member_ids"))
title = non_blank(body["title"], "title", 1, 100)
member_ids = uuid_list(body["member_ids"], "member_ids")
actor_id = str(actor["id"])
if actor_id not in member_ids:
raise bad_request("Создатель должен входить в member_ids")
member_uuids = [uuid.UUID(item) for item in member_ids]
chat_id = uuid.uuid4()
with db.pool().connection() as conn:
existing = conn.execute(
"SELECT id FROM users WHERE id = ANY(%s)", (member_uuids,)
).fetchall()
if len(existing) != len(member_uuids):
raise bad_request("Указан неизвестный участник")
row = conn.execute(
"INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at",
(chat_id, title),
).fetchone()
with conn.cursor() as cursor:
cursor.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
[(chat_id, member) for member in member_uuids],
)
payload = dict(row)
payload["member_ids"] = member_uuids
return _json(chat_json(payload), 201)
@app.get("/api/v1/chats")
def list_chats() -> Response:
actor = current_user()
limit = limit_arg(request.args.get("limit"))
cursor = decode_cursor(request.args.get("cursor"))
parameters: list[object] = [actor["id"]]
predicate = ""
if cursor is not None:
if cursor.get("kind") != "chats" or cursor.get("user_id") != str(actor["id"]):
raise bad_request("Некорректный cursor")
try:
cursor_created = cursor_time(cursor.get("created_at"))
cursor_id = uuid_value(cursor.get("id"), "cursor")
except ApiError:
raise bad_request("Некорректный cursor")
predicate = "AND (c.created_at, c.id) > (%s, %s)"
parameters.extend([cursor_created, cursor_id])
parameters.append(limit + 1)
query = f"""
SELECT c.id, c.title, c.created_at,
ARRAY(
SELECT cm.user_id FROM chat_members cm
WHERE cm.chat_id = c.id ORDER BY cm.user_id
) AS member_ids
FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
WHERE TRUE {predicate}
ORDER BY c.created_at, c.id
LIMIT %s
"""
with db.pool().connection() as conn:
rows = conn.execute(query, tuple(parameters)).fetchall()
page = rows[:limit]
next_cursor = None
if len(rows) > limit and page:
last = page[-1]
next_cursor = encode_cursor(
{
"v": 1,
"kind": "chats",
"user_id": str(actor["id"]),
"created_at": format_time(last["created_at"]),
"id": str(last["id"]),
}
)
return _json({"items": [chat_json(row) for row in page], "next_cursor": next_cursor})
@app.get("/api/v1/chats/<chat_id>")
def get_chat(chat_id: str) -> Response:
actor = current_user()
parsed_chat_id = uuid_value(chat_id, "chat_id")
with db.pool().connection() as conn:
row = conn.execute(
"""
SELECT c.id, c.title, c.created_at,
ARRAY(
SELECT cm.user_id FROM chat_members cm
WHERE cm.chat_id = c.id ORDER BY cm.user_id
) AS member_ids
FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
WHERE c.id = %s
""",
(actor["id"], parsed_chat_id),
).fetchone()
if row is None:
raise not_found()
return _json(chat_json(row))
# ---------------------------------------------------------------------------
# Messages
# ---------------------------------------------------------------------------
@app.post("/api/v1/chats/<chat_id>/messages")
def create_message(chat_id: str) -> Response:
actor = current_user()
parsed_chat_id = uuid_value(chat_id, "chat_id")
_require_chat_member(parsed_chat_id, actor["id"])
body = json_object(request, settings.max_body_bytes)
exact_keys(body, ("text",))
text = message_text(body["text"])
with db.pool().connection() as conn:
row = conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text)
VALUES (%s, %s, %s, %s)
RETURNING id, chat_id, sender_id, text, created_at
""",
(uuid.uuid4(), parsed_chat_id, actor["id"], text),
).fetchone()
return _json(message_json(row), 201)
@app.get("/api/v1/chats/<chat_id>/messages")
def list_messages(chat_id: str) -> Response:
actor = current_user()
parsed_chat_id = uuid_value(chat_id, "chat_id")
_require_chat_member(parsed_chat_id, actor["id"])
limit = limit_arg(request.args.get("limit"))
cursor = decode_cursor(request.args.get("cursor"))
parameters: list[object] = [parsed_chat_id]
predicate = ""
if cursor is not None:
if cursor.get("kind") != "messages" or cursor.get("chat_id") != str(parsed_chat_id):
raise bad_request("Некорректный cursor")
try:
cursor_created = cursor_time(cursor.get("created_at"))
cursor_id = uuid_value(cursor.get("id"), "cursor")
except ApiError:
raise bad_request("Некорректный cursor")
predicate = "AND (created_at, id) > (%s, %s)"
parameters.extend([cursor_created, cursor_id])
parameters.append(limit + 1)
query = f"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s {predicate}
ORDER BY created_at, id
LIMIT %s
"""
with db.pool().connection() as conn:
rows = conn.execute(query, tuple(parameters)).fetchall()
page = rows[:limit]
next_cursor = None
if len(rows) > limit and page:
last = page[-1]
next_cursor = encode_cursor(
{
"v": 1,
"kind": "messages",
"chat_id": str(parsed_chat_id),
"created_at": format_time(last["created_at"]),
"id": str(last["id"]),
}
)
return _json({"items": [message_json(row) for row in page], "next_cursor": next_cursor})
+101
View File
@@ -0,0 +1,101 @@
"""Opaque bearer sessions stored in Redis/Valkey with a TTL.
PostgreSQL is the source of truth for users/chats/messages. Redis is the
authoritative store for *active sessions*; its append-only file and named
volume make those sessions survive a restart. The raw bearer token is never
stored: only a SHA-256 digest is used as the Redis key.
"""
from __future__ import annotations
import hashlib
import json
import secrets
from datetime import datetime, timedelta, timezone
import redis
from .config import settings
from .errors import unavailable
_client: redis.Redis | None = None
def client() -> redis.Redis:
global _client
if _client is None:
_client = redis.Redis.from_url(
settings.cache_url,
decode_responses=True,
socket_connect_timeout=settings.redis_connect_timeout,
socket_timeout=settings.redis_socket_timeout,
retry_on_timeout=False,
health_check_interval=30,
)
return _client
def digest(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def _key(token_digest: str) -> str:
return "session:" + token_digest
def create(user_id: str) -> tuple[str, datetime]:
token = secrets.token_urlsafe(32) # 256 bits of entropy, opaque to clients
ttl = settings.session_ttl_seconds
expires_at = datetime.now(timezone.utc) + timedelta(seconds=ttl)
payload = json.dumps(
{"user_id": user_id, "expires_at": expires_at.isoformat().replace("+00:00", "Z")},
separators=(",", ":"),
)
try:
client().setex(_key(digest(token)), ttl, payload)
except redis.RedisError as exc:
raise unavailable("Хранилище сессий недоступно") from exc
return token, expires_at
def resolve(token: str) -> tuple[str, str]:
"""Return (user_id, token_digest) or raise a bounded 503 error."""
token_digest = digest(token)
try:
raw = client().get(_key(token_digest))
except redis.RedisError as exc:
raise unavailable("Хранилище сессий недоступно") from exc
if not raw:
return "", token_digest
try:
data = json.loads(raw)
user_id = str(data["user_id"])
expires_at = datetime.fromisoformat(str(data["expires_at"]).replace("Z", "+00:00"))
except (ValueError, KeyError, TypeError):
return "", token_digest
if expires_at <= datetime.now(timezone.utc):
revoke(token_digest)
return "", token_digest
return user_id, token_digest
def revoke(token_digest: str) -> None:
try:
client().delete(_key(token_digest))
except redis.RedisError as exc:
raise unavailable("Хранилище сессий недоступно") from exc
def ping() -> None:
try:
if not client().ping():
raise unavailable("Хранилище сессий недоступно")
except redis.RedisError as exc:
raise unavailable("Хранилище сессий недоступно") from exc
def seconds_left(token_digest: str) -> int:
try:
value = client().ttl(_key(token_digest))
except redis.RedisError:
return 0
return max(0, int(value))
+143
View File
@@ -0,0 +1,143 @@
"""Strict parsing shared by HTTP handlers.
The contract requires rejection of extra JSON fields, wrong types and
whitespace-only required strings. Validation happens before any SQL.
"""
from __future__ import annotations
import base64
import binascii
import json
import re
import uuid
from datetime import datetime, timezone
from flask import Request
from .errors import ApiError, bad_request
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
INTEGER_RE = re.compile(r"^[0-9]+$")
def json_object(request: Request, max_bytes: int) -> dict:
if request.mimetype != "application/json":
raise bad_request("Ожидается application/json")
raw = request.get_data(cache=False)
if not raw:
raise bad_request("Тело запроса обязательно")
if len(raw) > max_bytes:
raise ApiError(413, "payload_too_large", "Тело запроса слишком велико")
try:
value = json.loads(raw)
except (ValueError, UnicodeError) as exc:
raise bad_request("Некорректный JSON") from exc
if not isinstance(value, dict):
raise bad_request("Ожидается JSON-объект")
return value
def exact_keys(value: dict, required: tuple[str, ...], optional: tuple[str, ...] = ()) -> None:
allowed = set(required) | set(optional)
if not set(required).issubset(value) or set(value) - allowed:
raise bad_request("Неверный набор полей")
def text_field(value: object, name: str, minimum: int, maximum: int) -> str:
if not isinstance(value, str):
raise bad_request(f"Поле {name} должно быть строкой")
if not (minimum <= len(value) <= maximum):
raise bad_request(f"Поле {name} имеет недопустимую длину")
return value
def non_blank(value: object, name: str, minimum: int, maximum: int) -> str:
result = text_field(value, name, minimum, maximum)
if not result.strip():
raise bad_request(f"Поле {name} не должно быть пустым")
return result
def username(value: object) -> str:
result = text_field(value, "username", 3, 32)
if USERNAME_RE.fullmatch(result) is None:
raise bad_request("Недопустимый username")
return result
def display_name(value: object) -> str:
return non_blank(value, "display_name", 1, 100)
def password(value: object) -> str:
result = text_field(value, "password", 12, 128)
return result
def message_text(value: object) -> str:
return non_blank(value, "text", 1, 4000)
def uuid_list(value: object, name: str, minimum: int = 1, maximum: int = 100) -> list[str]:
if not isinstance(value, list):
raise bad_request(f"Поле {name} должно быть массивом")
if not (minimum <= len(value) <= maximum):
raise bad_request(f"Поле {name} имеет недопустимую длину")
parsed: list[str] = []
for item in value:
parsed.append(str(uuid_value(item, name)))
if len(set(parsed)) != len(parsed):
raise bad_request(f"Поле {name} содержит дубликаты")
return parsed
def uuid_value(value: object, name: str = "id") -> uuid.UUID:
if not isinstance(value, str):
raise bad_request(f"Поле {name} должно быть UUID")
try:
return uuid.UUID(value)
except (ValueError, AttributeError) as exc:
raise bad_request(f"Поле {name} должно быть UUID") from exc
def limit_arg(raw: str | None, default: int = 50) -> int:
if raw is None:
return default
if INTEGER_RE.fullmatch(raw) is None:
raise bad_request("limit должен быть целым числом")
value = int(raw)
if not (1 <= value <= 100):
raise bad_request("limit должен быть в диапазоне 1..100")
return value
def encode_cursor(payload: dict) -> str:
raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def decode_cursor(raw: str | None) -> dict | None:
if raw is None:
return None
if not raw or len(raw) > 4096:
raise bad_request("Некорректный cursor")
padded = raw + "=" * (-len(raw) % 4)
try:
data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
except (ValueError, UnicodeError, AttributeError, binascii.Error) as exc:
raise bad_request("Некорректный cursor") from exc
if not isinstance(data, dict):
raise bad_request("Некорректный cursor")
return data
def cursor_time(value: object) -> datetime:
if not isinstance(value, str):
raise bad_request("Некорректный cursor")
try:
result = datetime.fromisoformat(value.replace("Z", "+00:00"))
except ValueError as exc:
raise bad_request("Некорректный cursor") from exc
if result.tzinfo is None:
raise bad_request("Некорректный cursor")
return result.astimezone(timezone.utc)
+82
View File
@@ -0,0 +1,82 @@
# Local synthetic stand for laboratory 2.
# Copy .env.example to .env and change the local password before use.
# The password is read from .env at Compose time and is never committed.
name: mtusi-lab2
services:
postgres:
image: postgres:16.4-alpine
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB:-messenger}
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 3s
timeout: 3s
retries: 20
networks:
- backend
redis:
image: redis:7.4.0-alpine
restart: unless-stopped
# Sessions are the only Redis data. AOF + the named volume keep active
# sessions across an API/Redis restart; TTL remains the expiry authority.
command:
- redis-server
- --appendonly
- "yes"
- --appendfsync
- everysec
- --dir
- /data
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 3s
retries: 20
networks:
- backend
api:
build:
context: .
dockerfile: Dockerfile
restart: unless-stopped
environment:
APP_ENV: lab
DATABASE_URL: ${DATABASE_URL:?set DATABASE_URL in .env}
CACHE_URL: ${CACHE_URL:-redis://redis:6379/0}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DB_POOL_MIN: ${DB_POOL_MIN:-1}
DB_POOL_MAX: ${DB_POOL_MAX:-10}
DB_POOL_ACQUIRE_TIMEOUT_SECONDS: ${DB_POOL_ACQUIRE_TIMEOUT_SECONDS:-3}
DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:-3}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000}
REDIS_CONNECT_TIMEOUT_SECONDS: ${REDIS_CONNECT_TIMEOUT_SECONDS:-2}
REDIS_SOCKET_TIMEOUT_SECONDS: ${REDIS_SOCKET_TIMEOUT_SECONDS:-2}
MAX_BODY_BYTES: ${MAX_BODY_BYTES:-1048576}
ports:
- "${API_PORT:-8080}:8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
networks:
- backend
volumes:
pgdata:
redisdata:
networks:
backend:
driver: bridge
+1
View File
@@ -0,0 +1 @@
PASS: wrong password, Basic rejection, logout and token reuse checks
+1
View File
@@ -0,0 +1 @@
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+4
View File
@@ -0,0 +1,4 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "gunicorn --bind=0.0тАж" api 23 seconds ago Up 1 second (health: starting) 0.0.0.0:18080->8080/tcp, [::]:18080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.sтАж" postgres 12 minutes ago Up 2 seconds (health: starting) 5432/tcp
mtusi-lab2-redis-1 redis:7.4.0-alpine "docker-entrypoint.sтАж" redis 12 minutes ago Up 2 seconds (health: starting) 6379/tcp
+4
View File
@@ -0,0 +1,4 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "gunicorn --bind=0.0тАж" api 19 seconds ago Up 17 seconds (healthy) 0.0.0.0:18080->8080/tcp, [::]:18080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.sтАж" postgres 12 minutes ago Up About a minute (healthy) 5432/tcp
mtusi-lab2-redis-1 redis:7.4.0-alpine "docker-entrypoint.sтАж" redis 12 minutes ago Up About a minute (healthy) 6379/tcp
+19
View File
@@ -0,0 +1,19 @@
empty users body 400 invalid_request
extra user field 400 invalid_request
chat1 201 None
chat2 201 None
unknown member 400 invalid_request
caller missing 400 invalid_request
duplicate member 400 invalid_request
invalid chat uuid 400 invalid_request
message 201 None
message 201 None
page exactly limit 200 2 None
chat1 page 200 None
chat1 page had no next cursor
chat page 1 200 1 True
chat page 2 200 1 False
blank text 400 invalid_request
too long text 400 invalid_request
sender_id rejected 400 invalid_request
EDGE PASS
+1
View File
@@ -0,0 +1 @@
PASS: expired session is rejected with 401 and Bearer challenge
+16
View File
@@ -0,0 +1,16 @@
# EXPLAIN (ANALYZE, BUFFERS) for keyset history pagination
generated_at_utc: 2026-11-06T19:27:08.308823Z
messages_in_chat: 10000
chat_id: 009edfde-74bf-4dd7-8e55-a665d2d6f38a
query: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id LIMIT 51
Limit (cost=0.29..94.71 rows=51 width=78) (actual time=0.020..0.029 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_created_at_id_idx on messages (cost=0.29..926.01 rows=500 width=78) (actual time=0.019..0.025 rows=51 loops=1)
Index Cond: ((chat_id = '009edfde-74bf-4dd7-8e55-a665d2d6f38a'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:09.501+00'::timestamp with time zone, 'd8f60f44-b107-4f1a-bae2-4fcf80d33d70'::uuid)))
Buffers: shared hit=4
Planning:
Buffers: shared hit=6
Planning Time: 0.138 ms
Execution Time: 0.124 ms
PASS: index used on 10000 messages; evidence written to /tmp/explain_history.txt
+5
View File
@@ -0,0 +1,5 @@
OBSERVED: redis down: readiness=503, bearer request=503
OBSERVED: redis up: readiness=200 in 0.48s, same token=200 (AOF persistence)
OBSERVED: postgres down: readiness=503, bearer request=503
OBSERVED: postgres up: readiness=200 in 3.01s, same token=200
PASS: dependency loss produced only bounded 503 responses; no anonymous trust
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 15.0,
"elapsed_seconds": 15.047,
"concurrency": 4,
"successful_requests": 2599,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 172.728,
"successful_latency_ms": {
"p50": 22.956,
"p95": 38.873,
"p99": 44.759
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 15.0,
"elapsed_seconds": 15.047,
"concurrency": 4,
"successful_requests": 2599,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 172.728,
"successful_latency_ms": {
"p50": 22.956,
"p95": 38.873,
"p99": 44.759
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+2
View File
@@ -0,0 +1,2 @@
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+8
View File
@@ -0,0 +1,8 @@
statement_timeout = 5s
idle_in_transaction_session_timeout = 10s
lock_timeout = 3s
pool_min = 1
pool_max = 10
pool_size = 1
pool_available = 1
PASS: bounded pool and SQL timeouts are active
+1
View File
@@ -0,0 +1 @@
PASS: 8 concurrent registrations produced exactly one user and one session
+10
View File
@@ -0,0 +1,10 @@
rdb_last_save_time:1793993503
aof_enabled:1
aof_rewrite_in_progress:0
aof_last_write_status:ok
23
sample_session_key=session:0ca7134c5787318eb96bdeca133253f826477b52413ccd3f7f905f9aed20007d
sample_session_ttl_seconds=3486
+1
View File
@@ -0,0 +1 @@
PASS: failed membership insert rolled back the chat; subsequent create is atomic
+36
View File
@@ -0,0 +1,36 @@
TABLES
table_name
-------------------
chat_members
chats
messages
schema_migrations
users
(5 rows)
INDEXES
indexname | indexdef
---------------------------------+-------------------------------------------------------------------------------------------------------
chat_members_pkey | CREATE UNIQUE INDEX chat_members_pkey ON public.chat_members USING btree (chat_id, user_id)
chat_members_user_chat_idx | CREATE INDEX chat_members_user_chat_idx ON public.chat_members USING btree (user_id, chat_id)
chats_created_at_id_idx | CREATE INDEX chats_created_at_id_idx ON public.chats USING btree (created_at, id)
chats_pkey | CREATE UNIQUE INDEX chats_pkey ON public.chats USING btree (id)
messages_chat_created_at_id_idx | CREATE INDEX messages_chat_created_at_id_idx ON public.messages USING btree (chat_id, created_at, id)
messages_pkey | CREATE UNIQUE INDEX messages_pkey ON public.messages USING btree (id)
schema_migrations_pkey | CREATE UNIQUE INDEX schema_migrations_pkey ON public.schema_migrations USING btree (version)
users_pkey | CREATE UNIQUE INDEX users_pkey ON public.users USING btree (id)
users_username_key | CREATE UNIQUE INDEX users_username_key ON public.users USING btree (username)
(9 rows)
MIGRATIONS
version | applied_at
----------+-------------------------------
001_init | 2026-11-06 19:22:16.209767+00
(1 row)
COUNTS
users | chats | members | messages
-------+-------+---------+----------
34 | 11 | 18 | 22635
(1 row)
+1
View File
@@ -0,0 +1 @@
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+51
View File
@@ -0,0 +1,51 @@
-- Laboratory 2 initial schema.
-- PostgreSQL is the source of truth for users, chats, membership and messages.
CREATE TABLE IF NOT EXISTS users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT users_username_key UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_length CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE IF NOT EXISTS chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT chats_title_length CHECK (char_length(title) BETWEEN 1 AND 100)
);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
joined_at timestamptz NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (chat_id, user_id)
);
CREATE TABLE IF NOT EXISTS messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT messages_text_length CHECK (char_length(text) BETWEEN 1 AND 4000)
);
-- Reverse membership lookup: "my chats, newest last".
CREATE INDEX IF NOT EXISTS chat_members_user_chat_idx
ON chat_members (user_id, chat_id);
-- Chat page ordering and keyset pagination.
CREATE INDEX IF NOT EXISTS chats_created_at_id_idx
ON chats (created_at, id);
-- The only history access path:
-- WHERE chat_id = ? AND (created_at, id) > (?, ?)
-- ORDER BY created_at, id LIMIT ?
-- It supports the range scan without reading the whole chat history.
CREATE INDEX IF NOT EXISTS messages_chat_created_at_id_idx
ON messages (chat_id, created_at, id);
+5
View File
@@ -0,0 +1,5 @@
Flask==3.1.0
gunicorn==23.0.0
psycopg[binary,pool]==3.2.3
redis==5.2.1
argon2-cffi==23.1.0
+10
View File
@@ -0,0 +1,10 @@
@echo off
rem Restart API and all state stores without deleting named volumes.
setlocal
cd /d "%~dp0.."
if not exist ".env" (
echo missing .env; copy .env.example and set local synthetic credentials 1>&2
exit /b 2
)
docker compose --env-file .env restart
exit /b %errorlevel%
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
# Restart API and ALL state stores without deleting named volumes.
# The public persistence test polls /health/ready itself, so this hook only
# performs the restart and returns non-zero on a Compose error.
set -eu
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
cd "$ROOT"
if [ ! -f .env ]; then
echo "missing .env; copy .env.example and set local synthetic credentials" >&2
exit 2
fi
docker compose --env-file .env restart
+31
View File
@@ -0,0 +1,31 @@
# Студенческие проверки уровня 4
Все проверки, кроме `rollback_chat.py` и `explain_history.py`, запускаются на
хосте и обращаются к API по HTTP. Две проверки используют `psycopg` и запускаются
внутри контейнера `api`, где зависимость уже установлена.
```sh
# 1. Негативная аутентификация и logout
python student-tests/auth_negative.py --base-url http://localhost:8080
# 2. Гонка регистрации одного username
python student-tests/race_username.py --base-url http://localhost:8080 --workers 8
# 3. Откат составной операции (внутри контейнера)
docker compose exec -T api python student-tests/rollback_chat.py
# 4. EXPLAIN на 10 000 сообщений (внутри контейнера)
docker compose exec -T api python student-tests/explain_history.py \
--output /tmp/explain_history.txt
# 5. Отказы Redis и PostgreSQL (с хоста; управляет docker compose)
python student-tests/fault_matrix.py
# 6. Истечение сессии: API должен быть запущен с коротким TTL
# SESSION_TTL_SECONDS=2 docker compose up -d --force-recreate api
python student-tests/expiry.py --wait 4
```
`fault_matrix.py` останавливает `redis`/`postgres` и обязательно запускает их
обратно в `finally`. Он проверяет только ограниченные `503`, отсутствие
доверенного анонимного доступа и сохранность сессии после рестарта Redis с AOF.
+58
View File
@@ -0,0 +1,58 @@
#!/usr/bin/env python3
"""Wrong password, Basic-on-business-endpoint, logout and reuse checks."""
from __future__ import annotations
import argparse
import base64
from common import HttpClient, assert_status, error_code
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
args = parser.parse_args()
client = HttpClient(args.base_url)
user, registration = client.register()
wrong = base64.b64encode(
(registration["username"] + ":wrong-password-value").encode("utf-8")
).decode("ascii")
status, headers, payload, _ = client.call(
"POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + wrong}
)
assert_status(status, 401, "wrong password")
assert error_code(payload) == "unauthorized"
assert headers.get("WWW-Authenticate", "").lower().startswith("basic")
good = base64.b64encode(
(registration["username"] + ":" + registration["password"]).encode("utf-8")
).decode("ascii")
status, headers, _, _ = client.call(
"GET", "/api/v1/users/me", headers={"Authorization": "Basic " + good}
)
assert_status(status, 401, "Basic on business endpoint")
assert headers.get("WWW-Authenticate", "").lower().startswith("bearer")
session = client.login(registration)
token = session["token"]
status, _, me, _ = client.call("GET", "/api/v1/users/me", token=token)
assert_status(status, 200, "login")
assert me["id"] == user["id"]
status, _, _, raw = client.call("DELETE", "/api/v1/auth/sessions/current", token=token)
assert_status(status, 204, "logout")
assert raw == b"", "204 must have an empty body"
status, headers, payload, _ = client.call("GET", "/api/v1/users/me", token=token)
assert_status(status, 401, "token after logout")
assert error_code(payload) == "unauthorized"
assert headers.get("WWW-Authenticate", "").lower().startswith("bearer")
status, _, _, _ = client.call("DELETE", "/api/v1/auth/sessions/current", token=token)
assert_status(status, 401, "second logout")
print("PASS: wrong password, Basic rejection, logout and token reuse checks")
if __name__ == "__main__":
main()
+76
View File
@@ -0,0 +1,76 @@
#!/usr/bin/env python3
"""Small standard-library HTTP helpers for the student checks."""
from __future__ import annotations
import base64
import json
import os
import uuid
import urllib.error
import urllib.request
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
class HttpClient:
def __init__(self, base_url: str | None = None):
self.base = (base_url or BASE_URL).rstrip("/")
def call(self, method: str, path: str, body=None, token: str | None = None, headers=None):
h = {"Accept": "application/json"}
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
if token:
h["Authorization"] = "Bearer " + token
h.update(headers or {})
request = urllib.request.Request(self.base + path, data=data, headers=h, method=method)
try:
response = urllib.request.urlopen(request, timeout=10)
except urllib.error.HTTPError as error:
response = error
with response:
raw = response.read()
payload = None
if raw:
try:
payload = json.loads(raw)
except ValueError:
payload = None
return response.code, response.headers, payload, raw
def register(self) -> tuple[dict, dict]:
suffix = uuid.uuid4().hex[:12]
registration = {
"username": "st_" + suffix,
"display_name": "Студент " + suffix,
"password": "T3st-" + uuid.uuid4().hex,
}
status, _headers, user, _raw = self.call("POST", "/api/v1/users", registration)
if status != 201:
raise AssertionError(f"registration failed: HTTP {status}")
return user, registration
def login(self, registration: dict) -> dict:
credential = base64.b64encode(
(registration["username"] + ":" + registration["password"]).encode("utf-8")
).decode("ascii")
status, _headers, session, _raw = self.call(
"POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + credential}
)
if status != 201:
raise AssertionError(f"login failed: HTTP {status}")
return session
def assert_status(actual: int, expected: int, label: str) -> None:
if actual != expected:
raise AssertionError(f"{label}: expected HTTP {expected}, received {actual}")
def error_code(payload) -> str | None:
if not isinstance(payload, dict):
return None
error = payload.get("error")
return error.get("code") if isinstance(error, dict) else None
+35
View File
@@ -0,0 +1,35 @@
#!/usr/bin/env python3
"""Expiry check: run against an API with SESSION_TTL_SECONDS=2 (or pass --wait)."""
from __future__ import annotations
import argparse
import time
from common import HttpClient, assert_status, error_code
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--wait", type=float, default=3.0)
args = parser.parse_args()
client = HttpClient(args.base_url)
user, registration = client.register()
session = client.login(registration)
token = session["token"]
status, headers, payload, _ = client.call("GET", "/api/v1/users/me", token=token)
assert_status(status, 200, "fresh session")
assert payload["id"] == user["id"], "wrong current user"
time.sleep(args.wait)
status, headers, payload, _ = client.call("GET", "/api/v1/users/me", token=token)
assert_status(status, 401, "expired session")
assert error_code(payload) == "unauthorized", "expired session must be unauthorized"
assert headers.get("WWW-Authenticate", "").lower().startswith("bearer"), "missing Bearer challenge"
print("PASS: expired session is rejected with 401 and Bearer challenge")
if __name__ == "__main__":
main()
+101
View File
@@ -0,0 +1,101 @@
#!/usr/bin/env python3
"""Create 10 000 synthetic messages and record EXPLAIN (ANALYZE, BUFFERS).
Run inside the API container (psycopg is installed there):
docker compose exec -T api python student-tests/explain_history.py \
--output /app/evidence/explain_history.txt
The evidence directory is mounted read-only in the container, so the example
below is normally executed with a writable bind mount or copied out.
"""
from __future__ import annotations
import argparse
import os
import uuid
from datetime import datetime, timezone
from pathlib import Path
import psycopg
MESSAGES = 10_000
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--database-url", default=os.environ.get("DATABASE_URL"))
parser.add_argument("--output", default="evidence/explain_history.txt")
parser.add_argument("--messages", type=int, default=MESSAGES)
args = parser.parse_args()
if not args.database_url:
raise SystemExit("DATABASE_URL is required")
tag = uuid.uuid4().hex[:10]
user_id = uuid.uuid4()
chat_id = uuid.uuid4()
with psycopg.connect(args.database_url) as conn:
conn.execute(
"INSERT INTO users (id, username, display_name, password_hash) VALUES (%s, %s, %s, %s)",
(user_id, "perf_" + tag, "Performance synthetic", "not-a-real-password-hash"),
)
conn.execute("INSERT INTO chats (id, title) VALUES (%s, %s)", (chat_id, "perf-" + tag))
conn.execute(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", (chat_id, user_id)
)
conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), %s, %s, 'synthetic message ' || g,
timestamptz '2026-01-01 00:00:00+00' + (g || ' milliseconds')::interval
FROM generate_series(1, %s) AS g
""",
(chat_id, user_id, args.messages),
)
total = conn.execute(
"SELECT count(*) FROM messages WHERE chat_id = %s", (chat_id,)
).fetchone()[0]
conn.execute("ANALYZE messages")
cursor = conn.execute(
"""
SELECT created_at, id FROM messages
WHERE chat_id = %s ORDER BY created_at, id
OFFSET %s LIMIT 1
""",
(chat_id, max(0, args.messages - 500)),
).fetchone()
plan_rows = conn.execute(
"""
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s AND (created_at, id) > (%s, %s)
ORDER BY created_at, id
LIMIT 51
""",
(chat_id, cursor[0], cursor[1]),
).fetchall()
conn.commit()
plan = "\n".join(row[0] for row in plan_rows)
if "messages_chat_created_at_id_idx" not in plan:
raise AssertionError("history query did not use the keyset index:\n" + plan)
if "Seq Scan" in plan:
raise AssertionError("history query performed a sequential scan:\n" + plan)
header = (
"# EXPLAIN (ANALYZE, BUFFERS) for keyset history pagination\n"
f"generated_at_utc: {datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')}\n"
f"messages_in_chat: {total}\n"
f"chat_id: {chat_id}\n"
"query: WHERE chat_id = ? AND (created_at, id) > (?, ?) "
"ORDER BY created_at, id LIMIT 51\n\n"
)
output = Path(args.output)
output.parent.mkdir(parents=True, exist_ok=True)
output.write_text(header + plan + "\n", encoding="utf-8")
print(header + plan)
print(f"PASS: index used on {total} messages; evidence written to {output}")
if __name__ == "__main__":
main()
+102
View File
@@ -0,0 +1,102 @@
#!/usr/bin/env python3
"""Dependency-failure matrix: Redis and PostgreSQL outages must be bounded.
The check uses the local Compose project. It stops one dependency, verifies
503 (never 200 and never a trusted anonymous request), starts it again, waits
for readiness and confirms the original bearer session still works after the
Redis restart (AOF persistence).
"""
from __future__ import annotations
import argparse
import os
import subprocess
import time
from pathlib import Path
from common import HttpClient, assert_status, error_code
ROOT = Path(__file__).resolve().parents[1]
def compose(*args: str) -> None:
subprocess.run(
["docker", "compose", "--env-file", ".env", *args],
cwd=ROOT,
check=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
def wait_ready(client: HttpClient, expected: int, seconds: float = 90) -> None:
deadline = time.monotonic() + seconds
last = None
while time.monotonic() < deadline:
try:
status, _, _, _ = client.call("GET", "/health/ready")
last = status
if status == expected:
return
except OSError:
last = "connection error"
time.sleep(0.5)
raise AssertionError(f"readiness did not become {expected}; last={last}")
def expect_503(client: HttpClient, path: str, token: str | None, label: str) -> None:
status, _headers, payload, _raw = client.call("GET", path, token=token)
if status != 503:
raise AssertionError(f"{label}: expected 503, received {status}")
if error_code(payload) != "unavailable":
raise AssertionError(f"{label}: expected unavailable error code")
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
args = parser.parse_args()
client = HttpClient(args.base_url)
user, registration = client.register()
session = client.login(registration)
token = session["token"]
results = []
try:
compose("stop", "redis")
expect_503(client, "/health/ready", None, "Redis down readiness")
expect_503(client, "/api/v1/users/me", token, "Redis down authenticated request")
results.append("redis down: readiness=503, bearer request=503")
started = time.monotonic()
compose("start", "redis")
wait_ready(client, 200)
redis_recovery = round(time.monotonic() - started, 2)
status, _, me, _ = client.call("GET", "/api/v1/users/me", token=token)
assert_status(status, 200, "session after Redis restart")
if me["id"] != user["id"]:
raise AssertionError("session identity changed after Redis restart")
results.append(f"redis up: readiness=200 in {redis_recovery}s, same token=200 (AOF persistence)")
compose("stop", "postgres")
time.sleep(1)
expect_503(client, "/health/ready", None, "PostgreSQL down readiness")
expect_503(client, "/api/v1/users/me", token, "PostgreSQL down authenticated request")
results.append("postgres down: readiness=503, bearer request=503")
started = time.monotonic()
compose("start", "postgres")
wait_ready(client, 200)
postgres_recovery = round(time.monotonic() - started, 2)
status, _, me, _ = client.call("GET", "/api/v1/users/me", token=token)
assert_status(status, 200, "session after PostgreSQL restart")
results.append(f"postgres up: readiness=200 in {postgres_recovery}s, same token=200")
finally:
compose("start", "redis")
compose("start", "postgres")
for line in results:
print("OBSERVED:", line)
print("PASS: dependency loss produced only bounded 503 responses; no anonymous trust")
if __name__ == "__main__":
main()
+38
View File
@@ -0,0 +1,38 @@
#!/usr/bin/env python3
"""Print the effective PostgreSQL timeouts and pool limits.
Run inside the API container:
docker compose exec -T api python student-tests/pool_settings.py
"""
from __future__ import annotations
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app import db
def main() -> None:
db.pool().open(wait=True, timeout=5)
db.apply_migrations()
with db.pool().connection() as conn:
statement = conn.execute("SHOW statement_timeout").fetchone()["statement_timeout"]
idle = conn.execute("SHOW idle_in_transaction_session_timeout").fetchone()[
"idle_in_transaction_session_timeout"
]
lock = conn.execute("SHOW lock_timeout").fetchone()["lock_timeout"]
stats = db.pool().get_stats()
print("statement_timeout =", statement)
print("idle_in_transaction_session_timeout =", idle)
print("lock_timeout =", lock)
print("pool_min =", stats["pool_min"])
print("pool_max =", stats["pool_max"])
print("pool_size =", stats["pool_size"])
print("pool_available =", stats["pool_available"])
print("PASS: bounded pool and SQL timeouts are active")
if __name__ == "__main__":
main()
+45
View File
@@ -0,0 +1,45 @@
#!/usr/bin/env python3
"""Concurrent registration with the same username: one 201, the rest 409."""
from __future__ import annotations
import argparse
import uuid
from concurrent.futures import ThreadPoolExecutor
from common import HttpClient, assert_status, error_code
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--workers", type=int, default=8)
args = parser.parse_args()
client = HttpClient(args.base_url)
username = "race_" + uuid.uuid4().hex[:16]
body = {
"username": username,
"display_name": "Race candidate",
"password": "T3st-" + uuid.uuid4().hex,
}
def register(_index: int):
status, _, payload, _ = client.call("POST", "/api/v1/users", body)
return status, error_code(payload)
with ThreadPoolExecutor(max_workers=args.workers) as executor:
results = list(executor.map(register, range(args.workers)))
statuses = [status for status, _code in results]
if statuses.count(201) != 1 or statuses.count(409) != args.workers - 1:
raise AssertionError(f"expected one 201 and {args.workers - 1} conflicts, got {statuses}")
for status, code in results:
if status == 409 and code != "conflict":
raise AssertionError("409 must carry conflict code")
session = client.login(body)
assert session["user"]["username"] == username
print(f"PASS: {args.workers} concurrent registrations produced exactly one user and one session")
if __name__ == "__main__":
main()
+86
View File
@@ -0,0 +1,86 @@
#!/usr/bin/env python3
"""Prove that a failure after the chat insert rolls back the whole chat.
Run inside the API container (psycopg is installed there):
docker compose exec -T api python student-tests/rollback_chat.py
A temporary trigger aborts the second chat_members insert. The API must
return a bounded 500 and leave no chat row, because chat + membership share
one transaction.
"""
from __future__ import annotations
import argparse
import os
import uuid
import psycopg
from common import HttpClient, assert_status, error_code
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--database-url", default=os.environ.get("DATABASE_URL"))
args = parser.parse_args()
if not args.database_url:
raise SystemExit("DATABASE_URL is required")
client = HttpClient(args.base_url)
actor, actor_registration = client.register()
victim, _victim_registration = client.register()
session = client.login(actor_registration)
token = session["token"]
title = "rollback-" + uuid.uuid4().hex
function_name = "test_fail_member_" + uuid.uuid4().hex[:8]
victim_id = str(uuid.UUID(victim["id"]))
with psycopg.connect(args.database_url, autocommit=True) as conn:
conn.execute(
f"""
CREATE FUNCTION {function_name}() RETURNS trigger AS $$
BEGIN
IF NEW.user_id = '{victim_id}'::uuid THEN
RAISE EXCEPTION 'injected membership failure';
END IF;
RETURN NEW;
END
$$ LANGUAGE plpgsql
"""
)
conn.execute(
f"CREATE TRIGGER {function_name} BEFORE INSERT ON chat_members "
f"FOR EACH ROW EXECUTE FUNCTION {function_name}()"
)
try:
status, _, payload, _ = client.call(
"POST",
"/api/v1/chats",
{"title": title, "member_ids": [actor["id"], victim["id"]]},
token=token,
)
assert_status(status, 500, "injected membership failure")
if error_code(payload) != "internal_error":
raise AssertionError("unexpected error code for injected failure")
rows = conn.execute("SELECT count(*) FROM chats WHERE title = %s", (title,)).fetchone()
if rows[0] != 0:
raise AssertionError("chat survived a failed membership transaction")
finally:
conn.execute(f"DROP TRIGGER IF EXISTS {function_name} ON chat_members")
conn.execute(f"DROP FUNCTION IF EXISTS {function_name}()")
status, _, chat, _ = client.call(
"POST",
"/api/v1/chats",
{"title": title + "-ok", "member_ids": [actor["id"], victim["id"]]},
token=token,
)
assert_status(status, 201, "chat after trigger cleanup")
assert set(chat["member_ids"]) == {actor["id"], victim["id"]}
print("PASS: failed membership insert rolled back the chat; subsequent create is atomic")
if __name__ == "__main__":
main()