ЛР 2 — БВТ2301 — Чиняева — на 4 #157
+21
-7
@@ -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
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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)"
|
||||
|
||||
@@ -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 и отсутствия дублей.
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
# Messenger API for MTUSI high-load course, laboratory 2.
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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))
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
PASS: wrong password, Basic rejection, logout and token reuse checks
|
||||
@@ -0,0 +1 @@
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
PASS: expired session is rejected with 401 and Bearer challenge
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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.
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
PASS: 8 concurrent registrations produced exactly one user and one session
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
PASS: failed membership insert rolled back the chat; subsequent create is atomic
|
||||
@@ -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)
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -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);
|
||||
@@ -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
|
||||
@@ -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%
|
||||
Executable
+12
@@ -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
|
||||
@@ -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.
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user