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