3 Commits
Author SHA1 Message Date
imenno_on d1e55ec38d Документировать карту инфраструктуры Lab 2
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-10-18 16:07:56 +03:00
imenno_on 38de8782c4 Заполнить PR-шаблон и вывод make test 2026-10-18 16:03:35 +03:00
imenno_on be7a90132b Реализовать лабораторную работу 2 2026-10-18 15:53:16 +03:00
50 changed files with 2040 additions and 34 deletions
+10 -5
View File
@@ -2,10 +2,15 @@
# 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
POSTGRES_PORT=5432
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
POSTGRES_USER=messenger
POSTGRES_PASSWORD=replace_with_a_local_password
POSTGRES_DB=messenger
SESSION_TTL_SECONDS=3600
DB_POOL_MIN_SIZE=1
DB_POOL_MAX_SIZE=10
DB_POOL_ACQUIRE_TIMEOUT_SECONDS=3
DB_COMMAND_TIMEOUT_SECONDS=5
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
REDIS_TIMEOUT_SECONDS=2
+51 -14
View File
@@ -1,18 +1,55 @@
## Лабораторная 2
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Федотов Михаил, БВТ2302
Целевая оценка (3/4/5): **4**
Трек 5: **не заявлен**
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
### Что реализовано и что перенесено
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
- Реализован HTTP API на FastAPI; PostgreSQL хранит пользователей, чаты, участников и сообщения. Схема создаётся версионируемыми миграциями.
- Создание чата и его участников атомарно. История сообщений читается keyset-пагинацией по индексу `(chat_id, created_at, id)`.
- Redis используется как хранилище сессий: непрозрачный Bearer-токен, фиксированный TTL, logout и AOF persistence. Пароли хешируются Argon2id; SQL-запросы параметризованы.
- Переход аутентификации объявлен: пароль задаётся при регистрации, Basic применяется только для `POST /auth/sessions`, бизнес-запросы используют Bearer. Lab1 в исходном репозитории представлен skeleton; совместимость с прежним `X-User-Id` как механизмом доступа не сохраняется. Миграция 0002 удаляет старые сессии PostgreSQL, поэтому после обновления нужно войти заново.
### Запуск из чистого clone
Из корня репозитория в WSL (нужны Docker Compose и Python 3):
```sh
cp -n .env.example .env
# Установить локальный POSTGRES_PASSWORD в .env.
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
docker compose ps # дождаться healthy у api, postgres и redis
make check
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-grade4
docker compose --env-file .env down # тома сохраняются
```
### Результаты проверок
- `make check` — PASS; `make test` — PASS; `make test-grade4` — PASS, включая smoke и persistence.
- Проверены параллельная регистрация (1 × 201, 7 × 409), неверный пароль (401), rollback создания чата, expiry сессии, отказы Redis/PostgreSQL с ограниченным 503 и восстановление после перезапуска.
- `EXPLAIN (ANALYZE, BUFFERS)` на 10 000 синтетических сообщений выбрал `messages_history_idx`; страница из 50 строк прочитала 6 shared buffers. Это единичный замер плана запроса, не нагрузочный benchmark.
- Реальный stdout сохранён в [`evidence/make-check.txt`](../../evidence/make-check.txt), [`evidence/make-test.txt`](../../evidence/make-test.txt), [`evidence/make-test-grade4.txt`](../../evidence/make-test-grade4.txt), [`evidence/explain-history.txt`](../../evidence/explain-history.txt) и других файлах каталога `evidence/`.
- Подробное описание архитектуры, проверок и ограничений: [`REPORT.md`](../../REPORT.md).
### Ограничения / известные ошибки
- Уровень 5 и его экспериментальный трек не заявляются; пропускная способность под длительной нагрузкой и RTO/RPO не измерялись.
- Не проверялись восстановление из отдельной резервной копии и потеря/повреждение файлов Redis AOF при отказе хоста.
- При потере Redis аутентифицированные операции завершаются ограниченной ошибкой; резервного хранилища сессий нет.
- Старые PG-сессии при миграции 0002 отзываются; требуется повторный вход.
### Источники и использование ИИ
Использованы материалы из README задания: [PostgreSQL transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html), [PostgreSQL EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html), [Redis persistence](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/) и [RFC 7617](https://www.rfc-editor.org/info/rfc7617/). При подготовке кода и документации использовался Codex (ИИ-ассистент); результат проверен командами и сценариями, указанными выше.
- [x] Обязательный минимум текущего задания реализован; переход от lab1 и изменение аутентификации объявлены выше и в `REPORT.md`.
- [x] Контракт и публичные тесты не ослаблялись.
- [x] `make check` и `make test` выполнены; фактический stdout приложен в `evidence/`.
- [x] Проверены сценарии отказов и безопасности уровня 4.
- [x] `.env`, токены и приватные ключи в Git не добавлялись; доказательства обезличены.
- [x] Исходный README задания сохранён; инструкция запуска именно этой реализации находится в `REPORT.md`.
+16
View File
@@ -0,0 +1,16 @@
FROM python:3.12.8-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements-app.txt ./
RUN pip install --no-cache-dir -r requirements-app.txt
COPY app ./app
COPY migrations ./migrations
COPY scripts ./scripts
RUN useradd --create-home --uid 10001 appuser
USER appuser
EXPOSE 8080
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
+4 -1
View File
@@ -4,7 +4,7 @@ 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
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,6 @@ 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:
./scripts/test-grade4.sh
+35 -14
View File
@@ -1,37 +1,58 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Федотов Михаил, БВТ2302
- Целевая оценка: 4
- Commit/PR: `be7a901` (реализация; PR ещё не создан)
- Источники и библиотеки: PostgreSQL 16.4, Redis 7.4.2, FastAPI 0.115.6, asyncpg 0.30.0, redis-py 5.2.1, Argon2id через argon2-cffi 23.1.0. При подготовке кода использовалась помощь ИИ.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Python 3.12.8-slim, PostgreSQL 16.4-alpine и Redis 7.4.2-alpine; зависимости Python закреплены в requirements-app.txt. Создать локальный .env по .env.example, задать пароль из букв и цифр, затем выполнить `docker compose --env-file .env config --quiet`, `docker compose --env-file .env up -d --build`, дождаться healthy у api/postgres/redis через `docker compose ps` и выполнить `make test`. Миграции применяются API при старте. Сохранность проверяется `chmod +x scripts/restart.sh` и `make test-persistence ACTION_SCRIPT=scripts/restart.sh`. Полный набор дополнительных проверок: `make test-grade4`; план истории отдельно: `docker compose exec -T api python scripts/explain_history.py`. Обычная остановка: `docker compose down`; намеренное удаление учебных данных: `docker compose down -v` (не выполнять перед persistence-тестом). Секреты в отчёт не помещать.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Lab1 в указанном репозитории — skeleton без готового приложения. По правилам курса перенесён обязательный минимум API, а переход аутентификации выполнен так: регистрация принимает пароль, Basic используется только для создания сессии, защищённые запросы используют Bearer. Преподавательские контракты, публичные тесты и комментарии вне `app/` сохранены.
FastAPI обращается к PostgreSQL через asyncpg и ограниченный пул соединений. PostgreSQL — источник истины для пользователей, хешей паролей, чатов, участников и сообщений. Redis — источник истины для сессий; Redis AOF использует `appendfsync always`, а сессии задаются абсолютным PXAT и не продлеваются запросами. Logout удаляет ключ. Переходная миграция 0002 аннулирует старые хеши сессий PostgreSQL; после обновления клиент должен войти заново. Миграции выполняются при запуске и отмечаются в schema_migrations; создание чата и его участников проходит в одной транзакции. Bearer-токен генерируется с 256 битами энтропии; Redis содержит только SHA-256-ключ токена, user_id и expires_at. Индексы: уникальность username, список чатов по участнику и история сообщений по (chat_id, created_at, id). Параметры .env задают локальные реквизиты PostgreSQL и TTL; Compose передаёт API внутренние DATABASE_URL и REDIS_URL. Запросы параметризованы asyncpg; пул ограничен min/max size, временем ожидания свободного соединения и таймаутом SQL-команды. История сообщений читает только одну keyset-страницу через индекс `(chat_id, created_at, id)`. Порты API и PostgreSQL проброшены только на `127.0.0.1`, чтобы не выставлять учебный HTTP API и БД наружу.
### Карта инфраструктуры
| Роль | Compose service и версия | Health/readiness | Volume | Сеть и опубликованный порт | Передача credentials |
| --- | --- | --- | --- | --- | --- |
| HTTP API | `api`; локальная сборка из `Dockerfile`, база `python:3.12.8-slim`; Python-пакеты закреплены в `requirements-app.txt` | Compose проверяет `GET /health/ready`; запуск зависит от healthy PostgreSQL и Redis | Нет: API stateless | Внутренняя сеть Compose; наружу только `127.0.0.1:${APP_PORT:-8080}:8080` | Compose подставляет значения `.env` в `DATABASE_URL`; Redis доступен по внутреннему `REDIS_URL` |
| Основная БД | `postgres`, `postgres:16.4-alpine` | `pg_isready` с пользователем и базой из конфигурации | Именованный `postgres_data` → `/var/lib/postgresql/data` | Внутренняя сеть Compose; наружу только `127.0.0.1:${POSTGRES_PORT:-5432}:5432` | `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB` берутся из локального `.env`; пароль также входит во внутренний `DATABASE_URL` API |
| Сессии | `redis`, `redis:7.4.2-alpine` | `redis-cli ping`; API отдельно проверяет доступность зависимости в readiness | Именованный `redis_data` → `/data`; включены AOF и `appendfsync always` | Только внутренняя сеть Compose, host port не опубликован | Пароль Redis не задан; Redis не опубликован на host и доступен сервисам только по внутреннему имени `redis` |
Bootstrap схемы выполняет API при старте: `apply_migrations` создаёт `schema_migrations`, берёт PostgreSQL advisory lock и применяет упорядоченные SQL-файлы. Каждая новая версия и запись о ней фиксируются в одной транзакции; уже отмеченные версии пропускаются, поэтому повторный запуск безопасен. Отдельные bucket/broker provisioning-команды не нужны: эти сервисы в Lab 2 не используются. `scripts/restart.sh` перезапускает PostgreSQL, Redis и API, сохраняя именованные volumes; отдельный failover hook не добавлен, поскольку стенд содержит одну API-реплику и проверяет отказы зависимостей напрямую.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Структура, контракт и синтаксис | `make check` | PASS: локальная структура, ссылки и синтаксис Python | Вывод `make test-grade4` |
| Compose-конфигурация | `docker compose --env-file .env config --quiet` | PASS: конфигурация разобрана без ошибок | Команда воспроизводима из README |
| PostgreSQL, миграции и smoke API | `make test` | PASS: регистрация, Basic/Bearer, доступ к чату, keyset-пагинация, сообщения и logout | Вывод `make test-grade4` |
| Persistence API + PostgreSQL + Redis | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: подтверждённые данные и действующий токен сохранились после перезапуска API и обоих хранилищ с сохранением томов | `scripts/restart.sh`; вывод `make test-grade4` |
| Регистрация при гонке | 8 параллельных `POST /api/v1/users` с одним username | PASS: 1 ответ 201, 7 ответов 409 | `tests/grade4.py`; вывод `make test-grade4` |
| Атомарность создания чата | POST с неизвестным UUID участника и сверка числа чатов | PASS: API вернул 400; частичная запись не осталась | `tests/grade4.py`; вывод `make test-grade4` |
| Redis-сессии и короткий expiry | override `SESSION_TTL_SECONDS=2`, последующий Bearer-запрос | PASS: сессия истекла по исходному TTL и запрос вернул 401; logout также проверяется smoke-тестом | `tests/grade4.py`, `tests/smoke.py`; вывод `make test-grade4` |
| Отказ Redis | остановка Redis и проверка readiness/создания сессии | PASS: оба пути вернули ограниченный 503 `unavailable`; после запуска readiness восстановилась | `tests/grade4.py`; вывод `make test-grade4` |
| Отказ PostgreSQL | остановка PostgreSQL и проверка readiness/регистрации | PASS: оба пути вернули ограниченный 503 `unavailable`; после запуска readiness восстановилась | `tests/grade4.py`; вывод `make test-grade4` |
| План keyset-истории на 10 000 сообщениях | `scripts/explain_history.py` внутри контейнера | PASS: выбран `messages_history_idx`, 50 строк, 6 buffer hits; execution time 0.056 ms в этом запуске | `evidence/explain-history.txt` |
| Обезличенные протоколы stdout | `make check`, `make validate`, Compose config/up/down, `make test`, `make test-grade4`, restart hook | Вывод каждой команды сохранён отдельно; метаданные запуска и состояние контейнеров записаны отдельно, UUID обезличены | `evidence/make-check.txt`, `evidence/make-validate.txt`, `evidence/compose-config.txt`, `evidence/compose-start.txt`, `evidence/make-test.txt`, `evidence/make-test-grade4.txt`, `evidence/restart-hook.txt`, `evidence/compose-shutdown.txt`, `evidence/verification-metadata-2026-10-18.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Все сценарии запускаются командой `make test-grade4`; она собирает образ, задаёт короткий TTL, выполняет дополнительные проверки, восстанавливает штатную конфигурацию, затем запускает smoke и persistence.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Целевой уровень — 4, поэтому сравнительный нагрузочный трек уровня 5 не заявляется. Для критерия плана запроса сценарий создаёт 10 000 синтетических сообщений в отдельном чате, выполняет `ANALYZE`, затем сохраняет фактический `EXPLAIN (ANALYZE, BUFFERS)`. В последнем полном `make test-grade4` запуске PostgreSQL выбрал `messages_history_idx`; страница из 50 строк прочитала 6 shared buffers, время выполнения составило 0.066 ms. Это единичный плановый замер в контейнере, не benchmark и не обещание производительности.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка Redis | Readiness и создание сессии не должны доверять недоступному хранилищу | Ограниченный 503 `unavailable`; после `docker compose start redis` API снова готов | Время измеряется сценарием ожидания, точное число секунд не заявляется; данные Redis-volume не удалялись |
| Остановка PostgreSQL | Readiness и операция записи должны вернуть ограниченную ошибку | Ограниченный 503 `unavailable`; после запуска БД API снова готов | Точное число секунд не заявляется; PostgreSQL-volume не удалялся |
| Перезапуск API, PostgreSQL и Redis | Подтверждённые данные и ещё действующий токен должны сохраниться | Persistence-сценарий повторно прочитал подтверждённые данные с прежним токеном | Томы сохранялись; сценарий проверяет итог, но не измеряет RTO/RPO |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Подтверждены перезапуск всех трёх сервисов без потери тестовых подтверждённых данных, фиксированный expiry Redis-сессии и ограниченная ошибка при недоступности PostgreSQL/Redis. Отказ Redis означает недоступность аутентифицированных операций, а не переход на запасное хранилище. Redis AOF с `appendfsync always` включён, но сбой хоста/файловой системы и восстановление из отдельной резервной копии здесь не проверялись. Нагрузочная пропускная способность и RTO/RPO не измерялись; это не заявлено как трек уровня 5.
View File
View File
+42
View File
@@ -0,0 +1,42 @@
from fastapi import Request
from app.core.errors import ApiError
from app.repositories.memory import SessionRow, UserRow
import uuid as _uuid
BEARER_CHALLENGE = {'WWW-Authenticate': 'Bearer realm="messenger"'}
def storage_of(request: Request):
return request.app.state.storage
async def current_session(request: Request) -> SessionRow:
header = request.headers.get('authorization', '')
token = header[7:].strip() if header[:7].lower() == 'bearer ' else ''
if not token:
raise ApiError(401, 'Bearer session required', headers=BEARER_CHALLENGE)
row = await storage_of(request).session(token)
if row is None:
raise ApiError(401, 'Session is missing, expired or revoked', headers=BEARER_CHALLENGE)
return row
async def current_user(request: Request) -> UserRow:
session = await current_session(request)
user = await storage_of(request).user(session.user_id)
if user is None:
raise ApiError(401, 'Session user no longer exists', headers=BEARER_CHALLENGE)
return user
async def require_chat_member(request: Request, chat_id: str, user: UserRow):
try:
_uuid.UUID(chat_id)
except ValueError:
raise ApiError(400, 'chat_id must be a UUID')
row = await storage_of(request).chat(chat_id)
if row is None or user.id not in row.member_ids:
raise ApiError(404, 'Chat is not available for this user')
return row
View File
+31
View File
@@ -0,0 +1,31 @@
from fastapi import APIRouter, Request
from fastapi.responses import Response
from app.api.deps import current_session
from app.api.serialize import user_out
from app.core.config import settings
from app.core.errors import ApiError
from app.core.security import parse_basic, verify_password
from app.repositories.memory import iso_z
router = APIRouter()
BASIC_CHALLENGE = {'WWW-Authenticate': 'Basic realm="messenger", charset="UTF-8"'}
@router.post('/api/v1/auth/sessions', status_code=201)
async def login(request: Request):
creds = parse_basic(request.headers.get('authorization', ''))
storage = request.app.state.storage
row = await storage.user_by_username(creds[0]) if creds else None
if creds is None or row is None or not verify_password(row.password_hash, creds[1]):
raise ApiError(401, 'Invalid credentials', headers=BASIC_CHALLENGE)
session = await storage.create_session(row.id, settings.session_ttl_seconds)
return {'token': session.token, 'token_type': 'Bearer',
'expires_at': iso_z(session.expires_at), 'user': user_out(row)}
@router.delete('/api/v1/auth/sessions/current', status_code=204)
async def logout(request: Request):
session = await current_session(request)
await request.app.state.storage.revoke(session.token)
return Response(status_code=204)
+33
View File
@@ -0,0 +1,33 @@
from fastapi import APIRouter, Query, Request
from app.api.deps import current_user, require_chat_member
from app.api.serialize import chat_out
from app.core.cursors import decode_cursor, paginate
from app.schemas import CreateChat
router = APIRouter()
@router.post('/api/v1/chats', status_code=201)
async def create_chat(body: CreateChat, request: Request):
user = await current_user(request)
member_ids = [str(mid) for mid in body.member_ids]
row = await request.app.state.storage.create_chat(body.title, member_ids, user.id)
return chat_out(row)
@router.get('/api/v1/chats')
async def list_chats(request: Request, limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1)):
user = await current_user(request)
resource = 'chats:' + user.id
key = decode_cursor(cursor, resource) if cursor else None
rows = await request.app.state.storage.chats_of(user.id)
page, next_cursor = paginate(rows, key, limit, resource)
return {'items': [chat_out(r) for r in page], 'next_cursor': next_cursor}
@router.get('/api/v1/chats/{chat_id}')
async def get_chat(chat_id: str, request: Request):
user = await current_user(request)
return chat_out(await require_chat_member(request, chat_id, user))
+17
View File
@@ -0,0 +1,17 @@
from fastapi import APIRouter, Request
from app.core.errors import ApiError
router = APIRouter()
@router.get('/health/live')
async def live():
return {'status': 'ok'}
@router.get('/health/ready')
async def ready(request: Request):
if not await request.app.state.storage.ready():
raise ApiError(503, 'Storage is unavailable')
return {'status': 'ok'}
+11
View File
@@ -0,0 +1,11 @@
from fastapi import APIRouter, Request
from app.api.deps import current_user
from app.api.serialize import user_out
router = APIRouter()
@router.get('/api/v1/users/me')
async def me(request: Request):
return user_out(await current_user(request))
+32
View File
@@ -0,0 +1,32 @@
from fastapi import APIRouter, Query, Request
from app.api.deps import current_user, require_chat_member
from app.api.serialize import message_out
from app.core.cursors import decode_cursor, encode_cursor
from app.schemas import CreateMessage
router = APIRouter()
@router.post('/api/v1/chats/{chat_id}/messages', status_code=201)
async def create_message(body: CreateMessage, chat_id: str, request: Request):
user = await current_user(request)
chat = await require_chat_member(request, chat_id, user)
row = await request.app.state.storage.add_message(chat.id, user.id, body.text)
return message_out(row)
@router.get('/api/v1/chats/{chat_id}/messages')
async def list_messages(request: Request, chat_id: str,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1)):
user = await current_user(request)
chat = await require_chat_member(request, chat_id, user)
resource = 'messages:' + chat.id
key = decode_cursor(cursor, resource) if cursor else None
rows, has_more = await request.app.state.storage.messages_page(chat.id, key, limit)
next_cursor = (
encode_cursor(resource, rows[-1].created_at, rows[-1].id)
if has_more else None
)
return {'items': [message_out(row) for row in rows], 'next_cursor': next_cursor}
+14
View File
@@ -0,0 +1,14 @@
from fastapi import APIRouter, Request
from app.api.serialize import user_out
from app.core.security import hash_password
from app.schemas import CreateUser
router = APIRouter()
@router.post('/api/v1/users', status_code=201)
async def register(body: CreateUser, request: Request):
row = await request.app.state.storage.create_user(
body.username, body.display_name, hash_password(body.password))
return user_out(row)
+15
View File
@@ -0,0 +1,15 @@
from app.repositories.memory import UserRow
def user_out(row: UserRow) -> dict:
return {'id': row.id, 'username': row.username,
'display_name': row.display_name, 'created_at': row.created_at}
def chat_out(row) -> dict:
return {'id': row.id, 'title': row.title,
'member_ids': list(row.member_ids), 'created_at': row.created_at}
def message_out(row) -> dict:
return {'id': row.id, 'chat_id': row.chat_id, 'sender_id': row.sender_id,
'text': row.text, 'created_at': row.created_at}
View File
+31
View File
@@ -0,0 +1,31 @@
from pathlib import Path
from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
model_config = SettingsConfigDict(env_file='.env', extra='ignore')
app_host: str = '0.0.0.0'
app_port: int = 8080
session_ttl_seconds: int = 3600
database_url: str = ''
database_url_file: str | None = None
redis_url: str = 'redis://localhost:6379/0'
redis_url_file: str | None = None
db_pool_min_size: int = 1
db_pool_max_size: int = 10
db_pool_acquire_timeout_seconds: float = 3.0
db_command_timeout_seconds: float = 5.0
redis_timeout_seconds: float = 2.0
def resolved_database_url(self) -> str:
if self.database_url_file:
return Path(self.database_url_file).read_text(encoding='utf-8').strip()
return self.database_url
def resolved_redis_url(self) -> str:
if self.redis_url_file:
return Path(self.redis_url_file).read_text(encoding='utf-8').strip()
return self.redis_url
settings = Settings()
+37
View File
@@ -0,0 +1,37 @@
import base64
import binascii
import json
import uuid
from datetime import datetime
from app.core.errors import ApiError
from app.repositories.memory import order_key
def encode_cursor(resource: str, created_at: str, row_id: str) -> str:
payload = json.dumps({'r': resource, 't': created_at, 'i': row_id}, separators=(',', ':'))
return base64.urlsafe_b64encode(payload.encode()).decode()
def decode_cursor(value: str, resource: str) -> tuple[datetime, int]:
"""Курсор от другого ресурса или битый -> 400 invalid_request."""
try:
payload = json.loads(base64.urlsafe_b64decode(value.encode()))
if payload['r'] != resource:
raise ValueError('cursor belongs to another resource')
moment = datetime.fromisoformat(payload['t'].replace('Z', '+00:00'))
return moment, uuid.UUID(payload['i']).int
except (ValueError, KeyError, TypeError, binascii.Error):
raise ApiError(400, 'Invalid cursor')
def paginate(rows: list, cursor_key, limit: int, resource: str):
"""Keyset: берём строки строго после (created_at, id) курсора, без offset-скана."""
if cursor_key is not None:
rows = [r for r in rows if order_key(r.created_dt, r.id) > cursor_key]
page = rows[:limit]
next_cursor = None
if len(rows) > limit: # следующая запись есть на момент чтения
last = page[-1]
next_cursor = encode_cursor(resource, last.created_at, last.id)
return page, next_cursor
+69
View File
@@ -0,0 +1,69 @@
import uuid
import asyncpg
from redis.exceptions import RedisError
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.middleware.base import BaseHTTPMiddleware
CODES = {400: 'invalid_request', 401: 'unauthorized', 404: 'not_found', 409: 'conflict',
413: 'payload_too_large', 415: 'unsupported_media_type', 429: 'rate_limited',
503: 'unavailable', 500: 'internal_error'}
class ApiError(Exception):
"""Бизнес-ошибка: HTTP-статус + код контракта + безопасное сообщение."""
def __init__(self, status_code: int, message: str, code: str | None = None,
headers: dict | None = None):
self.status_code = status_code
self.code = code or CODES.get(status_code, 'internal_error')
self.message = message
self.headers = headers or {}
class RequestIdMiddleware(BaseHTTPMiddleware):
"""Каждый ответ, включая 204 и ошибки, несёт непустой X-Request-Id."""
async def dispatch(self, request: Request, call_next):
request.state.request_id = str(uuid.uuid4())
response = await call_next(request)
response.headers['X-Request-Id'] = request.state.request_id
return response
def _body(request: Request, status_code: int, code: str, message: str,
headers: dict | None = None) -> JSONResponse:
rid = getattr(request.state, 'request_id', str(uuid.uuid4()))
return JSONResponse(status_code=status_code, headers=headers,
content={'error': {'code': code, 'message': message, 'request_id': rid}})
def register_error_handlers(app: FastAPI) -> None:
@app.exception_handler(ApiError)
async def on_api_error(request: Request, exc: ApiError):
return _body(request, exc.status_code, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def on_validation(request: Request, exc: RequestValidationError):
return _body(request, 400, 'invalid_request', 'Request validation failed')
@app.exception_handler(StarletteHTTPException)
async def on_http(request: Request, exc: StarletteHTTPException):
code = CODES.get(exc.status_code, 'invalid_request')
return _body(request, exc.status_code, code, 'Route or method not found')
async def on_dependency_failure(request: Request, exc: Exception):
return _body(request, 503, 'unavailable', 'A required service is unavailable')
app.add_exception_handler(asyncpg.PostgresError, on_dependency_failure)
app.add_exception_handler(RedisError, on_dependency_failure)
app.add_exception_handler(OSError, on_dependency_failure)
app.add_exception_handler(TimeoutError, on_dependency_failure)
@app.exception_handler(Exception)
async def on_unexpected(request: Request, exc: Exception):
return _body(request, 500, 'internal_error', 'Internal error')
+39
View File
@@ -0,0 +1,39 @@
import base64
import binascii
import secrets
from argon2 import PasswordHasher
from argon2.exceptions import Argon2Error
_ph = PasswordHasher() # по умолчанию Argon2id
def hash_password(password: str) -> str:
return _ph.hash(password)
def verify_password(digest: str, password: str) -> bool:
try:
return _ph.verify(digest, password)
except (Argon2Error, ValueError):
return False
def new_token() -> str:
return secrets.token_hex(32) # 32 байта = 256 бит энтропии
def parse_basic(header: str) -> tuple[str, str] | None:
"""Преобразовать 'Basic base64(username:password)' в пару (username, password) или вернуть None."""
parts = header.split(' ', 1)
if len(parts) != 2 or parts[0].lower() != 'basic':
return None
try:
raw = base64.b64decode(parts[1].strip(), validate=True)
text = raw.decode('utf-8')
except (binascii.Error, ValueError, UnicodeDecodeError):
return None
if ':' not in text:
return None
username, password = text.split(':', 1) # двоеточие в пароле допустимо
return username, password
+1
View File
@@ -0,0 +1 @@
"""Настройка базы данных и миграции схемы."""
+32
View File
@@ -0,0 +1,32 @@
from pathlib import Path
import asyncpg
MIGRATIONS_DIR = Path(__file__).resolve().parents[2] / 'migrations'
async def apply_migrations(pool: asyncpg.Pool) -> None:
"""Применить каждую нумерованную SQL-миграцию один раз в транзакции под advisory lock."""
async with pool.acquire() as connection:
await connection.execute('SELECT pg_advisory_lock($1)', 762019002)
try:
await connection.execute(
'CREATE TABLE IF NOT EXISTS schema_migrations ('
' version integer PRIMARY KEY,'
' applied_at timestamptz NOT NULL DEFAULT now())'
)
applied = {
row['version']
for row in await connection.fetch('SELECT version FROM schema_migrations')
}
for path in sorted(MIGRATIONS_DIR.glob('[0-9]*_*.sql')):
version = int(path.name.split('_', 1)[0])
if version in applied:
continue
async with connection.transaction():
await connection.execute(path.read_text(encoding='utf-8'))
await connection.execute(
'INSERT INTO schema_migrations (version) VALUES ($1)', version
)
finally:
await connection.execute('SELECT pg_advisory_unlock($1)', 762019002)
+54
View File
@@ -0,0 +1,54 @@
from contextlib import asynccontextmanager
import asyncpg
from fastapi import FastAPI
from redis.asyncio import Redis
from app.api.routes import auth, health, me, users, chats, messages
from app.core.config import settings
from app.core.errors import RequestIdMiddleware, register_error_handlers
from app.db.migrate import apply_migrations
from app.repositories.postgres import PgStorage
from app.repositories.redis_sessions import RedisSessionStore
def create_app() -> FastAPI:
@asynccontextmanager
async def lifespan(app: FastAPI):
dsn = settings.resolved_database_url()
if not dsn:
raise RuntimeError('Set DATABASE_URL or DATABASE_URL_FILE before starting the API')
pool = await asyncpg.create_pool(
dsn,
min_size=settings.db_pool_min_size,
max_size=settings.db_pool_max_size,
timeout=settings.db_pool_acquire_timeout_seconds,
command_timeout=settings.db_command_timeout_seconds,
)
redis_client = Redis.from_url(
settings.resolved_redis_url(),
decode_responses=True,
socket_connect_timeout=settings.redis_timeout_seconds,
socket_timeout=settings.redis_timeout_seconds,
)
try:
await apply_migrations(pool)
app.state.storage = PgStorage(pool, RedisSessionStore(redis_client))
yield
finally:
await redis_client.aclose()
await pool.close()
app = FastAPI(title='MTUSI Messenger lab2', docs_url=None, redoc_url=None, lifespan=lifespan)
app.add_middleware(RequestIdMiddleware)
register_error_handlers(app)
app.include_router(health.router)
app.include_router(users.router)
app.include_router(me.router)
app.include_router(auth.router)
app.include_router(chats.router)
app.include_router(messages.router)
return app
app = create_app()
View File
+149
View File
@@ -0,0 +1,149 @@
import threading
import uuid
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone
from app.core.errors import ApiError
def now_utc() -> datetime:
return datetime.now(timezone.utc)
def iso_z(moment: datetime) -> str:
"""RFC 3339 UTC с Z и микросекундами: порядок (created_at, id) не теряет точность."""
return moment.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
def order_key(created_dt: datetime, row_id: str):
"""Контракт: порядок по (created_at, id), id сравнивается как значение UUID."""
return (created_dt, uuid.UUID(row_id).int)
@dataclass
class UserRow:
id: str
username: str
display_name: str
password_hash: str
created_at: str
@dataclass
class ChatRow:
id: str
title: str
member_ids: list
created_dt: datetime
created_at: str
@dataclass
class MessageRow:
id: str
chat_id: str
sender_id: str
text: str
created_dt: datetime
created_at: str
@dataclass
class SessionRow:
token: str
user_id: str
expires_at: datetime
class MemoryStorage:
"""Хранилище в памяти из скелета lab1. В lab2 его заменяет PgStorage с теми же
сигнатурами методов, поэтому роутеры и зависимости менять не требуется."""
def __init__(self):
self._lock = threading.RLock()
self._users: dict[str, UserRow] = {}
self._by_username: dict[str, str] = {}
self._chats: dict[str, ChatRow] = {}
self._messages: dict[str, list[MessageRow]] = {}
self._sessions: dict[str, SessionRow] = {}
def ready(self) -> bool:
return True
# --- пользователи
def create_user(self, username: str, display_name: str, password_hash: str) -> UserRow:
with self._lock:
if username in self._by_username:
raise ApiError(409, 'Username is already taken')
row = UserRow(str(uuid.uuid4()), username, display_name, password_hash,
iso_z(now_utc()))
self._users[row.id] = row
self._by_username[username] = row.id
return row
def user_by_username(self, username: str) -> UserRow | None:
with self._lock:
uid = self._by_username.get(username)
return self._users.get(uid) if uid else None
def user(self, user_id: str) -> UserRow | None:
with self._lock:
return self._users.get(user_id)
# --- сессии
def create_session(self, user_id: str, ttl_seconds: int) -> SessionRow:
from app.core.security import new_token
with self._lock:
row = SessionRow(new_token(), user_id, now_utc() + timedelta(seconds=ttl_seconds))
self._sessions[row.token] = row
return row
def session(self, token: str) -> SessionRow | None:
with self._lock:
row = self._sessions.get(token)
if row is None:
return None
if now_utc() >= row.expires_at:
del self._sessions[token] # истёкшую сессию считаем отозванной
return None
return row
def revoke(self, token: str) -> bool:
with self._lock:
return self._sessions.pop(token, None) is not None
# --- чаты (создание атомарно под одной блокировкой)
def create_chat(self, title: str, member_ids: list, caller_id: str) -> ChatRow:
with self._lock:
if caller_id not in member_ids:
raise ApiError(400, 'Creator must be included in member_ids')
for mid in member_ids:
if mid not in self._users:
raise ApiError(400, 'Unknown member id')
moment = now_utc()
row = ChatRow(str(uuid.uuid4()), title, list(member_ids), moment, iso_z(moment))
self._chats[row.id] = row
self._messages[row.id] = []
return row
def chat(self, chat_id: str) -> ChatRow | None:
with self._lock:
return self._chats.get(chat_id)
def chats_of(self, user_id: str) -> list[ChatRow]:
with self._lock:
rows = [c for c in self._chats.values() if user_id in c.member_ids]
return sorted(rows, key=lambda c: order_key(c.created_dt, c.id))
# --- сообщения
def add_message(self, chat_id: str, sender_id: str, text: str) -> MessageRow:
with self._lock:
moment = now_utc()
row = MessageRow(str(uuid.uuid4()), chat_id, sender_id, text, moment, iso_z(moment))
self._messages[chat_id].append(row)
return row
def messages_of(self, chat_id: str) -> list[MessageRow]:
with self._lock:
rows = list(self._messages.get(chat_id, []))
return sorted(rows, key=lambda m: order_key(m.created_dt, m.id))
+160
View File
@@ -0,0 +1,160 @@
import uuid
import asyncpg
from app.core.errors import ApiError
from app.core.security import new_token
from app.repositories.memory import (
ChatRow, MessageRow, UserRow, iso_z,
)
def _user(row: asyncpg.Record | None) -> UserRow | None:
if row is None:
return None
return UserRow(
id=str(row['id']), username=row['username'], display_name=row['display_name'],
password_hash=row['password_hash'], created_at=iso_z(row['created_at']),
)
def _chat(row: asyncpg.Record) -> ChatRow:
moment = row['created_at']
return ChatRow(
id=str(row['id']), title=row['title'], member_ids=[str(x) for x in row['member_ids']],
created_dt=moment, created_at=iso_z(moment),
)
def _message(row: asyncpg.Record) -> MessageRow:
moment = row['created_at']
return MessageRow(
id=str(row['id']), chat_id=str(row['chat_id']), sender_id=str(row['sender_id']),
text=row['text'], created_dt=moment, created_at=iso_z(moment),
)
class PgStorage:
"""Хранилище пользователей, сессий, чатов, участников и сообщений на PostgreSQL."""
def __init__(self, pool: asyncpg.Pool, session_store):
self.pool = pool
self.session_store = session_store
async def ready(self) -> bool:
try:
async with self.pool.acquire() as connection:
database_ready = await connection.fetchval('SELECT 1') == 1
return database_ready and await self.session_store.ready()
except (asyncpg.PostgresError, OSError, TimeoutError):
return False
async def create_user(self, username: str, display_name: str, password_hash: str) -> UserRow:
try:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'INSERT INTO users (id, username, display_name, password_hash) '
'VALUES ($1, $2, $3, $4) RETURNING *',
uuid.uuid4(), username, display_name, password_hash,
)
except asyncpg.UniqueViolationError as exc:
if exc.constraint_name == 'users_username_key':
raise ApiError(409, 'Username is already taken') from None
raise
return _user(row)
async def user_by_username(self, username: str) -> UserRow | None:
async with self.pool.acquire() as connection:
return _user(await connection.fetchrow(
'SELECT * FROM users WHERE username = $1', username
))
async def user(self, user_id: str) -> UserRow | None:
async with self.pool.acquire() as connection:
return _user(await connection.fetchrow(
'SELECT * FROM users WHERE id = $1', uuid.UUID(user_id)
))
async def create_session(self, user_id: str, ttl_seconds: int):
return await self.session_store.create_session(user_id, ttl_seconds)
async def session(self, token: str):
return await self.session_store.session(token)
async def revoke(self, token: str) -> bool:
return await self.session_store.revoke(token)
async def create_chat(self, title: str, member_ids: list[str], caller_id: str) -> ChatRow:
if caller_id not in member_ids:
raise ApiError(400, 'Creator must be included in member_ids')
chat_id = uuid.uuid4()
try:
async with self.pool.acquire() as connection:
async with connection.transaction():
created_at = await connection.fetchval(
'INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at',
chat_id, title,
)
await connection.executemany(
'INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)',
[(chat_id, uuid.UUID(member_id)) for member_id in member_ids],
)
except asyncpg.ForeignKeyViolationError:
raise ApiError(400, 'Unknown member id') from None
return ChatRow(
id=str(chat_id), title=title, member_ids=list(member_ids),
created_dt=created_at, created_at=iso_z(created_at),
)
async def chat(self, chat_id: str) -> ChatRow | None:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'SELECT c.id, c.title, c.created_at, '
'array_agg(cm.user_id ORDER BY cm.user_id) AS member_ids '
'FROM chats c JOIN chat_members cm ON cm.chat_id = c.id '
'WHERE c.id = $1 GROUP BY c.id', uuid.UUID(chat_id),
)
return _chat(row) if row else None
async def chats_of(self, user_id: str) -> list[ChatRow]:
async with self.pool.acquire() as connection:
rows = await connection.fetch(
'SELECT c.id, c.title, c.created_at, '
'array_agg(cm_all.user_id ORDER BY cm_all.user_id) AS member_ids '
'FROM chats c '
'JOIN chat_members mine ON mine.chat_id = c.id '
'JOIN chat_members cm_all ON cm_all.chat_id = c.id '
'WHERE mine.user_id = $1 '
'GROUP BY c.id ORDER BY c.created_at, c.id', uuid.UUID(user_id),
)
return [_chat(row) for row in rows]
async def add_message(self, chat_id: str, sender_id: str, text: str) -> MessageRow:
async with self.pool.acquire() as connection:
row = await connection.fetchrow(
'INSERT INTO messages (id, chat_id, sender_id, text) '
'VALUES ($1, $2, $3, $4) RETURNING *',
uuid.uuid4(), uuid.UUID(chat_id), uuid.UUID(sender_id), text,
)
return _message(row)
async def messages_page(self, chat_id: str, cursor_key, limit: int):
"""Прочитать одну отсортированную keyset-страницу и одну строку для проверки продолжения."""
chat_uuid = uuid.UUID(chat_id)
async with self.pool.acquire() as connection:
if cursor_key is None:
rows = await connection.fetch(
'SELECT * FROM messages WHERE chat_id = $1 '
'ORDER BY created_at, id LIMIT $2', chat_uuid, limit + 1,
)
else:
created_at, id_value = cursor_key
rows = await connection.fetch(
'SELECT * FROM messages WHERE chat_id = $1 '
'AND (created_at, id) > ($2, $3) '
'ORDER BY created_at, id LIMIT $4',
chat_uuid, created_at, uuid.UUID(int=id_value), limit + 1,
)
has_more = len(rows) > limit
return [_message(row) for row in rows[:limit]], has_more
+66
View File
@@ -0,0 +1,66 @@
import hashlib
import time
from datetime import datetime, timedelta, timezone
from redis.asyncio import Redis
from redis.exceptions import RedisError
from app.core.errors import ApiError
from app.core.security import new_token
from app.repositories.memory import SessionRow, now_utc
class RedisSessionStore:
"""Redis — источник истины для сессий; PXAT сохраняет исходный срок истечения после перезапуска."""
def __init__(self, client: Redis):
self.client = client
@staticmethod
def _key(token: str) -> str:
digest = hashlib.sha256(token.encode('utf-8')).hexdigest()
return 'session:' + digest
async def ready(self) -> bool:
try:
return bool(await self.client.ping())
except (RedisError, OSError, TimeoutError):
return False
async def create_session(self, user_id: str, ttl_seconds: int) -> SessionRow:
token = new_token()
current = now_utc()
expires_at = current.replace(microsecond=(current.microsecond // 1000) * 1000) + timedelta(seconds=ttl_seconds)
expires_ms = int(expires_at.timestamp() * 1000)
try:
await self.client.set(
self._key(token), f'{user_id}|{expires_ms}', pxat=expires_ms
)
except RedisError:
raise ApiError(503, 'Session storage is unavailable') from None
return SessionRow(token=token, user_id=user_id, expires_at=expires_at)
async def session(self, token: str) -> SessionRow | None:
try:
value = await self.client.get(self._key(token))
except RedisError:
raise ApiError(503, 'Session storage is unavailable') from None
if value is None:
return None
try:
user_id, expires_ms_text = value.split('|', 1)
expires_ms = int(expires_ms_text)
if expires_ms <= int(time.time() * 1000):
await self.client.delete(self._key(token))
return None
expires_at = datetime.fromtimestamp(expires_ms / 1000, timezone.utc)
return SessionRow(token=token, user_id=user_id, expires_at=expires_at)
except (ValueError, OverflowError):
await self.client.delete(self._key(token))
return None
async def revoke(self, token: str) -> bool:
try:
return bool(await self.client.delete(self._key(token)))
except RedisError:
raise ApiError(503, 'Session storage is unavailable') from None
+68
View File
@@ -0,0 +1,68 @@
import uuid as _uuid
from typing import Literal
from pydantic import BaseModel, ConfigDict, Field, field_validator
STRICT = ConfigDict(extra='forbid')
class CreateUser(BaseModel):
model_config = STRICT
username: str = Field(pattern=r'^[a-z0-9_]{3,32}$')
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator('display_name', 'password')
@classmethod
def _not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError('string must not consist of whitespace only')
return value
class User(BaseModel):
model_config = STRICT
id: _uuid.UUID
username: str
display_name: str
created_at: str
class Session(BaseModel):
model_config = STRICT
token: str
token_type: Literal['Bearer']
expires_at: str
user: User
class CreateChat(BaseModel):
model_config = STRICT
title: str = Field(min_length=1, max_length=100)
member_ids: list[_uuid.UUID] = Field(min_length=1, max_length=100)
@field_validator('title')
@classmethod
def _title_not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError('string must not consist of whitespace only')
return value
@field_validator('member_ids')
@classmethod
def _unique_members(cls, value):
if len(set(value)) != len(value):
raise ValueError('duplicate member ids')
return value
class CreateMessage(BaseModel):
model_config = STRICT
text: str = Field(min_length=1, max_length=4000)
@field_validator('text')
@classmethod
def _text_not_blank(cls, value: str) -> str:
if not value.strip():
raise ValueError('string must not consist of whitespace only')
return value
+4
View File
@@ -0,0 +1,4 @@
services:
api:
environment:
SESSION_TTL_SECONDS: "2"
+67
View File
@@ -0,0 +1,67 @@
name: mtusi-lab2
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER:?Set POSTGRES_USER in .env}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
POSTGRES_DB: ${POSTGRES_DB:?Set POSTGRES_DB in .env}
ports:
- "127.0.0.1:${POSTGRES_PORT:-5432}:5432"
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U \"$${POSTGRES_USER}\" -d \"$${POSTGRES_DB}\""]
interval: 3s
timeout: 3s
retries: 30
start_period: 5s
restart: unless-stopped
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always", "--save", ""]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 3s
retries: 30
start_period: 5s
restart: unless-stopped
api:
build:
context: .
dockerfile: Dockerfile
environment:
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: 8080
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
DB_POOL_MIN_SIZE: ${DB_POOL_MIN_SIZE:-1}
DB_POOL_MAX_SIZE: ${DB_POOL_MAX_SIZE:-10}
DB_POOL_ACQUIRE_TIMEOUT_SECONDS: ${DB_POOL_ACQUIRE_TIMEOUT_SECONDS:-3}
DB_COMMAND_TIMEOUT_SECONDS: ${DB_COMMAND_TIMEOUT_SECONDS:-5}
REDIS_URL: redis://redis:6379/0
REDIS_TIMEOUT_SECONDS: ${REDIS_TIMEOUT_SECONDS:-2}
ports:
- "127.0.0.1:${APP_PORT:-8080}:8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
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
restart: unless-stopped
volumes:
postgres_data:
redis_data:
+3
View File
@@ -0,0 +1,3 @@
$ docker compose --env-file .env config --quiet
exit_code=0
+14
View File
@@ -0,0 +1,14 @@
Container mtusi-lab2-api-1 Stopping
Container mtusi-lab2-api-1 Stopped
Container mtusi-lab2-api-1 Removing
Container mtusi-lab2-api-1 Removed
Container mtusi-lab2-redis-1 Stopping
Container mtusi-lab2-postgres-1 Stopping
Container mtusi-lab2-postgres-1 Stopped
Container mtusi-lab2-postgres-1 Removing
Container mtusi-lab2-postgres-1 Removed
Container mtusi-lab2-redis-1 Stopped
Container mtusi-lab2-redis-1 Removing
Container mtusi-lab2-redis-1 Removed
Network mtusi-lab2_default Removing
Network mtusi-lab2_default Removed
+85
View File
@@ -0,0 +1,85 @@
$ docker compose --env-file .env up -d --build
Image mtusi-lab2-api Building
#1 [internal] load local bake definitions
#1 reading from stdin 549B 0.1s done
#1 DONE 0.1s
#2 [internal] load build definition from Dockerfile
#2 transferring dockerfile: 426B 0.0s done
#2 DONE 0.0s
#3 [internal] load metadata for docker.io/library/python:3.12.8-slim
#3 ...
#4 [auth] library/python:pull token for registry-1.docker.io
#4 DONE 0.0s
#3 [internal] load metadata for docker.io/library/python:3.12.8-slim
#3 DONE 1.0s
#5 [internal] load .dockerignore
#5 transferring context: 196B done
#5 DONE 0.0s
#6 [1/8] FROM docker.io/library/python:3.12.8-slim@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0
#6 resolve docker.io/library/python:3.12.8-slim@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0 0.0s done
#6 DONE 0.0s
#7 [internal] load build context
#7 transferring context: 3.70kB 0.0s done
#7 DONE 0.0s
#8 [2/8] WORKDIR /app
#8 CACHED
#9 [5/8] COPY app ./app
#9 CACHED
#10 [6/8] COPY migrations ./migrations
#10 CACHED
#11 [7/8] COPY scripts ./scripts
#11 CACHED
#12 [4/8] RUN pip install --no-cache-dir -r requirements-app.txt
#12 CACHED
#13 [3/8] COPY requirements-app.txt ./
#13 CACHED
#14 [8/8] RUN useradd --create-home --uid 10001 appuser
#14 CACHED
#15 exporting to image
#15 exporting layers done
#15 exporting manifest sha256:9cf6afdb1a8794e290a56671c9efc636477b8be3f83fa4b6774ea411e5b45272 done
#15 exporting config sha256:095cc9895237f2b980d61820984491b10ee450d6ac5b9f7e2679edb1c3ab6b0d done
#15 exporting attestation manifest sha256:8c7e440b0feb1664a307d72756e5455e15eb595b853566d9d4bfe1915fcceeac 0.0s done
#15 exporting manifest list sha256:5a248ac1dbf37d83b7f374038bf4bde0aee37722a351863a5504483291076c29 0.0s done
#15 naming to docker.io/library/mtusi-lab2-api:latest done
#15 unpacking to docker.io/library/mtusi-lab2-api:latest done
#15 DONE 0.1s
#16 resolving provenance for metadata file
#16 DONE 0.0s
Image mtusi-lab2-api Built
Network mtusi-lab2_default Creating
Network mtusi-lab2_default Creating
Network mtusi-lab2_default Created
Network mtusi-lab2_default Created
Container mtusi-lab2-redis-1 Creating
Container mtusi-lab2-postgres-1 Creating
Container mtusi-lab2-redis-1 Created
Container mtusi-lab2-postgres-1 Created
Container mtusi-lab2-api-1 Creating
Container mtusi-lab2-api-1 Created
Container mtusi-lab2-postgres-1 Starting
Container mtusi-lab2-redis-1 Starting
Container mtusi-lab2-postgres-1 Started
Container mtusi-lab2-redis-1 Started
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-redis-1 Waiting
Container mtusi-lab2-redis-1 Healthy
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-api-1 Starting
Container mtusi-lab2-api-1 Started
+10
View File
@@ -0,0 +1,10 @@
chat_id=[synthetic-uuid]; messages_in_fixture=10000
Limit (cost=0.41..17.85 rows=50 width=70) (actual time=0.013..0.022 rows=50 loops=1)
Buffers: shared hit=6
-> Index Scan using messages_history_idx on messages (cost=0.41..3506.77 rows=10057 width=70) (actual time=0.013..0.019 rows=50 loops=1)
Index Cond: ((chat_id = '[synthetic-uuid]'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00+00'::timestamp with time zone, '[synthetic-uuid]'::uuid)))
Buffers: shared hit=6
Planning:
Buffers: shared hit=20
Planning Time: 0.215 ms
Execution Time: 0.066 ms
+5
View File
@@ -0,0 +1,5 @@
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
exit_code=0
+126
View File
@@ -0,0 +1,126 @@
$ make test-grade4
./scripts/test-grade4.sh
Image mtusi-lab2-api Building
#1 [internal] load local bake definitions
#1 reading from stdin 549B 0.1s done
#1 DONE 0.1s
#2 [internal] load build definition from Dockerfile
#2 transferring dockerfile:
#2 transferring dockerfile: 426B 0.0s done
#2 DONE 0.0s
#3 [auth] library/python:pull token for registry-1.docker.io
#3 DONE 0.0s
#4 [internal] load metadata for docker.io/library/python:3.12.8-slim
#4 DONE 1.0s
#5 [internal] load .dockerignore
#5 transferring context: 196B 0.0s done
#5 DONE 0.0s
#6 [1/8] FROM docker.io/library/python:3.12.8-slim@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0
#6 resolve docker.io/library/python:3.12.8-slim@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0 0.0s done
#6 DONE 0.0s
#7 [internal] load build context
#7 transferring context: 3.87kB 0.0s done
#7 DONE 0.1s
#8 [4/8] RUN pip install --no-cache-dir -r requirements-app.txt
#8 CACHED
#9 [5/8] COPY app ./app
#9 CACHED
#10 [2/8] WORKDIR /app
#10 CACHED
#11 [3/8] COPY requirements-app.txt ./
#11 CACHED
#12 [6/8] COPY migrations ./migrations
#12 CACHED
#13 [7/8] COPY scripts ./scripts
#13 DONE 0.0s
#14 [8/8] RUN useradd --create-home --uid 10001 appuser
#14 DONE 0.2s
#15 exporting to image
#15 exporting layers 0.1s done
#15 exporting manifest sha256:9cf6afdb1a8794e290a56671c9efc636477b8be3f83fa4b6774ea411e5b45272 0.0s done
#15 exporting config sha256:095cc9895237f2b980d61820984491b10ee450d6ac5b9f7e2679edb1c3ab6b0d 0.0s done
#15 exporting attestation manifest sha256:fa617bc26cb86a65a6dfd8525c4a7746266dc27f8310b60816894a9de1a0fbaa
#15 exporting attestation manifest sha256:fa617bc26cb86a65a6dfd8525c4a7746266dc27f8310b60816894a9de1a0fbaa 0.0s done
#15 exporting manifest list sha256:19627d8186b8193cce2b9ad8bd761bb4c1c704f92c6f9a73309528a29ca6cc9c 0.0s done
#15 naming to docker.io/library/mtusi-lab2-api:latest done
#15 unpacking to docker.io/library/mtusi-lab2-api:latest 0.0s done
#15 DONE 0.2s
#16 resolving provenance for metadata file
#16 DONE 0.0s
Image mtusi-lab2-api Built
Network mtusi-lab2_default Creating
Network mtusi-lab2_default Creating
Network mtusi-lab2_default Created
Network mtusi-lab2_default Created
Container mtusi-lab2-postgres-1 Creating
Container mtusi-lab2-redis-1 Creating
Container mtusi-lab2-redis-1 Created
Container mtusi-lab2-postgres-1 Created
Container mtusi-lab2-api-1 Creating
Container mtusi-lab2-api-1 Created
Container mtusi-lab2-postgres-1 Starting
Container mtusi-lab2-redis-1 Starting
Container mtusi-lab2-postgres-1 Started
Container mtusi-lab2-redis-1 Started
Container mtusi-lab2-redis-1 Waiting
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-redis-1 Healthy
Container mtusi-lab2-api-1 Starting
Container mtusi-lab2-api-1 Started
make[1]: Entering directory '/home/lenovo/lab2'
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
make[1]: Leaving directory '/home/lenovo/lab2'
PASS: concurrent username registration (1 x 201, 7 x 409)
PASS: invalid password returns 401
PASS: failed chat creation rolled back chat and memberships
PASS: Redis outage returns bounded 503 for readiness and session creation; service recovers
PASS: PostgreSQL outage returns bounded 503 for readiness and registration; service recovers
PASS: Redis session expires at the original short TTL
Container mtusi-lab2-redis-1 Running
Container mtusi-lab2-postgres-1 Running
Container mtusi-lab2-api-1 Recreate
Container mtusi-lab2-api-1 Recreated
Container mtusi-lab2-redis-1 Waiting
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-redis-1 Healthy
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-api-1 Starting
Container mtusi-lab2-api-1 Started
chat_id=[synthetic-uuid]; messages_in_fixture=10000
Limit (cost=0.41..17.85 rows=50 width=70) (actual time=0.013..0.022 rows=50 loops=1)
Buffers: shared hit=6
-> Index Scan using messages_history_idx on messages (cost=0.41..3506.77 rows=10057 width=70) (actual time=0.013..0.019 rows=50 loops=1)
Index Cond: ((chat_id = '[synthetic-uuid]'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00+00'::timestamp with time zone, '[synthetic-uuid]'::uuid)))
Buffers: shared hit=6
Planning:
Buffers: shared hit=20
Planning Time: 0.215 ms
Execution Time: 0.066 ms
make[1]: Entering directory '/home/lenovo/lab2'
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
make[1]: Leaving directory '/home/lenovo/lab2'
make[1]: Entering directory '/home/lenovo/lab2'
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
make[1]: Leaving directory '/home/lenovo/lab2'
exit_code=0
+5
View File
@@ -0,0 +1,5 @@
$ make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
exit_code=0
+5
View File
@@ -0,0 +1,5 @@
$ make validate PYTHON=.venv/bin/python
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
exit_code=0
+37
View File
@@ -0,0 +1,37 @@
$ make test-grade4
PASS: exit_code=0; details are in make-test-grade4.txt
$ docker compose --env-file .env ps (before restart)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api 12 seconds ago Up 6 seconds (healthy) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 35 seconds ago Up 6 seconds (healthy) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 35 seconds ago Up 6 seconds (healthy) 6379/tcp
$ docker inspect --format name + StartedAt + health (before restart)
/mtusi-lab2-api-1 2026-10-18T12:02:22.47421812Z healthy
/mtusi-lab2-postgres-1 2026-10-18T12:02:22.265638383Z healthy
/mtusi-lab2-redis-1 2026-10-18T12:02:22.37541571Z healthy
$ scripts/restart.sh
Container mtusi-lab2-api-1 Restarting
Container mtusi-lab2-redis-1 Restarting
Container mtusi-lab2-postgres-1 Restarting
Container mtusi-lab2-postgres-1 Started
Container mtusi-lab2-redis-1 Started
Container mtusi-lab2-api-1 Started
$ curl -fsS http://localhost:8080/health/ready
{"status":"ok"}
$ docker inspect --format name + StartedAt + health (after restart)
/mtusi-lab2-api-1 2026-10-18T12:02:30.372421246Z healthy
/mtusi-lab2-postgres-1 2026-10-18T12:02:30.172148956Z healthy
/mtusi-lab2-redis-1 2026-10-18T12:02:30.269554196Z healthy
$ docker compose --env-file .env ps (after restart)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api 21 seconds ago Up 7 seconds (healthy) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 44 seconds ago Up 7 seconds (healthy) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 44 seconds ago Up 7 seconds (healthy) 6379/tcp
exit_code=0
+167
View File
@@ -0,0 +1,167 @@
=== Lab2 verification evidence ===
Date (UTC):
2026-10-14
Local date (Europe/Moscow): 2026-10-15
Working tree base commit:
65003b61195361aac238f19c9bff0027ca58e09e
Working-tree note: implementation is uncommitted; no commit created.
Runtime:
Linux 6.18.33.2-microsoft-standard-WSL2 x86_64 GNU/Linux
Visible WSL CPU count:
32
Visible WSL memory:
MemTotal: 16209628 kB
Docker engine resources:
CPUs=32, memory_bytes=16598659072
Profile: 8-way concurrent same-username registration; API smoke; TTL=2s expiry; Redis/PostgreSQL outage and recovery; 10,000-message EXPLAIN. No sustained load/throughput benchmark.
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ docker compose --env-file .env config --quiet
PASS: Compose configuration
$ make test-grade4
./scripts/test-grade4.sh
Image mtusi-lab2-api Building
#1 [internal] load local bake definitions
#1 reading from stdin 480B done
#1 DONE 0.0s
#2 [internal] load build definition from Dockerfile
#2 transferring dockerfile: 426B done
#2 DONE 0.0s
#3 [internal] load metadata for docker.io/library/python:3.12.8-slim
#3 ...
#4 [auth] library/python:pull token for registry-1.docker.io
#4 DONE 0.0s
#3 [internal] load metadata for docker.io/library/python:3.12.8-slim
#3 DONE 2.9s
#5 [internal] load .dockerignore
#5 transferring context: 196B done
#5 DONE 0.0s
#6 [1/8] FROM docker.io/library/python:3.12.8-slim@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0
#6 resolve docker.io/library/python:3.12.8-slim@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0 0.0s done
#6 DONE 0.0s
#7 [internal] load build context
#7 transferring context: 4.45kB done
#7 DONE 0.0s
#8 [4/8] RUN pip install --no-cache-dir -r requirements-app.txt
#8 CACHED
#9 [5/8] COPY app ./app
#9 CACHED
#10 [2/8] WORKDIR /app
#10 CACHED
#11 [3/8] COPY requirements-app.txt ./
#11 CACHED
#12 [6/8] COPY migrations ./migrations
#12 CACHED
#13 [7/8] COPY scripts ./scripts
#13 DONE 0.0s
#14 [8/8] RUN useradd --create-home --uid 10001 appuser
#14 DONE 0.3s
#15 exporting to image
#15 exporting layers 0.1s done
#15 exporting manifest sha256:e41af12501ce06d0c4226798c7361c3d246c6e05dd58cc92e685b938cb461196 done
#15 exporting config sha256:88794e51c3f243a681401fdc72656dd5fd7eaec008e67a9d328cd5fc993c0a31 done
#15 exporting attestation manifest sha256:e7691318b06a958c64a7b7b736070b037e3830d44301ffd63b7b3f856d13bb87
#15 exporting attestation manifest sha256:e7691318b06a958c64a7b7b736070b037e3830d44301ffd63b7b3f856d13bb87 0.0s done
#15 exporting manifest list sha256:2f914bb85d5987a05b55998905a8f70789c90c99e76d38632d4111b31fc9eef9 0.0s done
#15 naming to docker.io/library/mtusi-lab2-api:latest done
#15 unpacking to docker.io/library/mtusi-lab2-api:latest 0.0s done
#15 DONE 0.2s
#16 resolving provenance for metadata file
#16 DONE 0.0s
Image mtusi-lab2-api Built
Container mtusi-lab2-postgres-1 Running
Container mtusi-lab2-redis-1 Running
Container mtusi-lab2-api-1 Recreate
Container mtusi-lab2-api-1 Recreated
Container mtusi-lab2-redis-1 Waiting
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-redis-1 Healthy
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-api-1 Starting
Container mtusi-lab2-api-1 Started
make[1]: Entering directory '/home/lenovo/lab2'
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
make[1]: Leaving directory '/home/lenovo/lab2'
PASS: concurrent username registration (1 x 201, 7 x 409)
PASS: invalid password returns 401
PASS: failed chat creation rolled back chat and memberships
PASS: Redis outage returns bounded 503 for readiness and session creation; service recovers
PASS: PostgreSQL outage returns bounded 503 for readiness and registration; service recovers
PASS: Redis session expires at the original short TTL
Container mtusi-lab2-postgres-1 Running
Container mtusi-lab2-redis-1 Running
Container mtusi-lab2-api-1 Recreate
Container mtusi-lab2-api-1 Recreated
Container mtusi-lab2-redis-1 Waiting
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-redis-1 Healthy
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-api-1 Starting
Container mtusi-lab2-api-1 Started
chat_id=[synthetic-uuid]; messages_in_fixture=10000
Limit (cost=0.41..9.56 rows=50 width=70) (actual time=0.012..0.018 rows=50 loops=1)
Buffers: shared hit=5
-> Index Scan using messages_history_idx on messages (cost=0.41..1830.33 rows=9997 width=70) (actual time=0.011..0.015 rows=50 loops=1)
Index Cond: ((chat_id = '[synthetic-uuid]'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00+00'::timestamp with time zone, '[synthetic-uuid]'::uuid)))
Buffers: shared hit=5
Planning:
Buffers: shared hit=18
Planning Time: 0.098 ms
Execution Time: 0.057 ms
make[1]: Entering directory '/home/lenovo/lab2'
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
make[1]: Leaving directory '/home/lenovo/lab2'
make[1]: Entering directory '/home/lenovo/lab2'
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
make[1]: Leaving directory '/home/lenovo/lab2'
=== Restart-hook evidence ===
2026-10-15T01:30:19+03:00
$ docker compose --env-file .env ps (before)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api 59 seconds ago Up 53 seconds (healthy) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 6 hours ago Up 53 seconds (healthy) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 6 hours ago Up 53 seconds (healthy) 6379/tcp
$ scripts/restart.sh
Container mtusi-lab2-postgres-1 Restarting
Container mtusi-lab2-redis-1 Restarting
Container mtusi-lab2-api-1 Restarting
Container mtusi-lab2-postgres-1 Started
Container mtusi-lab2-redis-1 Started
Container mtusi-lab2-api-1 Started
$ docker compose --env-file .env ps (after)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api About a minute ago Up Less than a second (health: starting) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 6 hours ago Up Less than a second (health: starting) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 6 hours ago Up Less than a second (health: starting) 6379/tcp
$ docker compose --env-file .env ps (after readiness)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api About a minute ago Up 22 seconds (healthy) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 6 hours ago Up 22 seconds (healthy) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 6 hours ago Up 22 seconds (healthy) 6379/tcp
{"status":"ok"}
+207
View File
@@ -0,0 +1,207 @@
=== Lab2 final verification ===
Date (Europe/Moscow): 2026-10-18
Date (UTC): 2026-10-18T11:50:18Z
HEAD commit: 65003b61195361aac238f19c9bff0027ca58e09e
Working tree: implementation changes are uncommitted; no commit created.
WSL runtime: Linux 6.18.33.2-microsoft-standard-WSL2 x86_64 GNU/Linux
WSL visible CPUs: 32
WSL visible memory: 16209624 kB
Docker engine resources: CPUs=32 memory_bytes=16598654976
Docker Compose version v5.5.1
Profile: make check; full OpenAPI/schema validation; Compose config; grade-4 suite (8-way username race, invalid password, transaction rollback, Redis/PostgreSQL outage and recovery, 2-second session expiry, 10k-message EXPLAIN); public smoke; persistence with restart of API/PostgreSQL/Redis; manual restart-hook state check. No sustained load benchmark.
Hardware limits: WSL/Docker visible resource caps above; no additional per-container CPU/RAM limits configured.
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
exit_code=0
$ make validate PYTHON=.venv/bin/python
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
exit_code=0
$ docker compose --env-file .env config --quiet
PASS: Compose configuration
exit_code=0
$ make test-grade4
Selected sanitized stdout (build lifecycle details omitted):
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
PASS: concurrent username registration (1 x 201, 7 x 409)
PASS: invalid password returns 401
PASS: failed chat creation rolled back chat and memberships
PASS: Redis outage returns bounded 503 for readiness and session creation; service recovers
PASS: PostgreSQL outage returns bounded 503 for readiness and registration; service recovers
PASS: Redis session expires at the original short TTL
chat_id=[synthetic-uuid]; messages_in_fixture=10000
Buffers: shared hit=6
-> Index Scan using messages_history_idx on messages (cost=0.41..2834.08 rows=9994 width=70) (actual time=0.011..0.017 rows=50 loops=1)
Buffers: shared hit=6
Buffers: shared hit=18
Planning Time: 0.102 ms
Execution Time: 0.056 ms
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
exit_code=0
$ docker compose --env-file .env ps (before manual restart hook)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api 8 seconds ago Up 1 second (health: starting) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 31 seconds ago Up 1 second (health: starting) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 31 seconds ago Up 1 second (health: starting) 6379/tcp
$ docker inspect --format name + StartedAt (before restart)
/mtusi-lab2-api-1 2026-10-18T11:51:04.236364497Z
/mtusi-lab2-postgres-1 2026-10-18T11:51:04.031258233Z
/mtusi-lab2-redis-1 2026-10-18T11:51:04.167666161Z
$ scripts/restart.sh
Container mtusi-lab2-redis-1 Restarting
Container mtusi-lab2-api-1 Restarting
Container mtusi-lab2-postgres-1 Restarting
Container mtusi-lab2-postgres-1 Started
Container mtusi-lab2-redis-1 Started
Container mtusi-lab2-api-1 Started
{"status":"ok"}
$ docker inspect --format name + StartedAt (after restart and ready)
/mtusi-lab2-api-1 2026-10-18T11:51:06.539804958Z
/mtusi-lab2-postgres-1 2026-10-18T11:51:06.356125844Z
/mtusi-lab2-redis-1 2026-10-18T11:51:06.47135391Z
$ docker compose --env-file .env ps (after restart and readiness)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api 11 seconds ago Up 1 second (health: starting) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 34 seconds ago Up 1 second (health: starting) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 34 seconds ago Up 1 second (health: starting) 6379/tcp
$ docker compose --env-file .env down (named volumes preserved)
Container mtusi-lab2-api-1 Stopping
Container mtusi-lab2-api-1 Stopped
Container mtusi-lab2-api-1 Removing
Container mtusi-lab2-api-1 Removed
Container mtusi-lab2-postgres-1 Stopping
Container mtusi-lab2-redis-1 Stopping
Container mtusi-lab2-postgres-1 Stopped
Container mtusi-lab2-postgres-1 Removing
Container mtusi-lab2-postgres-1 Removed
Container mtusi-lab2-redis-1 Stopped
Container mtusi-lab2-redis-1 Removing
Container mtusi-lab2-redis-1 Removed
Network mtusi-lab2_default Removing
Network mtusi-lab2_default Removed
$ docker compose --env-file .env ps -a
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
PASS: lab containers stopped; named data volumes retained.
=== Healthy-state follow-up for restart-hook evidence ===
Date (UTC): 2026-10-18T11:52:14Z
$ docker compose --env-file .env up -d
Network mtusi-lab2_default Creating
Network mtusi-lab2_default Creating
Network mtusi-lab2_default Created
Network mtusi-lab2_default Created
Container mtusi-lab2-postgres-1 Creating
Container mtusi-lab2-redis-1 Creating
Container mtusi-lab2-redis-1 Created
Container mtusi-lab2-postgres-1 Created
Container mtusi-lab2-api-1 Creating
Container mtusi-lab2-api-1 Created
Container mtusi-lab2-postgres-1 Starting
Container mtusi-lab2-redis-1 Starting
Container mtusi-lab2-postgres-1 Started
Container mtusi-lab2-redis-1 Started
Container mtusi-lab2-redis-1 Waiting
Container mtusi-lab2-postgres-1 Waiting
Container mtusi-lab2-postgres-1 Healthy
Container mtusi-lab2-redis-1 Healthy
Container mtusi-lab2-api-1 Starting
Container mtusi-lab2-api-1 Started
$ docker compose ps (before restart; all health checks healthy)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api 13 seconds ago Up 6 seconds (healthy) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 13 seconds ago Up 12 seconds (healthy) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 13 seconds ago Up 12 seconds (healthy) 6379/tcp
$ docker inspect --format service + StartedAt + health (before restart)
/mtusi-lab2-api-1 2026-10-18T11:52:20.370835549Z healthy
/mtusi-lab2-postgres-1 2026-10-18T11:52:15.020176217Z healthy
/mtusi-lab2-redis-1 2026-10-18T11:52:15.201648026Z healthy
$ scripts/restart.sh
Container mtusi-lab2-api-1 Restarting
Container mtusi-lab2-postgres-1 Restarting
Container mtusi-lab2-redis-1 Restarting
Container mtusi-lab2-postgres-1 Started
Container mtusi-lab2-redis-1 Started
Container mtusi-lab2-api-1 Started
$ curl -fsS http://localhost:8080/health/ready
{"status":"ok"}
$ docker inspect --format service + StartedAt + health (after restart)
/mtusi-lab2-api-1 2026-10-18T11:52:28.711942433Z healthy
/mtusi-lab2-postgres-1 2026-10-18T11:52:28.537174473Z healthy
/mtusi-lab2-redis-1 2026-10-18T11:52:28.647499479Z healthy
$ docker compose ps (after restart; all health checks healthy)
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-lab2-api-1 mtusi-lab2-api "uvicorn app.main:ap…" api 22 seconds ago Up 7 seconds (healthy) 127.0.0.1:8080->8080/tcp
mtusi-lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 22 seconds ago Up 7 seconds (healthy) 127.0.0.1:5432->5432/tcp
mtusi-lab2-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 22 seconds ago Up 7 seconds (healthy) 6379/tcp
$ docker compose --env-file .env down (named volumes preserved)
Container mtusi-lab2-api-1 Stopping
Container mtusi-lab2-api-1 Stopped
Container mtusi-lab2-api-1 Removing
Container mtusi-lab2-api-1 Removed
Container mtusi-lab2-redis-1 Stopping
Container mtusi-lab2-postgres-1 Stopping
Container mtusi-lab2-redis-1 Stopped
Container mtusi-lab2-redis-1 Removing
Container mtusi-lab2-redis-1 Removed
Container mtusi-lab2-postgres-1 Stopped
Container mtusi-lab2-postgres-1 Removing
Container mtusi-lab2-postgres-1 Removed
Network mtusi-lab2_default Removing
Network mtusi-lab2_default Removed
$ docker compose --env-file .env ps -a
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
PASS: lab containers stopped; named data volumes retained.
=== Post-edit final checks ===
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ make validate PYTHON=.venv/bin/python
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
$ git diff --check (initial attempt)
Detected a trailing CR on the newly added README command line; corrected that line ending.
$ git check-ignore .env
.env
PASS: local .env is ignored
=== Final post-fix verification ===
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ make validate PYTHON=.venv/bin/python
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
$ git diff --check
PASS: no whitespace errors after correction
$ git check-ignore .env
.env
PASS: local .env is ignored
@@ -0,0 +1,13 @@
Lab 2 verification run
Local date: 2026-10-18
UTC date: 2026-10-18T12:01:49Z
Base commit: 65003b61195361aac238f19c9bff0027ca58e09e
Working tree: local implementation is uncommitted.
Runtime: Linux 6.18.33.2-microsoft-standard-WSL2 x86_64 GNU/Linux
Visible WSL CPU count: 32
Visible WSL memory: 16209624 kB
Docker engine resources: CPUs=32 memory_bytes=16598654976
Docker Compose version v5.5.1
Profile: make check, OpenAPI/JSON Schema validation, Compose config, grade-4 test suite, EXPLAIN with 10,000 synthetic messages, smoke, persistence with restart hook, healthy-state restart evidence.
No sustained load benchmark was run. No per-container CPU/RAM limits are configured.
Session tokens, credentials, and raw message bodies are not part of these evidence files.
+37
View File
@@ -0,0 +1,37 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (length(title) BETWEEN 1 AND 100 AND btrim(title) <> ''),
created_at timestamptz NOT NULL DEFAULT now()
);
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 CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id),
text text NOT NULL CHECK (length(text) BETWEEN 1 AND 4000 AND btrim(text) <> ''),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
-- A leaked session table must not contain usable bearer credentials.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expiry_idx ON sessions (expires_at);
@@ -0,0 +1,3 @@
-- Active sessions move to Redis in lab2 grade 4; old token digests cannot be
-- reconstructed and are intentionally invalidated during this one-time migration.
DROP TABLE IF EXISTS sessions;
+6
View File
@@ -0,0 +1,6 @@
fastapi==0.115.6
uvicorn==0.34.0
pydantic-settings==2.7.1
argon2-cffi==23.1.0
asyncpg==0.30.0
redis==5.2.1
+72
View File
@@ -0,0 +1,72 @@
#!/usr/bin/env python3
"""Seed one synthetic 10k-message chat and show the indexed keyset query plan."""
import asyncio
from datetime import datetime, timezone
from pathlib import Path
import sys
import uuid
import asyncpg
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app.core.config import settings
async def main() -> None:
pool = await asyncpg.create_pool(
settings.resolved_database_url(),
min_size=1,
max_size=2,
command_timeout=settings.db_command_timeout_seconds,
)
user_id, chat_id = uuid.uuid4(), uuid.uuid4()
username = 'explain_' + uuid.uuid4().hex[:12]
base_time = datetime(2026, 1, 1, tzinfo=timezone.utc)
try:
async with pool.acquire() as connection:
async with connection.transaction():
await connection.execute(
'INSERT INTO users (id, username, display_name, password_hash) '
'VALUES ($1, $2, $3, $4)',
user_id, username, 'EXPLAIN fixture', 'not-a-login-hash',
)
await connection.execute(
'INSERT INTO chats (id, title) VALUES ($1, $2)',
chat_id, 'EXPLAIN 10k fixture',
)
await connection.execute(
'INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)',
chat_id, user_id,
)
await connection.execute(
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
"SELECT md5($1::text || ':' || n::text)::uuid, $1::uuid, $2::uuid, "
"'synthetic explain message ' || n, $3::timestamptz + n * interval '1 microsecond' "
'FROM generate_series(1, 10000) AS g(n)',
str(chat_id), str(user_id), base_time,
)
await connection.execute('ANALYZE messages')
total = await connection.fetchval(
'SELECT count(*) FROM messages WHERE chat_id = $1', chat_id
)
plan = await connection.fetch(
'EXPLAIN (ANALYZE, BUFFERS) '
'SELECT id, created_at, sender_id, text FROM messages '
'WHERE chat_id = $1 AND (created_at, id) > ($2, $3) '
'ORDER BY created_at, id LIMIT 50',
chat_id, base_time, uuid.UUID(int=0),
)
rendered = '\n'.join(row['QUERY PLAN'] for row in plan)
print(f'chat_id={chat_id}; messages_in_fixture={total}')
print(rendered)
if total < 10000:
raise RuntimeError('EXPLAIN fixture did not reach 10,000 messages')
if 'messages_history_idx' not in rendered:
raise RuntimeError('planner did not choose messages_history_idx; inspect the plan')
finally:
await pool.close()
if __name__ == '__main__':
asyncio.run(main())
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
# Restart API and both state stores while preserving their named volumes.
cd "$(dirname "$0")/.."
docker compose restart postgres redis api
+26
View File
@@ -0,0 +1,26 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
restore_default_api() {
docker compose --env-file .env up -d --force-recreate api >/dev/null
}
trap restore_default_api EXIT INT TERM
docker compose --env-file .env -f compose.yaml -f compose.grade4.yaml up -d --build --force-recreate api
make check
python3 tests/grade4.py
restore_default_api
trap - EXIT INT TERM
for attempt in $(seq 1 30); do
if curl -fsS "http://localhost:${APP_PORT:-8080}/health/ready" >/dev/null 2>&1; then
break
fi
sleep 1
done
mkdir -p evidence
docker compose --env-file .env exec -T api python scripts/explain_history.py > evidence/explain-history.txt
cat evidence/explain-history.txt
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
+125
View File
@@ -0,0 +1,125 @@
#!/usr/bin/env python3
"""Focused lab2 grade-4 checks; requires the local Compose stack and 2-second TTL."""
from concurrent.futures import ThreadPoolExecutor
import base64
from datetime import datetime, timezone
from pathlib import Path
import subprocess
import time
import uuid
from client import Client, Failure, arguments, check, run, timestamp
ROOT = Path(__file__).resolve().parents[1]
def compose(*args):
return subprocess.run(
['docker', 'compose', '--env-file', '.env', *args], cwd=ROOT,
check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
)
def chat_count() -> int:
result = compose(
'exec', '-T', 'postgres', 'sh', '-c',
'psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -Atqc "SELECT count(*) FROM chats"',
)
return int(result.stdout.strip())
def wait_ready(client: Client, timeout: float = 30) -> None:
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
client.call('GET', '/health/ready')
return
except Failure:
time.sleep(0.25)
raise Failure('API did not become ready after restoring a dependency')
def main():
args = arguments('Lab2 grade-4 checks against the local Compose stack')
c = Client(args.base_url, args.ca_file, timeout=8)
wait_ready(c)
# Concurrent requests for one username must have one winner and conflict losers.
race_name = 'u_race_' + uuid.uuid4().hex[:12]
race_body = {
'username': race_name, 'display_name': 'Concurrent registration',
'password': 'Concurrent-test-password-42',
}
def register_once(_):
local = Client(args.base_url, args.ca_file, timeout=5)
return local.call('POST', '/api/v1/users', expected=[201, 409], body=race_body)['status']
with ThreadPoolExecutor(max_workers=8) as pool:
statuses = list(pool.map(register_once, range(8)))
check(statuses.count(201) == 1 and statuses.count(409) == 7,
'same-username race must produce one user and seven conflicts')
print('PASS: concurrent username registration (1 x 201, 7 x 409)')
actor = c.user('rollback')
bad_password = base64.b64encode(
(actor['registration']['username'] + ':incorrect-password').encode()
).decode()
c.call('POST', '/api/v1/auth/sessions', 401,
headers={'Authorization': 'Basic ' + bad_password})
print('PASS: invalid password returns 401')
before = chat_count()
unknown_id = str(uuid.uuid4())
c.call('POST', '/api/v1/chats', 400, actor=actor,
body={'title': 'Rollback probe', 'member_ids': [actor['id'], unknown_id]})
after = chat_count()
check(after == before, 'failed chat creation left a partial chat row')
print('PASS: failed chat creation rolled back chat and memberships')
# Keep a current token in memory only; outage checks use readiness and must fail closed.
outage_user = c.user('outage')
outage_basic = 'Basic ' + base64.b64encode((outage_user['registration']['username'] + ':' + outage_user['registration']['password']).encode()).decode()
compose('stop', 'redis')
try:
redis_ready = c.call('GET', '/health/ready', 503)
check(redis_ready['json']['error']['code'] == 'unavailable', 'Redis readiness error must be bounded')
redis_failure = c.call('POST', '/api/v1/auth/sessions', 503, headers={'Authorization': outage_basic})
check(redis_failure['json']['error']['code'] == 'unavailable', 'Redis failure must return a bounded 503')
finally:
compose('start', 'redis')
wait_ready(c)
print('PASS: Redis outage returns bounded 503 for readiness and session creation; service recovers')
compose('stop', 'postgres')
try:
db_ready = c.call('GET', '/health/ready', 503)
check(db_ready['json']['error']['code'] == 'unavailable', 'PostgreSQL readiness error must be bounded')
db_failure = c.call('POST', '/api/v1/users', 503, body={
'username': 'u_dbdown_' + uuid.uuid4().hex[:12],
'display_name': 'Unavailable database probe',
'password': 'Database-unavailable-test-42',
})
check(db_failure['json']['error']['code'] == 'unavailable', 'PostgreSQL failure must return a bounded 503')
finally:
compose('start', 'postgres')
wait_ready(c)
print('PASS: PostgreSQL outage returns bounded 503 for readiness and registration; service recovers')
# Expiry is checked last because all sessions in this run have a two-second TTL.
expiring = c.user('expiry')
c.call('GET', '/api/v1/users/me', actor=expiring)
session_response = c.call(
'POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + base64.b64encode(
(expiring['registration']['username'] + ':' + expiring['registration']['password']).encode()
).decode()}, schema='Session',
)
expires_at = timestamp(session_response['json']['expires_at'])
remaining = (expires_at - datetime.now(timezone.utc)).total_seconds()
check(0 < remaining <= 2.5, 'session did not receive the configured two-second TTL')
time.sleep(remaining + 0.15)
c.call('GET', '/api/v1/users/me', 401, actor={'token': session_response['json']['token']})
print('PASS: Redis session expires at the original short TTL')
if __name__ == '__main__':
run(main)