Compare commits

7 Commits
Author SHA1 Message Date
Badradine 39277c1467 Обновить README.md
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-23 02:28:02 +03:00
Badradine e33582bf3e Обновить README.md
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-23 02:26:48 +03:00
Badradine a0e99d5308 Link Makefile outputs from report
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-23 01:39:13 +03:00
Badradine d26007028c Attach make check and test outputs 2026-10-23 01:38:52 +03:00
Badradine c7aee7fd05 Record persistence and migration checks 2026-10-23 01:32:51 +03:00
Badradine 3cd8ec1cec Restore lab assignment README and report PR status
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-23 00:53:50 +03:00
Badradine 191e88136c Implement Lab 2 grade 4 messenger service
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-22 23:58:55 +03:00
26 changed files with 1377 additions and 30 deletions
-8
View File
@@ -1,11 +1,3 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_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
+1
View File
@@ -15,6 +15,7 @@ data/
backups/
# Runtime/build artifacts
.venv/
.venv*/
__pycache__/
*.py[cod]
node_modules/
+25
View File
@@ -0,0 +1,25 @@
FROM python:3.12.6-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PYTHONUTF8=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir --requirement requirements.txt
COPY src/ ./src/
COPY migrations/ ./migrations/
RUN useradd --create-home --uid 10001 appuser
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=15s --retries=3 \
CMD python -c "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2).status==200 else 1)"
CMD ["uvicorn", "src.app.main:app", "--host", "0.0.0.0", "--port", "8080", "--workers", "1", "--timeout-graceful-shutdown", "8"]
+8 -2
View File
@@ -4,10 +4,10 @@ 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 test-grade4 explain-history
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "check: offline structure; validate: OpenAPI; test: public API smoke; test-grade4: auth/expiry/outage checks; explain-history: 10k-row query plan"
check:
$(PYTHON) scripts/check_contract.py
@@ -24,3 +24,9 @@ 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-grade4:
$(PYTHON) tests/grade4.py --base-url "$(BASE_URL)"
explain-history:
docker compose exec -T api python -m src.app.explain_history
+12
View File
@@ -92,10 +92,22 @@ Smoke не выставляет оценку автоматически. Про
## Вопросы на защите
- Что подтверждает COMMIT и какие гарантии зависят от настройки durability?
COMMIT подтверждает, что транзакция PostgreSQL успешно завершена. Создание чата и его участников выполняется атомарно: если операция завершается ошибкой до COMMIT, изменения откатываются. Долговечность зависит от WAL, fsync и надёжности диска; Docker volume сохраняет данные при перезапуске контейнера, но не защищает от потери диска.
- Где хранятся сессии и что будет после flush/restart Redis?
Сессии хранятся в Redis с TTL. В Redis используется SHA-256 от случайного Bearer-токена как ключ, а значение содержит user_id и время истечения. При обычном перезапуске с сохранённым volume данные восстанавливаются из AOF/RDB. После FLUSHDB сессии исчезнут, и пользователям нужно будет войти снова. При аварии настройка appendfsync everysec может привести к потере примерно последней секунды записей.
- Чем аутентификация отличается от доступа к конкретному чату?
Аутентификация отвечает на вопрос «кто пользователь?»: Basic используется для входа, затем Bearer-токен подтверждает сессию. Авторизация отвечает на вопрос «что пользователю разрешено?»: перед работой с чатом приложение проверяет членство пользователя в этом чате.
- Почему hash пароля и быстрый checksum имеют разные задачи?
Для паролей используется Argon2id: он намеренно медленный и требует памяти, поэтому подбор пароля обходится дороже. SHA-256 для ключа Redis работает быстро. Это подходит для случайного Bearer-токена с высокой энтропией, но быстрый checksum не подходит для хранения паролей.
2:22
## Первичные материалы
- [PostgreSQL transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html)
+45 -20
View File
@@ -1,37 +1,62 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Бадрадин Али, БВТ-2302
- Целевая оценка: 4; трек 5 не заявлен
- Commit/PR: черновик PR #84 — https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/84
- Источники и помощь: контракт этого репозитория; документация FastAPI, SQLAlchemy, PostgreSQL, Redis и Argon2. ИИ использован для реализации и ревью.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Версии закреплены в `requirements.txt` и `compose.yaml`: Python 3.12.6, FastAPI 0.115.0, SQLAlchemy 2.0.36, Psycopg 3.2.3, Redis client 5.2.0, Argon2-cffi 23.1.0, PostgreSQL 16.4 и Redis 7.4.1. Docker Compose v2 собирает API и запускает DB, Redis и одноразовую миграцию.
```powershell
Copy-Item .env.example .env
./scripts/create-secrets.ps1
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
python tests/smoke.py --base-url http://localhost:8080
```
Оператор создаёт secrets локально; их значения не добавляются в Git. `docker compose stop` или `docker compose down` сохраняют именованные volumes. Удаление учебной БД и Redis выполняется отдельно через `docker compose down --volumes`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- PostgreSQL — источник истины для пользователей, хэшей паролей, чатов, членства и сообщений. Все SQL-операции параметризованы через SQLAlchemy. Миграция `001_initial.sql` выполняется в транзакции с advisory lock и записывает версию в `schema_migrations`.
- Чат и членство создаются атомарно. FK `(chat_id, sender_id)` не позволяет записать сообщение от неучастника. Уникальность username обеспечивается PostgreSQL, а не предварительной проверкой приложения.
- История читается по keyset `(created_at, id)` через `messages_history_idx(chat_id, created_at, id)`; полная история не загружается на каждую страницу.
- Argon2id хэширует пароли. Basic используется только для входа; Bearer-токены генерируются с 256 битами случайности. В Redis сохраняется SHA-256-ключ, идентификатор пользователя и абсолютное время истечения. Logout удаляет текущую запись.
- Redis — источник истины для сессий. `appendonly yes`, `appendfsync everysec`, периодический RDB snapshot и именованный volume сохраняют записи при штатном рестарте. При аварии возможна потеря последних записей примерно за одну секунду.
- Пул PostgreSQL ограничен 5 соединениями + 5 overflow; connect timeout 3 с, pool timeout 3 с, statement timeout 5 с. При отказе Redis/PostgreSQL аутентификация не деградирует в доверие к `X-User-Id`: запросы возвращают `503 unavailable`, readiness становится 503.
- Для сообщений кэш отсутствует: успешная запись и последующее чтение используют PostgreSQL, поэтому stale read от кэша невозможен.
## Доказательства критериев
## Проверки и доказательства
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
Таблица ниже фиксирует фактически выполненное в этой рабочей сессии. Не отмечайте подготовленный сценарий как пройденный до запуска с работающим Docker Engine.
| Критерий | Команда/сценарий | Результат | Доказательство |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Структура API и локальные ссылки | `python scripts/check_contract.py` | PASS | Вывод: `PASS: offline skeleton structure, local refs and Python syntax` |
| Цели Makefile | `make check`; `make test` | PASS | `evidence/check-output.txt`; `evidence/test-output.txt` |
| Синтаксис Python | `python -m compileall -q src tests scripts` | PASS | exit code 0 |
| Конфигурация Compose и secrets | `docker compose config --quiet` | PASS; secrets и `.env` созданы локально и игнорируются Git | exit code 0 |
| In-process HTTP, ошибки и базовые проверки | `fastapi.testclient.TestClient` с нерабочими локальными адресами хранилищ | PASS: health, request ID, игнорирование `X-User-Id`, пустое тело сессии, ошибки валидации/malformed JSON, Argon2id, Basic parsing и cursor codec | вывод `PASS` в терминале |
| Недоступная PostgreSQL | `GET /health/ready` при закрытом localhost-порту | PASS: контролируемый `503 unavailable`, request ID совпадает | вывод `PASS` в терминале |
| README задания | `README.md` сохранён из исходного репозитория задания | PASS | `README.md`; инструкция запуска решения находится в этом отчёте |
| Публичный smoke | `python tests/smoke.py --base-url http://localhost:8080` | PASS | `evidence/test-output.txt`; вывод пользователя от 2026-10-23 |
| Пароль, expiry, logout, гонка регистрации, rollback чата | `$env:SESSION_TTL_SECONDS='10'; python tests/grade4.py --base-url http://localhost:8080` | PASS: все 8 сценариев | вывод пользователя от 2026-10-22; `tests/grade4.py` |
| Отказ Redis и PostgreSQL | часть `tests/grade4.py` | PASS: оба отказа возвращают ограниченный `503`; API и хранилища восстановлены | вывод пользователя от 2026-10-22 |
| Полный перезапуск сессии и данных | `python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://localhost:8080` | PASS: сохранены подтверждённые данные и действующая сессия после перезапуска | вывод пользователя от 2026-10-23; hook: `scripts/restart.sh` (без удаления volumes) |
| История ≥10 000 сообщений | `docker compose --env-file .env exec -T api python -m src.app.explain_history` | PASS: `Index Scan` использует `messages_history_idx`; Execution Time 0,108 мс | `evidence/query-plan.json`; 3 shared hit blocks в узле Index Scan |
| Повторное применение миграций | `docker compose --env-file .env run --rm migrate` | PASS: одноразовый migrate-контейнер завершился без ошибки | вывод пользователя от 2026-10-23 |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Локальный HTTP-прогон использовал установленное в рабочей среде FastAPI 0.139.0, Pydantic 2.13.4, SQLAlchemy 2.0.51 и Redis client 8.0.1; контейнер фиксирует версии из `requirements.txt`. Публичный smoke и полная suite grade4 подтверждены пользователем на Docker Compose 2026-10-22 и 2026-10-23; перезапуск с сохранением данных/сессии и повторное применение миграции также прошли 2026-10-23. План запроса истории снят в Docker: `Index Scan` по `messages_history_idx`, 0,108 мс на синтетическом наборе.
## Эксперименты и отказы
## Транзакции и план запроса
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Регистрация делает один `INSERT`; конкурентный конфликт определяется ограничением `UNIQUE(username)` и возвращает одинаковый `409`. Создание чата проверяет существование участников и затем вставляет чат и все связи в одном `Session.begin()`. Ошибка до commit откатывает всю транзакцию. История использует сравнение строки `(created_at, id)` и `LIMIT`, согласованное с индексом `messages_history_idx`.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
`src/app/explain_history.py` создаёт 10 000 синтетических сообщений в транзакции, запускает `ANALYZE` и `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)`, проверяет план и откатывает данные. Сохранённый `evidence/query-plan.json` показывает `Index Scan` через `messages_history_idx`, 3 shared hit blocks и время 0,108 мс. Это замер одного локального запуска, не универсальная оценка производительности.
## Ограничения и следующие шаги
## Ограничения
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Это локальный учебный стенд, не HA: один API, одна PostgreSQL и один Redis на одном Docker host. Перезапуск host/потеря диска не покрываются. AOF `everysec` не обещает сохранение каждой последней записи при внезапном обесточивании. TLS, лимиты скорости и защита от перебора паролей не входят в обязательный контракт Lab 2. Приложение не выдаёт производственный уровень безопасности.
+96
View File
@@ -0,0 +1,96 @@
name: mtusi-messenger-lab2
services:
db:
image: postgres:16.4-alpine
restart: unless-stopped
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 3s
timeout: 3s
retries: 20
start_period: 5s
redis:
image: redis:7.4.1-alpine
restart: unless-stopped
command:
- sh
- -ec
- exec redis-server --dir /data --appendonly yes --appendfsync everysec --save 60 1 --requirepass "$$(cat /run/secrets/redis_password)"
secrets:
- redis_password
volumes:
- redis_data:/data
healthcheck:
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping | grep -q PONG"]
interval: 3s
timeout: 3s
retries: 20
start_period: 5s
migrate:
build:
context: .
dockerfile: Dockerfile
command: ["python", "-m", "src.app.migrate"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
depends_on:
db:
condition: service_healthy
restart: "no"
api:
build:
context: .
dockerfile: Dockerfile
restart: unless-stopped
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
secrets:
- database_url
- cache_url
ports:
- "127.0.0.1:${APP_PORT:-8080}:8080"
depends_on:
db:
condition: service_healthy
redis:
condition: service_healthy
migrate:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2)"]
interval: 5s
timeout: 3s
retries: 12
start_period: 10s
secrets:
postgres_password:
file: ./secrets/postgres_password
redis_password:
file: ./secrets/redis_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
volumes:
postgres_data:
redis_data:
+2
View File
@@ -0,0 +1,2 @@
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+72
View File
@@ -0,0 +1,72 @@
{
"Execution Time": 0.108,
"Plan": {
"Actual Loops": 1,
"Actual Rows": 50,
"Actual Startup Time": 0.02,
"Actual Total Time": 0.03,
"Async Capable": false,
"Local Dirtied Blocks": 0,
"Local Hit Blocks": 0,
"Local Read Blocks": 0,
"Local Written Blocks": 0,
"Node Type": "Limit",
"Parallel Aware": false,
"Plan Rows": 50,
"Plan Width": 78,
"Plans": [
{
"Actual Loops": 1,
"Actual Rows": 50,
"Actual Startup Time": 0.018,
"Actual Total Time": 0.024,
"Alias": "messages",
"Async Capable": false,
"Index Cond": "((chat_id = '4a2cebc7-0477-4352-bda4-8d4bf06cf6f3'::uuid) AND (ROW(created_at, id) > ROW('2025-01-01 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))",
"Index Name": "messages_history_idx",
"Local Dirtied Blocks": 0,
"Local Hit Blocks": 0,
"Local Read Blocks": 0,
"Local Written Blocks": 0,
"Node Type": "Index Scan",
"Parallel Aware": false,
"Parent Relationship": "Outer",
"Plan Rows": 9999,
"Plan Width": 78,
"Relation Name": "messages",
"Rows Removed by Index Recheck": 0,
"Scan Direction": "Forward",
"Shared Dirtied Blocks": 0,
"Shared Hit Blocks": 3,
"Shared Read Blocks": 0,
"Shared Written Blocks": 0,
"Startup Cost": 0.29,
"Temp Read Blocks": 0,
"Temp Written Blocks": 0,
"Total Cost": 808.37
}
],
"Shared Dirtied Blocks": 0,
"Shared Hit Blocks": 3,
"Shared Read Blocks": 0,
"Shared Written Blocks": 0,
"Startup Cost": 0.29,
"Temp Read Blocks": 0,
"Temp Written Blocks": 0,
"Total Cost": 4.33
},
"Planning": {
"Local Dirtied Blocks": 0,
"Local Hit Blocks": 0,
"Local Read Blocks": 0,
"Local Written Blocks": 0,
"Shared Dirtied Blocks": 0,
"Shared Hit Blocks": 39,
"Shared Read Blocks": 0,
"Shared Written Blocks": 0,
"Temp Read Blocks": 0,
"Temp Written Blocks": 0
},
"Planning Time": 0.502,
"Triggers": []
}
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+36
View File
@@ -0,0 +1,36 @@
CREATE TABLE users (
id UUID PRIMARY KEY,
username VARCHAR(32) NOT NULL UNIQUE
CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name VARCHAR(100) NOT NULL
CHECK (char_length(display_name) BETWEEN 1 AND 100 AND btrim(display_name) <> ''),
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title VARCHAR(100) NOT NULL
CHECK (char_length(title) BETWEEN 1 AND 100 AND btrim(title) <> ''),
created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_id_idx ON chat_members(user_id, chat_id);
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL,
sender_id UUID NOT NULL,
text VARCHAR(4000) NOT NULL
CHECK (char_length(text) BETWEEN 1 AND 4000 AND btrim(text) <> ''),
created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
CONSTRAINT messages_sender_is_chat_member_fk
FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members(chat_id, user_id) ON DELETE CASCADE
);
CREATE INDEX messages_history_idx ON messages(chat_id, created_at, id);
+1
View File
@@ -1,2 +1,3 @@
# Only for full OpenAPI/JSON Schema validation; HTTP tests use stdlib.
openapi-spec-validator==0.7.2
pytest==8.3.3
+7
View File
@@ -0,0 +1,7 @@
fastapi==0.115.0
uvicorn[standard]==0.30.6
pydantic==2.9.2
SQLAlchemy==2.0.36
psycopg[binary]==3.2.3
redis==5.2.0
argon2-cffi==23.1.0
+33
View File
@@ -0,0 +1,33 @@
$ErrorActionPreference = 'Stop'
$repo = Split-Path -Parent $PSScriptRoot
$secretDir = Join-Path $repo 'secrets'
New-Item -ItemType Directory -Path $secretDir -Force | Out-Null
$secretNames = @('postgres_password', 'redis_password', 'database_url', 'cache_url')
$existing = @($secretNames | Where-Object { Test-Path -LiteralPath (Join-Path $secretDir $_) })
if ($existing.Count -eq $secretNames.Count) {
Write-Output 'All local secret files already exist; they were left unchanged.'
return
}
if ($existing.Count -gt 0) {
throw 'Some but not all local secret files exist. Resolve them manually; this script will not rotate credentials.'
}
function New-Secret {
$bytes = New-Object byte[] 32
[System.Security.Cryptography.RandomNumberGenerator]::Fill($bytes)
return [Convert]::ToBase64String($bytes).TrimEnd('=').Replace('+', '-').Replace('/', '_')
}
$postgresPassword = New-Secret
$redisPassword = New-Secret
$files = @{
postgres_password = $postgresPassword
redis_password = $redisPassword
database_url = "postgresql+psycopg://messenger:$postgresPassword@db:5432/messenger"
cache_url = "redis://:$redisPassword@redis:6379/0"
}
foreach ($name in $secretNames) {
$path = Join-Path $secretDir $name
[System.IO.File]::WriteAllText($path, $files[$name], [System.Text.UTF8Encoding]::new($false))
}
Write-Output 'Local Postgres and Redis credentials created under secrets/. Values were not displayed.'
+20
View File
@@ -0,0 +1,20 @@
#!/usr/bin/env sh
set -eu
cd "$(dirname "$0")/.."
# Stop the API before its state stores; named volumes are left intact.
docker compose stop api redis db
docker compose start db redis
attempt=0
until docker compose exec -T db pg_isready -U messenger -d messenger >/dev/null 2>&1 \
&& docker compose exec -T redis sh -ec 'REDISCLI_AUTH="$(cat /run/secrets/redis_password)" redis-cli ping | grep -q PONG' >/dev/null 2>&1; do
attempt=$((attempt + 1))
if [ "$attempt" -ge 60 ]; then
echo 'Database/cache did not become ready within 60 seconds.' >&2
exit 1
fi
sleep 1
done
docker compose start api
+1
View File
@@ -0,0 +1 @@
"""MTUSI Lab 2 API."""
+19
View File
@@ -0,0 +1,19 @@
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from .settings import load_database_url
engine = create_engine(
load_database_url(),
pool_size=5,
max_overflow=5,
pool_timeout=3,
pool_recycle=1800,
pool_pre_ping=True,
connect_args={
"connect_timeout": 3,
"options": "-c statement_timeout=5000",
},
)
SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+23
View File
@@ -0,0 +1,23 @@
from fastapi import Request
from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, code: str, message: str, status: int, challenge: str | None = None):
super().__init__(message)
self.code = code
self.message = message
self.status = status
self.challenge = challenge
def error_response(request: Request, code: str, message: str, status: int, challenge: str | None = None):
request_id = getattr(request.state, "request_id", "unknown")
headers = {"X-Request-Id": request_id, "Cache-Control": "no-store"}
if challenge:
headers["WWW-Authenticate"] = challenge
return JSONResponse(
status_code=status,
headers=headers,
content={"error": {"code": code, "message": message, "request_id": request_id}},
)
+71
View File
@@ -0,0 +1,71 @@
"""Create 10,000 disposable rows and record the indexed keyset-page plan."""
import json
import uuid
from sqlalchemy import text
from .db import engine
def run() -> None:
user_id = uuid.uuid4()
chat_id = uuid.uuid4()
plan_json = None
with engine.connect() as connection:
transaction = connection.begin()
try:
connection.execute(
text("INSERT INTO users(id, username, display_name, password_hash) "
"VALUES (:id, :username, 'Synthetic plan fixture', 'not-a-login-hash')"),
{"id": user_id, "username": "plan_" + uuid.uuid4().hex[:20]},
)
connection.execute(
text("INSERT INTO chats(id, title) VALUES (:id, 'Synthetic plan fixture')"),
{"id": chat_id},
)
connection.execute(
text("INSERT INTO chat_members(chat_id, user_id) VALUES (:chat_id, :user_id)"),
{"chat_id": chat_id, "user_id": user_id},
)
connection.execute(
text("""
INSERT INTO messages(id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), :chat_id, :sender_id,
'synthetic message ' || n::text,
TIMESTAMPTZ '2025-01-01 00:00:00+00' + n * INTERVAL '1 microsecond'
FROM generate_series(1, 10000) AS n
"""),
{"chat_id": chat_id, "sender_id": user_id},
)
connection.exec_driver_sql("ANALYZE messages")
raw = connection.execute(
text("""
EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = :chat_id
AND (created_at, id) > (TIMESTAMPTZ '2025-01-01 00:00:00+00',
'00000000-0000-0000-0000-000000000000'::uuid)
ORDER BY created_at, id
LIMIT 50
"""),
{"chat_id": chat_id},
).scalar_one()
plan_json = raw if isinstance(raw, list) else json.loads(raw)
finally:
transaction.rollback()
document = plan_json[0]
def contains_history_index(node: dict) -> bool:
if node.get("Index Name") == "messages_history_idx":
return True
return any(contains_history_index(child) for child in node.get("Plans", []))
if not contains_history_index(document["Plan"]):
raise SystemExit("Planner did not use messages_history_idx; inspect and revise the query/index.")
print(json.dumps(document, indent=2, sort_keys=True))
if __name__ == "__main__":
run()
+456
View File
@@ -0,0 +1,456 @@
import base64
import binascii
from datetime import datetime, timedelta, timezone
import hashlib
import json
import logging
import re
import secrets
import uuid
from argon2 import PasswordHasher, Type
from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from redis import Redis
from redis.exceptions import RedisError
from sqlalchemy import and_, func, or_, select, text, tuple_
from sqlalchemy.exc import DBAPIError, OperationalError, TimeoutError as SQLAlchemyTimeoutError
from starlette.concurrency import run_in_threadpool
from starlette.exceptions import HTTPException as StarletteHTTPException
from .db import SessionLocal, engine
from .errors import ApiError, error_response
from .models import Chat, ChatMember, Message, User
from .schemas import (
ChatOut,
ChatPage,
CreateChat,
CreateMessage,
CreateUser,
Health,
MessageOut,
MessagePage,
SessionOut,
UserOut,
)
from .settings import load_settings
settings = load_settings()
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
)
logger = logging.getLogger("messenger.api")
password_hasher = PasswordHasher(
time_cost=2,
memory_cost=19_456,
parallelism=1,
hash_len=32,
salt_len=16,
type=Type.ID,
)
DUMMY_PASSWORD_HASH = password_hasher.hash("dummy-password-for-timing-only")
redis_client = Redis.from_url(
settings.cache_url,
decode_responses=True,
socket_connect_timeout=2,
socket_timeout=2,
health_check_interval=30,
)
app = FastAPI(title="MTUSI Messenger — Lab 2", version="1.2.0")
BEARER_CHALLENGE = 'Bearer realm="messenger"'
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
TOKEN_RE = re.compile(r"^[A-Za-z0-9_-]{43}$")
def _iso(value: datetime) -> str:
if value.tzinfo is None:
value = value.replace(tzinfo=timezone.utc)
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def _user_out(user: User) -> dict:
return {
"id": str(user.id),
"username": user.username,
"display_name": user.display_name,
"created_at": _iso(user.created_at),
}
def _message_out(message: Message) -> dict:
return {
"id": str(message.id),
"chat_id": str(message.chat_id),
"sender_id": str(message.sender_id),
"text": message.text,
"created_at": _iso(message.created_at),
}
def _chat_out(session, chat: Chat) -> dict:
members = session.scalars(
select(ChatMember.user_id)
.where(ChatMember.chat_id == chat.id)
.order_by(ChatMember.user_id)
).all()
return {
"id": str(chat.id),
"title": chat.title,
"member_ids": [str(member_id) for member_id in members],
"created_at": _iso(chat.created_at),
}
def _api_error(code: str, message: str, status: int, challenge: str | None = None) -> ApiError:
return ApiError(code, message, status, challenge)
def _unauthorized(challenge: str = BEARER_CHALLENGE) -> ApiError:
return _api_error("unauthorized", "Нет действительной идентификации", 401, challenge)
def _encode_cursor(payload: dict) -> str:
raw = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def _decode_cursor(value: str) -> dict:
try:
padded = value + ("=" * ((4 - len(value) % 4) % 4))
raw = base64.b64decode(padded.encode("ascii"), altchars=b"-_", validate=True)
payload = json.loads(raw.decode("utf-8"))
if not isinstance(payload, dict):
raise ValueError("cursor must be an object")
return payload
except (ValueError, UnicodeError, binascii.Error, json.JSONDecodeError) as exc:
raise _api_error("invalid_request", "Неверный cursor", 400) from exc
def _cursor_position(payload: dict) -> tuple[datetime, uuid.UUID]:
try:
created_at = datetime.fromisoformat(payload["t"].replace("Z", "+00:00"))
if created_at.tzinfo is None:
raise ValueError("cursor time must include timezone")
item_id = uuid.UUID(payload["i"])
return created_at.astimezone(timezone.utc), item_id
except (KeyError, TypeError, ValueError, AttributeError) as exc:
raise _api_error("invalid_request", "Неверный cursor", 400) from exc
def _session_key(token: str) -> str:
digest = hashlib.sha256(token.encode("ascii")).hexdigest()
return "session:v1:" + digest
def _parse_bearer(request: Request) -> str:
header = request.headers.get("authorization", "")
scheme, separator, token = header.partition(" ")
if scheme.lower() != "bearer" or not separator or not TOKEN_RE.fullmatch(token):
raise _unauthorized()
return token
def _load_session(token: str) -> dict:
value = redis_client.get(_session_key(token))
if value is None:
raise _unauthorized()
try:
session = json.loads(value)
user_id = uuid.UUID(session["user_id"])
expires_at = datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
if expires_at.tzinfo is None or datetime.now(timezone.utc) >= expires_at:
redis_client.delete(_session_key(token))
raise _unauthorized()
return {"user_id": user_id, "expires_at": expires_at}
except ApiError:
raise
except (KeyError, TypeError, ValueError, AttributeError, json.JSONDecodeError):
redis_client.delete(_session_key(token))
raise _unauthorized() from None
def _current_user(request: Request) -> tuple[User, str]:
token = _parse_bearer(request)
session_data = _load_session(token)
with SessionLocal() as session:
user = session.get(User, session_data["user_id"])
if user is None:
redis_client.delete(_session_key(token))
raise _unauthorized()
return user, token
def _parse_basic(header: str) -> tuple[str, str]:
scheme, separator, encoded = header.partition(" ")
if scheme.lower() != "basic" or not separator or not encoded:
raise _unauthorized(BASIC_CHALLENGE)
try:
decoded = base64.b64decode(encoded.encode("ascii"), validate=True).decode("utf-8")
username, password = decoded.split(":", 1)
except (UnicodeError, ValueError, binascii.Error):
raise _unauthorized(BASIC_CHALLENGE) from None
if not USERNAME_RE.fullmatch(username) or not password:
raise _unauthorized(BASIC_CHALLENGE)
return username, password
def _password_matches(password_hash: str, password: str) -> bool:
try:
return password_hasher.verify(password_hash, password)
except (VerifyMismatchError, VerificationError, InvalidHashError):
return False
def _create_session(username: str, password: str) -> dict:
with SessionLocal() as session:
user = session.scalar(select(User).where(User.username == username))
stored_hash = user.password_hash if user is not None else DUMMY_PASSWORD_HASH
password_ok = _password_matches(stored_hash, password)
if user is None or not password_ok:
raise _unauthorized(BASIC_CHALLENGE)
user_payload = _user_out(user)
expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.session_ttl_seconds)
for _ in range(3):
token = secrets.token_urlsafe(32)
stored_value = json.dumps(
{"user_id": user_payload["id"], "expires_at": _iso(expires_at)},
separators=(",", ":"),
)
if redis_client.set(_session_key(token), stored_value, ex=settings.session_ttl_seconds, nx=True):
return {
"token": token,
"token_type": "Bearer",
"expires_at": _iso(expires_at),
"user": user_payload,
}
logger.error("session_token_collision_limit_reached")
raise _api_error("unavailable", "Сервис временно недоступен", 503)
def _get_chat_for_member(session, chat_id: uuid.UUID, user_id: uuid.UUID) -> Chat | None:
return session.scalar(
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
@app.middleware("http")
async def request_id_middleware(request: Request, call_next):
request_id = str(uuid.uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
return response
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
return error_response(request, exc.code, exc.message, exc.status, exc.challenge)
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, _exc: RequestValidationError):
return error_response(request, "invalid_request", "Неверный запрос", 400)
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException):
if exc.status_code == 404:
return error_response(request, "not_found", "Объект не найден", 404)
return error_response(request, "invalid_request", "Неверный запрос", 400)
@app.exception_handler(OperationalError)
@app.exception_handler(SQLAlchemyTimeoutError)
async def handle_database_unavailable(request: Request, exc: Exception):
logger.warning("database_unavailable request_id=%s type=%s", request.state.request_id, type(exc).__name__)
return error_response(request, "unavailable", "Сервис временно недоступен", 503)
@app.exception_handler(RedisError)
async def handle_cache_unavailable(request: Request, exc: RedisError):
logger.warning("session_store_unavailable request_id=%s type=%s", request.state.request_id, type(exc).__name__)
return error_response(request, "unavailable", "Сервис временно недоступен", 503)
@app.exception_handler(DBAPIError)
async def handle_database_error(request: Request, exc: DBAPIError):
if exc.connection_invalidated:
logger.warning("database_connection_lost request_id=%s", request.state.request_id)
return error_response(request, "unavailable", "Сервис временно недоступен", 503)
logger.error("database_error request_id=%s type=%s", request.state.request_id, type(exc).__name__)
return error_response(request, "internal_error", "Внутренняя ошибка", 500)
@app.exception_handler(Exception)
async def handle_unexpected_error(request: Request, exc: Exception):
logger.error("internal_error request_id=%s type=%s", request.state.request_id, type(exc).__name__)
return error_response(request, "internal_error", "Внутренняя ошибка", 500)
@app.get("/health/live", response_model=Health)
def live():
return {"status": "ok"}
@app.get("/health/ready", response_model=Health, responses={503: {"description": "Dependency unavailable"}})
def ready():
with SessionLocal() as session:
session.execute(text("SELECT 1"))
redis_client.ping()
return {"status": "ok"}
@app.post("/api/v1/users", response_model=UserOut, status_code=201)
def register_user(payload: CreateUser):
password_hash = password_hasher.hash(payload.password)
user = User(username=payload.username, display_name=payload.display_name, password_hash=password_hash)
try:
with SessionLocal.begin() as session:
session.add(user)
session.flush()
except DBAPIError as exc:
if getattr(getattr(exc, "orig", None), "sqlstate", None) == "23505":
raise _api_error("conflict", "username занят", 409) from exc
raise
return _user_out(user)
@app.post("/api/v1/auth/sessions", response_model=SessionOut, status_code=201)
async def create_session(request: Request):
if await request.body():
raise _api_error("invalid_request", "Basic authentication must not include a body", 400)
username, password = _parse_basic(request.headers.get("authorization", ""))
return await run_in_threadpool(_create_session, username, password)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(request: Request):
_user, token = _current_user(request)
redis_client.delete(_session_key(token))
return None
@app.get("/api/v1/users/me", response_model=UserOut)
def current_user(request: Request):
user, _token = _current_user(request)
return _user_out(user)
@app.post("/api/v1/chats", response_model=ChatOut, status_code=201)
def create_chat(payload: CreateChat, request: Request):
user, _token = _current_user(request)
member_ids = [uuid.UUID(value) for value in payload.member_ids]
if user.id not in member_ids:
raise _api_error("invalid_request", "Вызывающий должен входить в member_ids", 400)
try:
with SessionLocal.begin() as session:
chat = Chat(title=payload.title)
session.add(chat)
session.flush()
session.add_all(ChatMember(chat_id=chat.id, user_id=member_id) for member_id in member_ids)
session.flush()
result = _chat_out(session, chat)
except DBAPIError as exc:
if getattr(getattr(exc, "orig", None), "sqlstate", None) in {"23503", "23505"}:
raise _api_error("invalid_request", "Неизвестный участник", 400) from exc
raise
return result
@app.get("/api/v1/chats", response_model=ChatPage)
def list_chats(request: Request, limit: int = 50, cursor: str | None = None):
user, _token = _current_user(request)
if limit < 1 or limit > 100:
raise _api_error("invalid_request", "limit вне диапазона", 400)
statement = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user.id)
.order_by(Chat.created_at, Chat.id)
)
if cursor is not None:
payload = _decode_cursor(cursor)
if payload.get("u") != str(user.id):
raise _api_error("invalid_request", "Неверный cursor", 400)
created_at, chat_id = _cursor_position(payload)
statement = statement.where(tuple_(Chat.created_at, Chat.id) > tuple_(created_at, chat_id))
with SessionLocal() as session:
chats = session.scalars(statement.limit(limit + 1)).all()
has_more = len(chats) > limit
page = chats[:limit]
items = [_chat_out(session, chat) for chat in page]
next_cursor = None
if has_more:
last = page[-1]
next_cursor = _encode_cursor({"u": str(user.id), "t": _iso(last.created_at), "i": str(last.id)})
return {"items": items, "next_cursor": next_cursor}
@app.get("/api/v1/chats/{chat_id}", response_model=ChatOut)
def get_chat(chat_id: uuid.UUID, request: Request):
user, _token = _current_user(request)
with SessionLocal() as session:
chat = _get_chat_for_member(session, chat_id, user.id)
if chat is None:
raise _api_error("not_found", "Объект не найден", 404)
return _chat_out(session, chat)
@app.post("/api/v1/chats/{chat_id}/messages", response_model=MessageOut, status_code=201)
def create_message(chat_id: uuid.UUID, payload: CreateMessage, request: Request):
user, _token = _current_user(request)
with SessionLocal.begin() as session:
chat = _get_chat_for_member(session, chat_id, user.id)
if chat is None:
raise _api_error("not_found", "Объект не найден", 404)
if not payload.text.strip():
raise _api_error("invalid_request", "Сообщение не может состоять только из пробелов", 400)
message = Message(chat_id=chat_id, sender_id=user.id, text=payload.text)
session.add(message)
session.flush()
result = _message_out(message)
return result
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
def list_messages(chat_id: uuid.UUID, request: Request, limit: int = 50, cursor: str | None = None):
user, _token = _current_user(request)
with SessionLocal() as session:
chat = _get_chat_for_member(session, chat_id, user.id)
if chat is None:
raise _api_error("not_found", "Объект не найден", 404)
if limit < 1 or limit > 100:
raise _api_error("invalid_request", "limit вне диапазона", 400)
after = None
if cursor is not None:
payload = _decode_cursor(cursor)
if payload.get("c") != str(chat_id):
raise _api_error("invalid_request", "cursor от другого чата", 400)
after = _cursor_position(payload)
statement = select(Message).where(Message.chat_id == chat_id)
if after is not None:
statement = statement.where(tuple_(Message.created_at, Message.id) > tuple_(*after))
statement = statement.order_by(Message.created_at, Message.id).limit(limit + 1)
rows = session.scalars(statement).all()
has_more = len(rows) > limit
page = rows[:limit]
items = [_message_out(message) for message in page]
next_cursor = None
if has_more:
last = page[-1]
next_cursor = _encode_cursor({"c": str(chat_id), "t": _iso(last.created_at), "i": str(last.id)})
return {"items": items, "next_cursor": next_cursor}
+36
View File
@@ -0,0 +1,36 @@
from pathlib import Path
from sqlalchemy import text
from .db import engine
MIGRATIONS = Path(__file__).resolve().parents[2] / "migrations"
def migrate() -> None:
with engine.begin() as connection:
connection.exec_driver_sql("SELECT pg_advisory_xact_lock(2026102202)")
connection.exec_driver_sql(
"CREATE TABLE IF NOT EXISTS schema_migrations "
"(version VARCHAR(128) PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP)"
)
applied = set(connection.execute(text("SELECT version FROM schema_migrations")).scalars())
for path in sorted(MIGRATIONS.glob("*.sql")):
version = path.stem
if version in applied:
continue
sql = path.read_text(encoding="utf-8")
for statement in sql.split(";"):
if statement.strip():
connection.exec_driver_sql(statement)
connection.execute(
text("INSERT INTO schema_migrations(version) VALUES (:version)"),
{"version": version},
)
print(f"Applied migration {version}")
engine.dispose()
if __name__ == "__main__":
migrate()
+61
View File
@@ -0,0 +1,61 @@
import uuid
from datetime import datetime
from sqlalchemy import DateTime, ForeignKey, ForeignKeyConstraint, Index, String, Text, func
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
class Base(DeclarativeBase):
pass
class User(Base):
__tablename__ = "users"
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
username: Mapped[str] = mapped_column(String(32), nullable=False, unique=True)
display_name: Mapped[str] = mapped_column(String(100), nullable=False)
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
class Chat(Base):
__tablename__ = "chats"
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
title: Mapped[str] = mapped_column(String(100), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
class ChatMember(Base):
__tablename__ = "chat_members"
__table_args__ = (
Index("chat_members_user_id_idx", "user_id", "chat_id"),
)
chat_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True
)
user_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True), ForeignKey("users.id", ondelete="RESTRICT"), primary_key=True
)
class Message(Base):
__tablename__ = "messages"
__table_args__ = (
ForeignKeyConstraint(
["chat_id", "sender_id"],
["chat_members.chat_id", "chat_members.user_id"],
name="messages_sender_is_chat_member_fk",
ondelete="CASCADE",
),
Index("messages_history_idx", "chat_id", "created_at", "id"),
)
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
chat_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), nullable=False)
sender_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), nullable=False)
text: Mapped[str] = mapped_column(String(4000), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
+94
View File
@@ -0,0 +1,94 @@
from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
class StrictModel(BaseModel):
model_config = ConfigDict(extra="forbid")
class CreateUser(StrictModel):
username: StrictStr = Field(min_length=3, max_length=32, pattern=r"^[a-z0-9_]{3,32}$")
display_name: StrictStr = Field(min_length=1, max_length=100)
password: StrictStr = Field(min_length=12, max_length=128)
@field_validator("display_name")
@classmethod
def display_name_not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError("display_name must contain a non-whitespace character")
return value
class UserOut(BaseModel):
id: str
username: str
display_name: str
created_at: str
class CreateChat(StrictModel):
title: StrictStr = Field(min_length=1, max_length=100)
member_ids: list[StrictStr] = Field(min_length=1, max_length=100)
@field_validator("title")
@classmethod
def title_not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError("title must contain a non-whitespace character")
return value
@field_validator("member_ids")
@classmethod
def members_are_unique_uuids(cls, values: list[str]) -> list[str]:
import uuid
try:
normalized = [str(uuid.UUID(value)) for value in values]
except (ValueError, AttributeError, TypeError) as exc:
raise ValueError("member_ids must contain UUIDs") from exc
if len(normalized) != len(set(normalized)):
raise ValueError("member_ids must be unique")
return normalized
class ChatOut(BaseModel):
id: str
title: str
member_ids: list[str]
created_at: str
class ChatPage(BaseModel):
items: list[ChatOut]
next_cursor: str | None
class CreateMessage(StrictModel):
text: StrictStr = Field(min_length=1, max_length=4000)
class MessageOut(BaseModel):
id: str
chat_id: str
sender_id: str
text: str
created_at: str
class MessagePage(BaseModel):
items: list[MessageOut]
next_cursor: str | None
class SessionOut(BaseModel):
token: str
token_type: str = "Bearer"
expires_at: str
user: UserOut
class Health(BaseModel):
status: str = "ok"
class ErrorBody(BaseModel):
error: dict[str, str]
+37
View File
@@ -0,0 +1,37 @@
from dataclasses import dataclass
import os
from pathlib import Path
def _secret(file_variable: str, value_variable: str) -> str:
file_path = os.environ.get(file_variable)
if file_path:
value = Path(file_path).read_text(encoding="utf-8").strip()
else:
value = os.environ.get(value_variable, "").strip()
if not value:
raise RuntimeError(f"Required setting {file_variable} is missing")
return value
def load_database_url() -> str:
return _secret("DATABASE_URL_FILE", "DATABASE_URL")
@dataclass(frozen=True)
class Settings:
cache_url: str
session_ttl_seconds: int
def load_settings() -> Settings:
try:
ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
except ValueError as exc:
raise RuntimeError("SESSION_TTL_SECONDS must be an integer") from exc
if ttl < 1 or ttl > 31_536_000:
raise RuntimeError("SESSION_TTL_SECONDS must be between 1 and 31536000")
return Settings(
cache_url=_secret("CACHE_URL_FILE", "CACHE_URL"),
session_ttl_seconds=ttl,
)
+14
View File
@@ -171,6 +171,20 @@ class Client:
self.call('GET','/health/live',schema='Health')
self.call('GET','/health/ready',schema='Health')
alice, bob, eve = (self.user(label) for label in ('alice','bob','eve'))
if LAB >= 2:
# Grade-4 runs with a 10-second TTL. Creating and authenticating the
# other users can outlive Alice's initial session before chat creation.
registration = alice['registration']
credential = base64.b64encode(
(registration['username'] + ':' + registration['password']).encode()
).decode()
session = self.call(
'POST', '/api/v1/auth/sessions', 201,
headers={'Authorization':'Basic ' + credential}, schema='Session'
)['json']
check(session['user'] == alice['user'], 'session user mismatch')
check(timestamp(session['expires_at']) > dt.datetime.now(dt.timezone.utc), 'session already expired')
alice['token'] = session['token']
chat = self.call('POST','/api/v1/chats',201,actor=alice,body={'title':'Контрактный тест','member_ids':[alice['id'],bob['id']]},schema='Chat')['json']
check(set(chat['member_ids'])=={alice['id'],bob['id']},'chat member mismatch')
return alice,bob,eve,chat
+205
View File
@@ -0,0 +1,205 @@
#!/usr/bin/env python3
"""Manual integration checks for Lab 2 grade 4; uses a disposable local Compose stack."""
import base64
import concurrent.futures
import json
from pathlib import Path
import subprocess
import time
import urllib.error
import urllib.request
import uuid
from client import Client, Failure, arguments, check, run
ROOT = Path(__file__).resolve().parents[1]
def compose(*args: str) -> None:
subprocess.run(["docker", "compose", *args], cwd=ROOT, check=True, capture_output=True, text=True)
def compose_output(*args: str) -> str:
result = subprocess.run(["docker", "compose", *args], cwd=ROOT, check=True, capture_output=True, text=True)
return result.stdout.strip()
def get_status(base_url: str, path: str, actor=None) -> tuple[int, dict, object, float]:
headers = {"Accept": "application/json"}
if actor:
headers["Authorization"] = "Bearer " + actor["token"]
request = urllib.request.Request(base_url.rstrip("/") + path, headers=headers)
started = time.monotonic()
try:
response = urllib.request.urlopen(request, timeout=10)
except urllib.error.HTTPError as exc:
response = exc
with response:
headers = {name.lower(): value for name, value in response.headers.items()}
body = json.loads(response.read())
return response.status, headers, body, time.monotonic() - started
def register_once(base_url: str, username: str, password: str) -> int:
body = json.dumps({"username": username, "display_name": "Race test", "password": password}).encode()
request = urllib.request.Request(
base_url.rstrip("/") + "/api/v1/users",
data=body,
headers={"Content-Type": "application/json"},
method="POST",
)
try:
response = urllib.request.urlopen(request, timeout=10)
except urllib.error.HTTPError as exc:
response = exc
with response:
return response.status
def fresh_actor(client: Client, registration: dict) -> dict:
credential = base64.b64encode(
(registration["username"] + ":" + registration["password"]).encode()
).decode()
session = client.call(
"POST",
"/api/v1/auth/sessions",
201,
headers={"Authorization": "Basic " + credential},
schema="Session",
)["json"]
return {
"id": session["user"]["id"],
"user": session["user"],
"registration": registration,
"token": session["token"],
}
def wait_ready(base_url: str, timeout: int = 45) -> None:
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
status, _headers, _body, _elapsed = get_status(base_url, "/health/ready")
if status == 200:
return
except Exception:
pass
time.sleep(0.5)
raise Failure("API did not become ready after restoring a dependency")
def main() -> None:
args = arguments("Lab 2 grade-4 checks; dependency-outage checks restart Compose services")
client = Client(args.base_url)
config = subprocess.run(
["docker", "compose", "config", "--format", "json"],
cwd=ROOT,
check=True,
capture_output=True,
text=True,
)
ttl = int(json.loads(config.stdout)["services"]["api"]["environment"]["SESSION_TTL_SECONDS"])
check(ttl <= 10, "Run this check with SESSION_TTL_SECONDS=10 to verify expiry.")
alice, bob, _eve, chat = client.bootstrap()
registration = alice["registration"]
bad = base64.b64encode((registration["username"] + ":wrong-password").encode()).decode()
client.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": "Basic " + bad})
print("PASS: invalid password returns the same Basic 401 challenge")
alice = fresh_actor(client, registration)
chat_count_before = len(client.call("GET", "/api/v1/chats?limit=100", actor=alice, schema="ChatPage")["json"]["items"])
unknown_id = str(uuid.uuid4())
failed_title = "must_roll_back_" + uuid.uuid4().hex[:12]
client.call(
"POST",
"/api/v1/chats",
400,
actor=alice,
body={"title": failed_title, "member_ids": [alice["id"], unknown_id]},
)
chat_count_after = len(client.call("GET", "/api/v1/chats?limit=100", actor=alice, schema="ChatPage")["json"]["items"])
check(chat_count_after == chat_count_before, "invalid chat creation left visible partial state")
stored_failed_chats = compose_output(
"exec", "-T", "db", "psql", "-U", "messenger", "-d", "messenger", "-Atc",
f"SELECT count(*) FROM chats WHERE title = '{failed_title}'",
)
check(stored_failed_chats == "0", "database kept a chat row after the member foreign-key rollback")
print("PASS: invalid composite chat creation leaves no chat")
race_name = "race_" + uuid.uuid4().hex[:20]
race_password = "T3st-" + uuid.uuid4().hex
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
statuses = list(executor.map(lambda _i: register_once(client.base, race_name, race_password), range(2)))
check(statuses.count(201) == 1 and statuses.count(409) == 1, "username race was not resolved by the unique constraint")
print("PASS: concurrent duplicate registration produced one 201 and one 409 response")
expiring = client.call(
"POST",
"/api/v1/auth/sessions",
201,
headers={"Authorization": "Basic " + base64.b64encode(
(registration["username"] + ":" + registration["password"]).encode()
).decode()},
schema="Session",
)["json"]
time.sleep(ttl + 1)
status, headers, body, _elapsed = get_status(client.base, "/api/v1/users/me", {"token": expiring["token"]})
check(
status == 401 and headers.get("www-authenticate", "").lower().startswith("bearer"),
"expired session was not rejected with a Bearer challenge",
)
check(body["error"]["code"] == "unauthorized", "expired session returned the wrong error")
print("PASS: session expiry with short TTL")
# A protected request fails closed when Redis is unavailable; the stack is restored in finally.
alice = fresh_actor(client, registration)
compose("stop", "redis")
try:
try:
status, _headers, body, elapsed = get_status(client.base, "/api/v1/users/me", alice)
except OSError as exc:
raise Failure("Redis outage request timed out before the API returned 503") from exc
check(
status == 503 and body["error"]["code"] == "unavailable" and elapsed <= 8,
f"Redis outage did not return a bounded 503 (status={status}, elapsed={elapsed:.2f}s)",
)
print("PASS: Redis outage returns bounded 503")
finally:
compose("start", "redis")
wait_ready(client.base)
# Database loss has the same bounded behavior and does not trust a cached identity.
bob = fresh_actor(client, bob["registration"])
compose("stop", "db")
try:
try:
status, _headers, body, elapsed = get_status(client.base, "/api/v1/users/me", bob)
except OSError as exc:
raise Failure("Postgres outage request timed out before the API returned 503") from exc
check(
status == 503 and body["error"]["code"] == "unavailable" and elapsed <= 8,
f"Postgres outage did not return a bounded 503 (status={status}, elapsed={elapsed:.2f}s)",
)
print("PASS: Postgres outage returns bounded 503")
finally:
compose("start", "db")
wait_ready(client.base)
# Explicitly verify logout too; the public smoke covers this but grade 4 records it separately.
bob = fresh_actor(client, bob["registration"])
client.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=bob)
client.call("GET", "/api/v1/users/me", 401, actor=bob)
print("PASS: logout revokes the bearer session")
# A harmless read confirms the restored stack and the same persistent conversation still work.
alice = fresh_actor(client, registration)
client.call("GET", "/api/v1/chats/" + chat["id"], 200, actor=alice, schema="Chat")
print("PASS: API and persistent stores are ready after dependency restarts")
if __name__ == "__main__":
run(main)