From be7a90132b113fc64bbbefc7bcc43e22560cd73d Mon Sep 17 00:00:00 2001 From: lenovo Date: Sun, 18 Oct 2026 15:53:16 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=BE?= =?UTF-8?q?=D0=B2=D0=B0=D1=82=D1=8C=20=D0=BB=D0=B0=D0=B1=D0=BE=D1=80=D0=B0?= =?UTF-8?q?=D1=82=D0=BE=D1=80=D0=BD=D1=83=D1=8E=20=D1=80=D0=B0=D0=B1=D0=BE?= =?UTF-8?q?=D1=82=D1=83=202?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 15 +- Dockerfile | 16 ++ Makefile | 5 +- README.md | 24 +- REPORT.md | 39 ++-- app/__init__.py | 0 app/api/__init__.py | 0 app/api/deps.py | 42 ++++ app/api/routes/__init__.py | 0 app/api/routes/auth.py | 31 +++ app/api/routes/chats.py | 33 +++ app/api/routes/health.py | 17 ++ app/api/routes/me.py | 11 + app/api/routes/messages.py | 32 +++ app/api/routes/users.py | 14 ++ app/api/serialize.py | 15 ++ app/core/__init__.py | 0 app/core/config.py | 31 +++ app/core/cursors.py | 37 ++++ app/core/errors.py | 69 ++++++ app/core/security.py | 39 ++++ app/db/__init__.py | 1 + app/db/migrate.py | 32 +++ app/main.py | 54 +++++ app/repositories/__init__.py | 0 app/repositories/memory.py | 149 +++++++++++++ app/repositories/postgres.py | 160 ++++++++++++++ app/repositories/redis_sessions.py | 66 ++++++ app/schemas.py | 68 ++++++ compose.grade4.yaml | 4 + compose.yaml | 67 ++++++ evidence/compose-config.txt | 3 + evidence/compose-shutdown.txt | 25 +++ evidence/explain-history.txt | 10 + evidence/make-check.txt | 5 + evidence/make-test-grade4.txt | 126 +++++++++++ evidence/make-validate.txt | 5 + evidence/restart-hook.txt | 37 ++++ evidence/verification-2026-10-15.txt | 167 ++++++++++++++ evidence/verification-2026-10-18.txt | 207 ++++++++++++++++++ evidence/verification-metadata-2026-10-18.txt | 13 ++ migrations/0001_initial.sql | 37 ++++ migrations/0002_remove_postgres_sessions.sql | 3 + requirements-app.txt | 6 + scripts/explain_history.py | 72 ++++++ scripts/restart.sh | 6 + scripts/test-grade4.sh | 26 +++ tests/grade4.py | 125 +++++++++++ 48 files changed, 1921 insertions(+), 23 deletions(-) create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/api/__init__.py create mode 100644 app/api/deps.py create mode 100644 app/api/routes/__init__.py create mode 100644 app/api/routes/auth.py create mode 100644 app/api/routes/chats.py create mode 100644 app/api/routes/health.py create mode 100644 app/api/routes/me.py create mode 100644 app/api/routes/messages.py create mode 100644 app/api/routes/users.py create mode 100644 app/api/serialize.py create mode 100644 app/core/__init__.py create mode 100644 app/core/config.py create mode 100644 app/core/cursors.py create mode 100644 app/core/errors.py create mode 100644 app/core/security.py create mode 100644 app/db/__init__.py create mode 100644 app/db/migrate.py create mode 100644 app/main.py create mode 100644 app/repositories/__init__.py create mode 100644 app/repositories/memory.py create mode 100644 app/repositories/postgres.py create mode 100644 app/repositories/redis_sessions.py create mode 100644 app/schemas.py create mode 100644 compose.grade4.yaml create mode 100644 compose.yaml create mode 100644 evidence/compose-config.txt create mode 100644 evidence/compose-shutdown.txt create mode 100644 evidence/explain-history.txt create mode 100644 evidence/make-check.txt create mode 100644 evidence/make-test-grade4.txt create mode 100644 evidence/make-validate.txt create mode 100644 evidence/restart-hook.txt create mode 100644 evidence/verification-2026-10-15.txt create mode 100644 evidence/verification-2026-10-18.txt create mode 100644 evidence/verification-metadata-2026-10-18.txt create mode 100644 migrations/0001_initial.sql create mode 100644 migrations/0002_remove_postgres_sessions.sql create mode 100644 requirements-app.txt create mode 100644 scripts/explain_history.py create mode 100755 scripts/restart.sh create mode 100755 scripts/test-grade4.sh create mode 100644 tests/grade4.py diff --git a/.env.example b/.env.example index 714c8076..b4e8af6e 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..c8f83e45 --- /dev/null +++ b/Dockerfile @@ -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"] \ No newline at end of file diff --git a/Makefile b/Makefile index 9ecb223e..7a8d1fdd 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/README.md b/README.md index 0e073ff7..dfc20f40 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ Перенести состояние в постоянное хранилище и связать запросы с аутентифицированным пользователем. Подтверждённые сообщения и действующие сессии переживают перезапуск. -Это **skeleton**, а не готовый сервер. Здесь есть задание, контракт и публичные проверки. Реализацию приложения, Dockerfile и требуемую инфраструктуру пишет студент. Язык и framework свободные; UI не обязателен. +Исходный репозиторий — skeleton с заданием, контрактом и публичными проверками. В этой рабочей ветке добавлена реализация минимума на FastAPI и PostgreSQL; дальше её нужно проверять и развивать по критериям лабораторной. Язык и framework свободные; UI не обязателен. [Карта курса](COURSE.md) · [Процесс fork/PR](CONTRIBUTING.md) · [OpenAPI](contracts/openapi.json) · [Семантика API](contracts/README.md) · [Проверки](tests/README.md) · [Отчёт](REPORT.md) · [Примеры JSON](contracts/examples.json) · [Памятка преподавателю](MAINTAINERS.md) @@ -25,7 +25,7 @@ - Минимум lab1 сохранён с объявленным переходом на новую аутентификацию. Все обязательные данные и ещё действующие сессии переживают рестарт API и хранилищ без удаления volumes. - PostgreSQL содержит пользователей, чаты, участников и сообщения. Есть первичные/внешние ключи, уникальность username и миграции с нуля. Составная операция создания чата выполняется атомарно. - Basic применяется только на POST /auth/sessions, остальные endpoint требуют Bearer. Есть срок жизни сессии и отзыв; X-User-Id не даёт доступ. Пароли уже хешируются password KDF. -- make test и make test-persistence ACTION_SCRIPT=scripts/restart.sh проходят. Миграции повторно запускаются без дублирования данных. Secrets/volumes не попадают в Git. +- `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh` и `make test-grade4` проходят. Миграции повторно запускаются без дублирования данных. Secrets/volumes не попадают в Git. ## Оценка «4»: уровень стажёра/джуна @@ -44,7 +44,25 @@ **Трек 2. План запроса и восстановление.** Исследуйте ≥100 000 сообщений с неравномерными размерами чатов, сравните ≥2 индекса/запроса и стоимость записи. Сделайте backup → восстановление в новое хранилище → сверку количества и выбранных сообщений. Обсудите время восстановления и границы потери данных. -## Как начать и проверить +### Запуск реализации этой ветки + +В WSL из корня репозитория: + +```sh +cp -n .env.example .env +# Замените POSTGRES_PASSWORD на локальный пароль из букв и цифр. +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +# Дождаться healthy у api, postgres и redis: +docker compose ps +make test +chmod +x scripts/restart.sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-grade4 +``` + +API применяет новые SQL-миграции при старте. PostgreSQL хранит основные данные в `postgres_data`; Redis хранит сессии в `redis_data` с AOF и `appendfsync always`. Сессия имеет фиксированный абсолютный expiry, logout удаляет её из Redis. Порты API и PostgreSQL публикуются только на `127.0.0.1`, поскольку локальный HTTP не предназначен для удалённого доступа. При переходе с предыдущей версии старые PG-сессии отзываются миграцией 0002; выполните вход заново. `docker compose down` сохраняет тома. Не используйте `docker compose down -v` при проверке сохранности. `make test-grade4` запускает короткий TTL, проверки гонки/отката/отказов, EXPLAIN и затем повторяет smoke и persistence. Запустить только план истории: `docker compose exec -T api python scripts/explain_history.py` (добавляет 10 000 синтетических сообщений). +# Как начать и проверить ```sh # Работает прямо в skeleton, Python 3.9+; приложение не запускается: diff --git a/REPORT.md b/REPORT.md index e42f2b05..0818ab7a 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,48 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: заполнить перед сдачей +- Целевая оценка: 4 +- Commit/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 и БД наружу. ## Доказательства критериев | Критерий 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, `make test-grade4`, restart hook, shutdown | Вывод каждой команды сохранён отдельно; метаданные запуска и состояние контейнеров записаны отдельно, UUID обезличены | `evidence/make-check.txt`, `evidence/make-validate.txt`, `evidence/compose-config.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)`. В последнем локальном запуске PostgreSQL выбрал `messages_history_idx`; страница из 50 строк прочитала 6 shared buffers, время выполнения составило 0.056 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. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/api/__init__.py b/app/api/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/api/deps.py b/app/api/deps.py new file mode 100644 index 00000000..b1e5fb59 --- /dev/null +++ b/app/api/deps.py @@ -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 \ No newline at end of file diff --git a/app/api/routes/__init__.py b/app/api/routes/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/api/routes/auth.py b/app/api/routes/auth.py new file mode 100644 index 00000000..93d9d10a --- /dev/null +++ b/app/api/routes/auth.py @@ -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) \ No newline at end of file diff --git a/app/api/routes/chats.py b/app/api/routes/chats.py new file mode 100644 index 00000000..b2e4e66b --- /dev/null +++ b/app/api/routes/chats.py @@ -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)) \ No newline at end of file diff --git a/app/api/routes/health.py b/app/api/routes/health.py new file mode 100644 index 00000000..9547683c --- /dev/null +++ b/app/api/routes/health.py @@ -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'} \ No newline at end of file diff --git a/app/api/routes/me.py b/app/api/routes/me.py new file mode 100644 index 00000000..a510d63c --- /dev/null +++ b/app/api/routes/me.py @@ -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)) \ No newline at end of file diff --git a/app/api/routes/messages.py b/app/api/routes/messages.py new file mode 100644 index 00000000..b3f6c23e --- /dev/null +++ b/app/api/routes/messages.py @@ -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} \ No newline at end of file diff --git a/app/api/routes/users.py b/app/api/routes/users.py new file mode 100644 index 00000000..efd3d1d7 --- /dev/null +++ b/app/api/routes/users.py @@ -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) \ No newline at end of file diff --git a/app/api/serialize.py b/app/api/serialize.py new file mode 100644 index 00000000..c7272e2c --- /dev/null +++ b/app/api/serialize.py @@ -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} \ No newline at end of file diff --git a/app/core/__init__.py b/app/core/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/core/config.py b/app/core/config.py new file mode 100644 index 00000000..c4df4d72 --- /dev/null +++ b/app/core/config.py @@ -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() diff --git a/app/core/cursors.py b/app/core/cursors.py new file mode 100644 index 00000000..c5b1443c --- /dev/null +++ b/app/core/cursors.py @@ -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 \ No newline at end of file diff --git a/app/core/errors.py b/app/core/errors.py new file mode 100644 index 00000000..0ebe72e1 --- /dev/null +++ b/app/core/errors.py @@ -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') \ No newline at end of file diff --git a/app/core/security.py b/app/core/security.py new file mode 100644 index 00000000..c6546f60 --- /dev/null +++ b/app/core/security.py @@ -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 diff --git a/app/db/__init__.py b/app/db/__init__.py new file mode 100644 index 00000000..c0df4427 --- /dev/null +++ b/app/db/__init__.py @@ -0,0 +1 @@ +"""Настройка базы данных и миграции схемы.""" diff --git a/app/db/migrate.py b/app/db/migrate.py new file mode 100644 index 00000000..c4cad0a0 --- /dev/null +++ b/app/db/migrate.py @@ -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) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..0c435f22 --- /dev/null +++ b/app/main.py @@ -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() \ No newline at end of file diff --git a/app/repositories/__init__.py b/app/repositories/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/repositories/memory.py b/app/repositories/memory.py new file mode 100644 index 00000000..f149fb92 --- /dev/null +++ b/app/repositories/memory.py @@ -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)) diff --git a/app/repositories/postgres.py b/app/repositories/postgres.py new file mode 100644 index 00000000..04ede781 --- /dev/null +++ b/app/repositories/postgres.py @@ -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 diff --git a/app/repositories/redis_sessions.py b/app/repositories/redis_sessions.py new file mode 100644 index 00000000..cfd18de3 --- /dev/null +++ b/app/repositories/redis_sessions.py @@ -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 diff --git a/app/schemas.py b/app/schemas.py new file mode 100644 index 00000000..b05e82a9 --- /dev/null +++ b/app/schemas.py @@ -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 \ No newline at end of file diff --git a/compose.grade4.yaml b/compose.grade4.yaml new file mode 100644 index 00000000..d59932b7 --- /dev/null +++ b/compose.grade4.yaml @@ -0,0 +1,4 @@ +services: + api: + environment: + SESSION_TTL_SECONDS: "2" \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..79691711 --- /dev/null +++ b/compose.yaml @@ -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: diff --git a/evidence/compose-config.txt b/evidence/compose-config.txt new file mode 100644 index 00000000..9089a5c5 --- /dev/null +++ b/evidence/compose-config.txt @@ -0,0 +1,3 @@ +$ docker compose --env-file .env config --quiet + +exit_code=0 diff --git a/evidence/compose-shutdown.txt b/evidence/compose-shutdown.txt new file mode 100644 index 00000000..37f55a0b --- /dev/null +++ b/evidence/compose-shutdown.txt @@ -0,0 +1,25 @@ +$ docker compose --env-file .env down + 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 + +$ docker volume ls --filter name=mtusi-lab2 +DRIVER VOLUME NAME +local mtusi-lab2_postgres_data +local mtusi-lab2_redis_data + +PASS: containers stopped; named volumes retained. diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt new file mode 100644 index 00000000..7576c465 --- /dev/null +++ b/evidence/explain-history.txt @@ -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 diff --git a/evidence/make-check.txt b/evidence/make-check.txt new file mode 100644 index 00000000..103d1e4f --- /dev/null +++ b/evidence/make-check.txt @@ -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 diff --git a/evidence/make-test-grade4.txt b/evidence/make-test-grade4.txt new file mode 100644 index 00000000..85896b16 --- /dev/null +++ b/evidence/make-test-grade4.txt @@ -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 diff --git a/evidence/make-validate.txt b/evidence/make-validate.txt new file mode 100644 index 00000000..e01988a9 --- /dev/null +++ b/evidence/make-validate.txt @@ -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 diff --git a/evidence/restart-hook.txt b/evidence/restart-hook.txt new file mode 100644 index 00000000..34bb8582 --- /dev/null +++ b/evidence/restart-hook.txt @@ -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 diff --git a/evidence/verification-2026-10-15.txt b/evidence/verification-2026-10-15.txt new file mode 100644 index 00000000..6f9a484b --- /dev/null +++ b/evidence/verification-2026-10-15.txt @@ -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"} \ No newline at end of file diff --git a/evidence/verification-2026-10-18.txt b/evidence/verification-2026-10-18.txt new file mode 100644 index 00000000..58fc6a18 --- /dev/null +++ b/evidence/verification-2026-10-18.txt @@ -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 diff --git a/evidence/verification-metadata-2026-10-18.txt b/evidence/verification-metadata-2026-10-18.txt new file mode 100644 index 00000000..e92a0459 --- /dev/null +++ b/evidence/verification-metadata-2026-10-18.txt @@ -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. diff --git a/migrations/0001_initial.sql b/migrations/0001_initial.sql new file mode 100644 index 00000000..296fc4b0 --- /dev/null +++ b/migrations/0001_initial.sql @@ -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); diff --git a/migrations/0002_remove_postgres_sessions.sql b/migrations/0002_remove_postgres_sessions.sql new file mode 100644 index 00000000..23a244c2 --- /dev/null +++ b/migrations/0002_remove_postgres_sessions.sql @@ -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; diff --git a/requirements-app.txt b/requirements-app.txt new file mode 100644 index 00000000..e6ef5291 --- /dev/null +++ b/requirements-app.txt @@ -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 diff --git a/scripts/explain_history.py b/scripts/explain_history.py new file mode 100644 index 00000000..635e0e3b --- /dev/null +++ b/scripts/explain_history.py @@ -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()) diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..6ba1547f --- /dev/null +++ b/scripts/restart.sh @@ -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 diff --git a/scripts/test-grade4.sh b/scripts/test-grade4.sh new file mode 100755 index 00000000..2227333c --- /dev/null +++ b/scripts/test-grade4.sh @@ -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 diff --git a/tests/grade4.py b/tests/grade4.py new file mode 100644 index 00000000..66f2d541 --- /dev/null +++ b/tests/grade4.py @@ -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)