From 376f1a9a10ffbb02287f34779112f42fdc8dfa5c Mon Sep 17 00:00:00 2001 From: User name Date: Sat, 31 Oct 2026 02:44:10 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=A0=202=20=E2=80=94=20=D0=91=D0=9F?= =?UTF-8?q?=D0=98-2304=20=E2=80=94=20=D0=A1=D0=B0=D0=BB=D0=B0=D0=BC=D0=B0?= =?UTF-8?q?=D1=82=D0=B8=D0=BD=20=E2=80=94=20=D0=BD=D0=B0=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .dockerignore | 29 ++-- .env.example | 17 +-- .gitattributes | 2 + .github/pull_request_template.md | 35 +++-- .github/workflows/application.yml | 26 ++++ Dockerfile | 27 ++++ Makefile | 59 ++++---- REPORT.md | 163 +++++++++++++++----- app/__init__.py | 1 + app/__main__.py | 17 +++ app/api.py | 168 +++++++++++++++++++++ app/config.py | 28 ++++ app/errors.py | 22 +++ app/migrate.py | 37 +++++ app/models.py | 50 ++++++ app/security.py | 93 ++++++++++++ app/store.py | 211 ++++++++++++++++++++++++++ compose.yaml | 118 +++++++++++++++ docs/DATABASE.md | 33 ++++ docs/DEFENSE.md | 52 +++++++ docs/SUBMISSION.md | 15 ++ evidence/README.md | 10 +- evidence/build.txt | 58 +++++++ evidence/clean-build.txt | 221 +++++++++++++++++++++++++++ evidence/clean-expiry.json | 7 + evidence/clean-explain.txt | 29 ++++ evidence/clean-failures.json | 14 ++ evidence/clean-persistence.txt | 5 + evidence/clean-published-smoke.txt | 1 + evidence/clean-restart.json | 68 +++++++++ evidence/clean-source.json | 18 +++ evidence/clean-startup.txt | 42 ++++++ evidence/clean-student-tests.txt | 21 +++ evidence/clean-verification.json | 61 ++++++++ evidence/contract-check.txt | 4 + evidence/expiry.json | 7 + evidence/expiry.txt | 3 + evidence/explain-run.txt | 4 + evidence/explain.json | 235 +++++++++++++++++++++++++++++ evidence/explain.txt | 29 ++++ evidence/failures.json | 14 ++ evidence/final-status.json | 37 +++++ evidence/host.json | 15 ++ evidence/migration-newlines.txt | 6 + evidence/migrations-repeat.txt | 4 + evidence/persistence.txt | 5 + evidence/published-smoke.txt | 1 + evidence/restart.json | 68 +++++++++ evidence/smoke-final.txt | 4 + evidence/smoke.txt | 4 + evidence/source-integrity.json | 16 ++ evidence/startup.txt | 24 +++ evidence/student-tests.txt | 21 +++ evidence/verification.json | 60 ++++++++ infra/redis.conf | 9 ++ migrations/001_initial.sql | 32 ++++ requirements.txt | 17 +++ scripts/check_expiry.py | 35 +++++ scripts/explain_history.py | 76 ++++++++++ scripts/init_local.py | 35 +++++ scripts/restart.sh | 4 + scripts/verify.py | 114 ++++++++++++++ student-tests/test_api.py | 215 ++++++++++++++++++++++++++ 63 files changed, 2739 insertions(+), 117 deletions(-) create mode 100644 .gitattributes create mode 100644 .github/workflows/application.yml create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/__main__.py create mode 100644 app/api.py create mode 100644 app/config.py create mode 100644 app/errors.py create mode 100644 app/migrate.py create mode 100644 app/models.py create mode 100644 app/security.py create mode 100644 app/store.py create mode 100644 compose.yaml create mode 100644 docs/DATABASE.md create mode 100644 docs/DEFENSE.md create mode 100644 docs/SUBMISSION.md create mode 100644 evidence/build.txt create mode 100644 evidence/clean-build.txt create mode 100644 evidence/clean-expiry.json create mode 100644 evidence/clean-explain.txt create mode 100644 evidence/clean-failures.json create mode 100644 evidence/clean-persistence.txt create mode 100644 evidence/clean-published-smoke.txt create mode 100644 evidence/clean-restart.json create mode 100644 evidence/clean-source.json create mode 100644 evidence/clean-startup.txt create mode 100644 evidence/clean-student-tests.txt create mode 100644 evidence/clean-verification.json create mode 100644 evidence/contract-check.txt create mode 100644 evidence/expiry.json create mode 100644 evidence/expiry.txt create mode 100644 evidence/explain-run.txt create mode 100644 evidence/explain.json create mode 100644 evidence/explain.txt create mode 100644 evidence/failures.json create mode 100644 evidence/final-status.json create mode 100644 evidence/host.json create mode 100644 evidence/migration-newlines.txt create mode 100644 evidence/migrations-repeat.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/published-smoke.txt create mode 100644 evidence/restart.json create mode 100644 evidence/smoke-final.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/source-integrity.json create mode 100644 evidence/startup.txt create mode 100644 evidence/student-tests.txt create mode 100644 evidence/verification.json create mode 100644 infra/redis.conf create mode 100644 migrations/001_initial.sql create mode 100644 requirements.txt create mode 100644 scripts/check_expiry.py create mode 100644 scripts/explain_history.py create mode 100644 scripts/init_local.py create mode 100755 scripts/restart.sh create mode 100644 scripts/verify.py create mode 100644 student-tests/test_api.py diff --git a/.dockerignore b/.dockerignore index bc16e556..e9c02b1b 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,20 +1,9 @@ -.git -.github -.env -.env.* -!.env.example -secrets -certs -volumes -data -backups -*.key -*.pem -*.p12 -*.pfx -*.jks -.venv -__pycache__ -node_modules -evidence -.DS_Store +* +!Dockerfile +!requirements.txt +!app/ +!app/*.py +!migrations/ +!migrations/*.sql +!contracts/ +!contracts/openapi.json diff --git a/.env.example b/.env.example index 714c8076..c24b95c2 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,6 @@ -# 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 +# python scripts/init_local.py creates .env and random local secret files. +# Never commit .env or secrets/. +COMPOSE_PROJECT_NAME=mtusi-lab2 +API_PORT=8080 +APP_ENV=lab +SESSION_TTL_SECONDS=3600 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..06cdaa1b --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +*.sh text eol=lf +/migrations/*.sql text eol=lf diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 8ceefa10..ce4e4c1b 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,17 @@ -## Лабораторная 2 - -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO - -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO - -- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. -- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +## Лабораторная 2 + +Автор / группа: Саламатин, БПИ-2304. +Целевая оценка: **4**. Треки на 5 не заявляются. + +Мессенджер из lab1 перенесён на PostgreSQL: пользователи, чаты, участники и сообщения сохраняются после рестарта. Добавлены миграция, scrypt, Basic-вход, Bearer-сессии Redis с TTL и AOF `appendfsync always`, logout и Compose с именованными volumes. Пагинация истории использует составной индекс и keyset-запрос. + +Запуск: `python scripts/init_local.py`, затем `python scripts/verify.py`. Версии, отдельные команды и описание архитектуры — в [REPORT.md](../REPORT.md). Публичные smoke/persistence и 8 собственных интеграционных тестов проходят; EXPLAIN на 10 000 сообщениях подтверждает Index Scan для начала, середины и поздней страницы. Выводы сохранены в `evidence/`. + +Стенд рассчитан на локальные синтетические данные. Нет репликации PostgreSQL/Redis и восстановления после потери volume/host. Источники: задание lab2, собственная lab1, документация Psycopg, PostgreSQL и Redis; ссылки приведены в отчёте. + +- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. +- [x] Контракт и публичные тесты не ослаблены. +- [x] make check и make test выполнены; приложен реальный вывод. +- [x] Сценарии отказов/безопасности своего уровня воспроизведены. +- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. +- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. diff --git a/.github/workflows/application.yml b/.github/workflows/application.yml new file mode 100644 index 00000000..9dcc3f46 --- /dev/null +++ b/.github/workflows/application.yml @@ -0,0 +1,26 @@ +name: application + +on: [push, pull_request] + +permissions: + contents: read + +jobs: + application: + runs-on: ubuntu-latest + timeout-minutes: 12 + steps: + - uses: actions/checkout@v7 + with: + persist-credentials: false + - name: Build stack and run acceptance checks + run: python3 scripts/verify.py --published-base-url http://127.0.0.1:8080 + - name: Save sanitized check results + if: always() + uses: actions/upload-artifact@v7 + with: + name: lab2-evidence + path: evidence/ + - name: Stop local test stack + if: always() + run: docker compose --env-file .env down diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..23e53e63 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +FROM docker:28.5.1-cli AS docker_cli + +FROM python:3.13.15-slim-bookworm AS runtime +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab +WORKDIR /app +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt \ + && useradd --uid 10001 --create-home messenger +COPY app ./app +COPY migrations ./migrations +COPY contracts/openapi.json ./contracts/openapi.json +USER messenger +EXPOSE 8080 +HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \ + CMD python -c "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.getenv('APP_PORT', '8080') + '/health/ready', timeout=2)" +CMD ["python", "-m", "app"] + +# Optional test operator. The API image does not contain the Docker client/socket. +FROM runtime AS checks +USER root +COPY --from=docker_cli /usr/local/bin/docker /usr/local/bin/docker +COPY --from=docker_cli /usr/local/libexec/docker/cli-plugins/docker-compose /usr/local/libexec/docker/cli-plugins/docker-compose +RUN apt-get update && apt-get install -y --no-install-recommends make \ + && rm -rf /var/lib/apt/lists/* +WORKDIR /checks +CMD ["make", "test-student"] diff --git a/Makefile b/Makefile index 9ecb223e..47ab3ca5 100644 --- a/Makefile +++ b/Makefile @@ -1,26 +1,33 @@ -PYTHON ?= python3 -BASE_URL ?= http://localhost:8080 -CA_FILE ?= -ACTION_SCRIPT ?= -TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) - -.PHONY: help check validate test load test-persistence - -help: - @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" - -check: - $(PYTHON) scripts/check_contract.py - -validate: - $(PYTHON) scripts/validate_openapi.py - -test: - $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) - -load: - $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) - -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) +PYTHON ?= python3 +BASE_URL ?= http://localhost:8080 +CA_FILE ?= +ACTION_SCRIPT ?= +TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) + +.PHONY: help check validate test load test-persistence + +help: + @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + +check: + $(PYTHON) scripts/check_contract.py + +validate: + $(PYTHON) scripts/validate_openapi.py + +test: + $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) + +load: + $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) + +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) + +.PHONY: test-student explain +test-student: + $(PYTHON) -m unittest discover -s student-tests -v + +explain: + $(PYTHON) scripts/explain_history.py diff --git a/REPORT.md b/REPORT.md index e42f2b05..83b7960d 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,126 @@ -# Отчёт — лабораторная 2 - -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO - -## Запуск из чистого clone - -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. - -## Архитектура и решения - -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. - -## Доказательства критериев - -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. - -## Эксперименты и отказы - -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | - -## Ограничения и следующие шаги - -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +# Отчёт — лабораторная 2 + +- Автор: Саламатин, БПИ-2304. +- Целевая оценка: **4**, включая все требования уровня 3. Исследовательские треки на 5 не заявляются. +- Проверено 31 октября 2026 года, Europe/Moscow. В JSON и времени контейнеров используется UTC. +- Задание: [mtusi2026/mtusi2026lab2](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2), предоставленный архив, контракт 1.2.0. README задания, содержимое `contracts/` и публичные `tests/` сохранены. +- Основа: собственная lab1 из `Lab1_Highload`, commit `0a931edce3bcd3c1130093b3dd5259f7b208cf2e`. Перенесены HTTP-маршруты, строгие модели, формат ошибок, request ID, проверка доступа и идея подписанного cursor. In-memory Store полностью заменён PostgreSQL/Redis; регистрация и идентификация изменены по контракту lab2. +- Локальный commit сборки из чистого clone зафиксирован в `evidence/clean-source.json`. Публикация fork/ветки и оформление PR выполняются отдельно. + +## Запуск из чистого clone + +Нужны Docker Desktop с Linux containers, Docker Compose и Python 3.13 для локальных вспомогательных скриптов. API и все его Python-зависимости собираются в контейнере; локальная установка PostgreSQL/Redis не требуется. На Linux подходит Docker Engine с Compose. + +Версии: Python `3.13.15-slim-bookworm`, PostgreSQL `17.6-bookworm`, Redis `7.4.5-bookworm`; тестовый Docker CLI `28.5.1-cli`. FastAPI 0.141.1, Pydantic 2.13.5, Uvicorn 0.53.0, Psycopg 3.2.10, pool 3.2.6, redis-py 6.4.0. Прямые и транзитивные Python-зависимости закреплены в `requirements.txt`. Образы закреплены тегами версий; фактические image ID записаны в доказательствах. + +Из корня полученного clone, PowerShell: + +```powershell +python scripts/init_local.py +python scripts/verify.py +``` + +На этой машине вместо `python` доступен `D:\Labs_Highload\.tools\bin\python3.13.exe`: + +```powershell +& 'D:\Labs_Highload\.tools\bin\python3.13.exe' scripts/init_local.py +& 'D:\Labs_Highload\.tools\bin\python3.13.exe' scripts/verify.py +``` + +`init_local.py` создаёт `.env`, случайные пароли PostgreSQL/Redis, DSN и ключ подписи cursor в `secrets/`. Значения не печатаются. Повторный запуск сохраняет секреты и нормализует окончания строк для Linux. В `.env` только имя Compose-проекта, опубликованный порт, окружение и TTL. Пароли/DSN передаются как Compose secrets, а не в образе. Не удалять секреты существующего стенда при сохранённых volumes. + +`verify.py` собирает API и тестовый образ, поднимает зависимости, ждёт readiness, запускает публичные и собственные тесты, полный restart, отдельную проверку TTL=2, EXPLAIN и повтор миграций. Результаты сохраняются в `evidence/`; основной стенд остаётся запущенным. Проверка управляет только сервисами данного Compose-проекта. Существующий контейнер с именем временного TTL-теста не удаляется автоматически. + +Отдельные команды: + +```powershell +docker compose --env-file .env config --quiet +docker compose --env-file .env build api checks +docker compose --env-file .env up -d --wait +docker compose --env-file .env run --rm --no-deps checks make check +docker compose --env-file .env run --rm --no-deps checks make test +docker compose --env-file .env run --rm --no-deps checks make test-student +docker compose --env-file .env run --rm --no-deps checks make test-persistence ACTION_SCRIPT=scripts/restart.sh +docker compose --env-file .env run --rm --no-deps checks make explain +``` + +На Linux после clone: `chmod +x scripts/restart.sh`. `verify.py` также выполняет chmod перед публичным persistence-тестом. Контейнер `checks` содержит GNU Make и Docker CLI: это позволяет выполнять неизменённый Linux hook и тесты на Windows. Для управления рестартом ему подключён локальный Docker socket; сервис относится к профилю `tools`, не запускается с обычным `up` и завершается после проверки. Runtime API работает от пользователя `messenger`, без Docker CLI/socket. + +API публикуется только на loopback, по умолчанию `127.0.0.1:8080`; PostgreSQL и Redis не имеют опубликованных портов. На проверявшейся Windows-машине порт 8080 сбрасывал соединения, поэтому в локальном `.env` выбран `API_PORT=18080`: `http://127.0.0.1:18080`. На этом порту curl и публичный HTTP-клиент проверяют опубликованный API. Основные проверки также идут из отдельного клиента к API по Docker-сети. Для дополнительного smoke с хоста: `python scripts/verify.py --published-base-url http://127.0.0.1:18080`. `APP_HOST=0.0.0.0` и `APP_PORT=8080` заданы внутри контейнера; `API_PORT` меняет только внешний порт. `APP_ENV` влияет на стартовый лог, `SESSION_TTL_SECONDS` — на новые сессии. Внутри контейнеров `SESSION_STORE=redis`, DSN и ключ читаются через `DATABASE_URL_FILE`, `CACHE_URL_FILE`, `CURSOR_KEY_FILE`. + +Остановка с сохранением данных: + +```powershell +docker compose --env-file .env stop +# Либо удалить контейнеры и сеть, сохранив volumes: +docker compose --env-file .env down +``` + +Только для намеренного уничтожения всех данных этого учебного стенда: `docker compose --env-file .env down --volumes`. Эта команда не используется ни в одном restart-тесте. + +Отдельный job сборки и acceptance-проверок подготовлен в `.github/workflows/application.yml`. Он использует изолированный runner, создаёт локальные секреты и сохраняет только `evidence/`. На площадке workflow не запускался; локальный эквивалент выполнен из чистого clone. GitHub workflow — дополнительная возможность, локальные проверки от площадки не зависят. + +## Архитектура и решения + +Клиент → Uvicorn/FastAPI → PostgreSQL для пользователей, чатов, членства и сообщений; Redis для серверных сессий. Схема и транзакционные границы описаны в [docs/DATABASE.md](docs/DATABASE.md). + +Миграция `001_initial.sql` создаёт PK/FK, UNIQUE username, ограничения длины и индексы. Сервис `migrate` применяет её до API. Версии и SHA-256 находятся в `schema_migrations`; advisory lock сериализует запуск. Перед checksum окончания строк нормализуются к LF, чтобы Windows checkout не менял версию SQL. Повтор миграции не меняет данные, изменённый ранее применённый SQL отклоняется. + +Отдельно на существующей БД повторно применены временные LF- и CRLF-копии одного SQL: обе распознаны как Unchanged, версия, checksum и applied_at не изменились. Результат — `evidence/migration-newlines.txt`. + +Все значения SQL передаются параметрами. Пул PostgreSQL ограничен 10 соединениями и очередью 20 запросов. Ожидание пула 1 s, соединения 2 s, SQL 2 s, блокировки 1 s; keepalive и TCP_USER_TIMEOUT ограничивают сетевые зависания. У Redis максимум 10 соединений, connect/read timeout 1 s, повторов команд нет. Общий бюджет обработки HTTP — 5 s. Занятый/недоступный сервис даёт 503 без SQL, DSN и stack trace в ответе. + +Регистрация сохраняет scrypt-хеш с независимой 128-битной солью: N=16384, r=8, p=1, выход 32 байта. Вычисление вынесено из event loop, одновременно выполняются максимум четыре KDF. UTF-8 пароль длиной 128 code points, включая двоеточие и многобайтовые символы, проверен без усечения. Basic используется только при входе. Отсутствующий пользователь и неверный пароль возвращают одинаковый 401 и Basic challenge. + +Bearer содержит 256 случайных бит. В Redis хранится SHA-256 токена как ключ и UUID/абсолютное время окончания как значение. `PXAT` и дополнительная проверка срока в API не позволяют продлевать сессию чтением/рестартом. Logout удаляет ключ до 204. Неизвестный, истёкший и отозванный токены дают 401 с Bearer challenge; X-User-Id не влияет на личность. + +Redis — единственное хранилище сессий, поэтому настроены volume, AOF и `appendfsync always`. TTL управляет сроком жизни, AOF — сохранностью. Кэширования истории нет: следующее чтение идёт в PostgreSQL и видит подтверждённую запись. При отказе Redis API не подменяет сессии локальной памятью. Для readiness критичны оба хранилища; liveness проверяет только процесс. + +Запись сообщения блокирует строку своего чата до COMMIT. Новая метка не меньше текущего времени и предыдущей метки + 1 microsecond. Это сохраняет порядок commit в одном чате при совпадении/откате часов. История использует подписанный cursor, привязанный к чату, и keyset-условие `(created_at, id) > (...)`. Общего snapshot между страницами нет; поздние записи могут появиться на следующих страницах. После рестарта cursor остаётся действителен благодаря сохранённому ключу подписи. + +## Доказательства критериев + +| Критерий | Команда / сценарий | Наблюдение | Доказательство | +| --- | --- | --- | --- | +| Структура и публичный API | `make check`, `make test` в checks | PASS, Unicode, членство, пагинация, Basic/Bearer, logout | `contract-check.txt`, `smoke.txt`, `smoke-final.txt` | +| Реальные PostgreSQL/Redis, volume и полный restart | Неизменённый `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | Подтверждённое сообщение и прежняя сессия сохранились; перезапущены все 3 сервиса | `persistence.txt`, `restart.json` | +| Миграция с нуля и повторяемость | Старт migrate, затем повтор `compose run --rm --no-deps migrate` | 001 применена; повтор — Unchanged; количества строк совпали | `migrations-repeat.txt`, `verification.json`, `clean-source.json` | +| Password KDF, UTF-8, неверные credentials, logout | `make test-student` | Хеш проверен scrypt; пароль 128 code points без усечения; неверный пароль/Basic на бизнес-endpoint/отозванный токен — 401 | `student-tests.txt` | +| Redis реально хранит сессии с TTL/persistence | Интеграционный SIGKILL Redis и возврат со старым токеном | Сессия восстановилась из AOF, абсолютный expiry не изменился | `student-tests.txt`, `infra/redis.conf` | +| Гонка регистрации | 10 параллельных запросов одного username | 1 ответ 201, 9 ответов 409, 1 строка users | `student-tests.txt` | +| Rollback составной операции | Второй участник чата неизвестен; сравнение БД до/после | 400, число чатов/членств не изменилось, частичного чата нет | `student-tests.txt` | +| Сохранность конкурентных сообщений | 100 сообщений, 10 HTTP-клиентов, чтение всех страниц | 100 подтверждений, 100 уникальных UUID, все тексты на месте | `student-tests.txt` | +| Индекс истории ≥10 000 сообщений | `make explain` | Начало/середина/поздняя страница: Index Scan, LIMIT 51, без Seq Scan/OFFSET | `explain.json`, `explain.txt`, `explain-run.txt` | +| Expiry при коротком TTL | Отдельный API с TTL=2 | 200 сразу, 401 через 2.3 s; основной TTL не меняется | `expiry.json`, `expiry.txt` | +| Недоступность Redis/БД | Поочерёдный stop/start каждого хранилища | Live 200, ready и защищённый запрос 503 примерно за 1 s, анонимный X-User-Id 401; прежняя сессия работает после восстановления | `failures.json`, `student-tests.txt` | +| Сборка и повтор проверок из чистого clone | Отдельный Compose-проект и пустые volumes | Чистый commit, независимые secrets/volumes, повтор проверок | `clean-source.json`, `clean-verification.json`, `clean-build.txt` | + +Имена файлов в таблице относятся к `evidence/`, если не указан иной каталог. + +## Измерения и отказы + +Стенд: Windows, Docker Desktop/WSL2 Linux containers, Intel Core i5-9600K, 6 физических/логических ядер, RAM 31.9 GiB. Лимиты: API 1 CPU/256 MiB, PostgreSQL 1 CPU/512 MiB, Redis 0.5 CPU/192 MiB; клиент проверок 1 CPU/256 MiB. Версии и фактические ограничения сохранены в JSON. Это функциональные проверки и локальный план SQL; максимальная пропускная способность/RPS/p95/p99 не измерялись и не заявляются. + +Для плана создан отдельный чат с 10 000 синтетическими сообщениями, выполнен ANALYZE. Измерены первая страница и страницы после 5000-го/9900-го сообщения, по 50 элементов. Каждому HTTP-запросу соответствует `LIMIT 51`: лишняя строка нужна только для признака следующей страницы. Сохранены машинный JSON и текстовый EXPLAIN (ANALYZE, BUFFERS). Во всех трёх случаях используется `messages_chat_created_id_idx`, обрабатывается 51 строка. Во втором прогретом чтении время выполнения составляло около 0.03 ms и 3–4 shared buffer hits. Эти цифры относятся к SQL на прогретом локальном наборе, а не ко времени HTTP или дисковому чтению холодного стенда. + +| Воздействие | Результат | +| --- | --- | +| Рестарт API + PostgreSQL + Redis | Те же данные и старый токен доступны после readiness; имена volumes сохранены | +| SIGKILL Redis | Сессия восстанавливается из AOF; абсолютный expiry не продлён | +| Stop Redis | Защищённый запрос 503 примерно за 1 s, live 200; после start работает старый токен | +| Stop PostgreSQL | Защищённый запрос 503 примерно за 1 s, live 200; пул восстанавливает соединения | +| Истечение TTL | Через 2.3 s сессия с TTL=2 отклонена с 401 | +| Неизвестный участник при создании чата | Вся SQL-транзакция откатилась | + +## Ограничения + +Один Docker-host, одна PostgreSQL и один Redis: рестарт выдерживается, потеря host/диска/volume — нет. Backup/restore, репликация и HA не реализованы. Redis flush уничтожает сессии. При потере SQL-соединения после отправки COMMIT клиент может получить неопределённый результат; идемпотентность сообщений относится к lab3. Общего snapshot между страницами нет. Записи одного очень активного чата сериализуются его row lock. Нет UI, TLS, лимита хранения истории и исследования уровня 5. HTTP разрешён только в локальном изолированном стенде с синтетическими паролями. + +## Источники и разбор + +- [Задание и контракт lab2](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2); локальные `README.md`, `contracts/README.md`, OpenAPI и публичные тесты. +- Собственная реализация lab1, указанный выше commit. +- [Psycopg connection pools](https://www.psycopg.org/psycopg3/docs/advanced/pool.html). +- [PostgreSQL EXPLAIN](https://www.postgresql.org/docs/17/using-explain.html), [транзакции](https://www.postgresql.org/docs/17/tutorial-transactions.html). +- [redis-py asyncio](https://redis.readthedocs.io/en/stable/examples/asyncio_examples.html), [Redis persistence](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/). +- Объяснение схемы — [docs/DATABASE.md](docs/DATABASE.md); сценарий защиты и разбор решений — [docs/DEFENSE.md](docs/DEFENSE.md); порядок передачи файлов — [docs/SUBMISSION.md](docs/SUBMISSION.md). diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..7a56db5b --- /dev/null +++ b/app/__init__.py @@ -0,0 +1 @@ +"""Laboratory 1: a single-process, in-memory messenger.""" diff --git a/app/__main__.py b/app/__main__.py new file mode 100644 index 00000000..c4416c87 --- /dev/null +++ b/app/__main__.py @@ -0,0 +1,17 @@ +import logging +import os + +import uvicorn + + +def main(): + logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") + logging.getLogger("psycopg.pool").setLevel(logging.CRITICAL) + logging.info("Starting lab2 environment=%s with PostgreSQL and Redis", os.getenv("APP_ENV", "lab")) + uvicorn.run("app.api:app", host=os.getenv("APP_HOST", "0.0.0.0"), + port=int(os.getenv("APP_PORT", "8080")), workers=1, + access_log=False, timeout_graceful_shutdown=5) + + +if __name__ == "__main__": + main() diff --git a/app/api.py b/app/api.py new file mode 100644 index 00000000..183769c5 --- /dev/null +++ b/app/api.py @@ -0,0 +1,168 @@ +import asyncio +from contextlib import asynccontextmanager +import json +import logging +from pathlib import Path +import re +from time import perf_counter +from uuid import uuid4 + +from fastapi import Depends, FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from fastapi.responses import Response +import psycopg +from psycopg_pool import PoolTimeout, TooManyRequests +from redis.exceptions import RedisError +from pydantic import ValidationError +from starlette.exceptions import HTTPException + +from .config import Settings +from .errors import APIError, invalid, unavailable +from .models import CreateChat, CreateMessage, CreateUser +from .security import basic_credentials, identifier +from .store import Store + +logger = logging.getLogger("messenger") + + +def error_response(request, status, code, message, headers=None): + return JSONResponse(status_code=status, headers=headers, content={"error": { + "code": code, "message": message, "request_id": request.state.request_id}}) + + +async def body(request, model): + content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower() + if content_type != "application/json": + raise APIError(415, "unsupported_media_type", "Use application/json") + try: + raw = (await request.body()).decode("utf-8") + def reject_constant(value): + raise ValueError("Nonstandard JSON constant") + data = json.loads(raw, parse_constant=reject_constant) + return model.model_validate(data) + except (ValueError, UnicodeError, ValidationError): + raise invalid("Body must be valid UTF-8 JSON with the required fields and types") from None + + +def pagination(request): + raw = request.query_params.get("limit", "50") + if re.fullmatch(r"[0-9]+", raw) is None or len(raw) > 3 or not 1 <= int(raw) <= 100: + raise invalid("Limit must be an integer from 1 to 100") + return int(raw), request.query_params.get("cursor") + + +def create_app(settings=None): + @asynccontextmanager + async def lifespan(app): + store = Store(settings or Settings.load()) + app.state.store = store + try: + await store.open() + yield + finally: + await store.close() + + app = FastAPI(title="Lab 2 messenger", docs_url=None, redoc_url=None, + openapi_url=None, redirect_slashes=False, lifespan=lifespan) + + @app.middleware("http") + async def request_context(request, call_next): + request.state.request_id = str(uuid4()) + start = perf_counter() + try: + async with asyncio.timeout(5): + response = await call_next(request) + except (psycopg.Error, PoolTimeout, TooManyRequests, RedisError, TimeoutError): + error = unavailable() + logger.warning("Storage unavailable request_id=%s", request.state.request_id) + response = error_response(request, error.status, error.code, error.message) + except Exception: + logger.error("Unhandled error request_id=%s", request.state.request_id) + response = error_response(request, 500, "internal_error", "Internal server error") + response.headers["X-Request-Id"] = request.state.request_id + logger.info("request_id=%s method=%s path=%s status=%s duration_ms=%.2f", + request.state.request_id, request.method, request.url.path, + response.status_code, (perf_counter() - start) * 1000) + return response + + @app.exception_handler(APIError) + async def api_error(request, error): + return error_response(request, error.status, error.code, error.message, error.headers) + + @app.exception_handler(RequestValidationError) + async def validation_error(request, error): + return error_response(request, 400, "invalid_request", "Invalid request parameters") + + @app.exception_handler(HTTPException) + async def routing_error(request, error): + code = "not_found" if error.status_code == 404 else "invalid_request" + return error_response(request, error.status_code, code, "Unknown path or unsupported method") + + async def current_user(request: Request): + user, token = await app.state.store.authenticate(request.headers.get("authorization")) + request.state.session_token = token + return user + + @app.get("/health/live") + async def health(): + return {"status": "ok"} + + @app.get("/health/ready") + async def readiness(): + await app.state.store.ready() + return {"status": "ok"} + + @app.post("/api/v1/auth/sessions", status_code=201) + async def login(request: Request): + credentials = basic_credentials(request.headers.get("authorization")) + if await request.body(): + raise invalid("Session creation does not accept a body") + return await app.state.store.login(*credentials) + + @app.delete("/api/v1/auth/sessions/current", status_code=204) + async def logout(request: Request, user=Depends(current_user)): + await app.state.store.logout(request.state.session_token) + return Response(status_code=204) + + @app.post("/api/v1/users", status_code=201) + async def create_user(request: Request): + return await app.state.store.create_user(await body(request, CreateUser)) + + @app.get("/api/v1/users/me") + async def me(user=Depends(current_user)): + return user + + @app.post("/api/v1/chats", status_code=201) + async def create_chat(request: Request, user=Depends(current_user)): + return await app.state.store.create_chat(user["id"], await body(request, CreateChat)) + + @app.get("/api/v1/chats") + async def list_chats(request: Request, user=Depends(current_user)): + return await app.state.store.list_chats(user["id"], *pagination(request)) + + @app.get("/api/v1/chats/{chat_id}") + async def get_chat(chat_id: str, user=Depends(current_user)): + return await app.state.store.get_chat(user["id"], identifier(chat_id)) + + @app.post("/api/v1/chats/{chat_id}/messages", status_code=201) + async def create_message(chat_id: str, request: Request, user=Depends(current_user)): + chat_id = identifier(chat_id) + await app.state.store.get_chat(user["id"], chat_id) + return await app.state.store.create_message(user["id"], chat_id, await body(request, CreateMessage)) + + @app.get("/api/v1/chats/{chat_id}/messages") + async def list_messages(chat_id: str, request: Request, user=Depends(current_user)): + chat_id = identifier(chat_id) + await app.state.store.get_chat(user["id"], chat_id) + return await app.state.store.list_messages(user["id"], chat_id, *pagination(request)) + + @app.get("/openapi.json", include_in_schema=False) + async def contract(): + path = Path(__file__).resolve().parents[1] / "contracts" / "openapi.json" + return json.loads(path.read_text(encoding="utf-8")) + + return app + + +app = create_app() diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..7c405f65 --- /dev/null +++ b/app/config.py @@ -0,0 +1,28 @@ +"""Runtime settings; credential values are never logged.""" +from dataclasses import dataclass +import os +from pathlib import Path + + +def secret(name): + return Path(os.environ[name + "_FILE"]).read_text(encoding="utf-8").strip() + + +@dataclass(frozen=True) +class Settings: + database_url: str + cache_url: str + cursor_key: bytes + session_ttl: int + + @classmethod + def load(cls): + ttl = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + if not 1 <= ttl <= 604800: + raise ValueError("SESSION_TTL_SECONDS must be in 1..604800") + if os.getenv("SESSION_STORE", "redis") != "redis": + raise ValueError("This deployment uses SESSION_STORE=redis") + key = secret("CURSOR_KEY").encode() + if len(key) < 32: + raise ValueError("Cursor key must contain at least 32 bytes") + return cls(secret("DATABASE_URL"), secret("CACHE_URL"), key, ttl) diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..cf7a0621 --- /dev/null +++ b/app/errors.py @@ -0,0 +1,22 @@ +class APIError(Exception): + def __init__(self, status: int, code: str, message: str, headers=None): + self.status = status + self.code = code + self.message = message + self.headers = headers or {} + super().__init__(message) + + +def invalid(message="Invalid request"): + return APIError(400, "invalid_request", message) + + +def unauthorized(basic=False): + challenge = ('Basic realm="messenger", charset="UTF-8"' if basic + else 'Bearer realm="messenger"') + return APIError(401, "unauthorized", "Valid credentials required", + {"WWW-Authenticate": challenge}) + + +def unavailable(): + return APIError(503, "unavailable", "Storage temporarily unavailable") diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..337225ae --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,37 @@ +"""Apply numbered migrations atomically; safe to repeat and serialize.""" +import hashlib +from pathlib import Path + +import psycopg + +from .config import secret + +ROOT = Path(__file__).resolve().parents[1] + + +def migrate(): + with psycopg.connect(secret("DATABASE_URL"), connect_timeout=2, + options="-c statement_timeout=10000 -c lock_timeout=5000") as conn: + conn.execute("SELECT pg_advisory_xact_lock(202602)") + conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, sha256 text NOT NULL, + applied_at timestamptz NOT NULL DEFAULT clock_timestamp())""") + for path in sorted((ROOT / "migrations").glob("[0-9]*.sql")): + # Git checkout may change LF to CRLF on Windows; SQL is unchanged. + content = path.read_text(encoding="utf-8").encode("utf-8") + checksum = hashlib.sha256(content).hexdigest() + row = conn.execute("SELECT sha256 FROM schema_migrations WHERE version=%s", (path.name,)).fetchone() + if row: + if row[0] != checksum: + raise RuntimeError("Applied migration checksum differs: " + path.name) + print("Unchanged:", path.name) + continue + conn.execute(content.decode("utf-8")) + conn.execute("INSERT INTO schema_migrations(version, sha256) VALUES (%s, %s)", + (path.name, checksum)) + print("Applied:", path.name) + print("PASS: migrations committed") + + +if __name__ == "__main__": + migrate() diff --git a/app/models.py b/app/models.py new file mode 100644 index 00000000..a2c53970 --- /dev/null +++ b/app/models.py @@ -0,0 +1,50 @@ +"""Strict request models; strings retain their original Unicode content.""" +import re +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, field_validator + + +class Input(BaseModel): + model_config = ConfigDict(strict=True, extra="forbid") + + @field_validator("*", check_fields=False) + @classmethod + def valid_text(cls, value): + if isinstance(value, str): + if not value.strip(): + raise ValueError("A string must not be blank") + value.encode("utf-8") + if "\x00" in value: + raise ValueError("NUL is not supported") + return value + + +class CreateUser(Input): + username: str + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def username_format(cls, value): + if re.fullmatch(r"[a-z0-9_]{3,32}", value) is None: + raise ValueError("Invalid username") + return value + + +class CreateChat(Input): + title: str = Field(min_length=1, max_length=100) + member_ids: list[str] = Field(min_length=1, max_length=100) + + @field_validator("member_ids") + @classmethod + def members(cls, values): + normalized = [str(UUID(value)) for value in values] + if len(set(normalized)) != len(normalized): + raise ValueError("Duplicate members") + return normalized + + +class CreateMessage(Input): + text: str = Field(min_length=1, max_length=4000) diff --git a/app/security.py b/app/security.py new file mode 100644 index 00000000..c4b5061a --- /dev/null +++ b/app/security.py @@ -0,0 +1,93 @@ +"""scrypt passwords, strict Basic credentials and persistent signed cursors.""" +import base64 +from datetime import datetime, timezone +import hashlib +import hmac +import json +import re +import secrets +from uuid import UUID + +from .errors import invalid, unauthorized + + +def password_hash(password, salt=None): + salt = salt or secrets.token_bytes(16) + digest = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=16384, + r=8, p=1, dklen=32, maxmem=64 * 1024 * 1024) + return "scrypt$16384$8$1$" + salt.hex() + "$" + digest.hex() + + +def password_matches(password, encoded): + try: + algorithm, n, r, p, salt, digest = encoded.split("$") + if (algorithm, n, r, p) != ("scrypt", "16384", "8", "1"): + return False + actual = password_hash(password, bytes.fromhex(salt)).rsplit("$", 1)[1] + return hmac.compare_digest(actual, digest) + except (ValueError, UnicodeError): + return False + + +def basic_credentials(header): + try: + scheme, encoded = header.split(" ", 1) + if scheme.lower() != "basic" or len(encoded) > 2048: + raise ValueError + value = base64.b64decode(encoded, validate=True).decode("utf-8") + username, password = value.split(":", 1) + if re.fullmatch(r"[a-z0-9_]{3,32}", username) is None: + raise ValueError + if not 12 <= len(password) <= 128: + raise ValueError + return username, password + except (AttributeError, ValueError, UnicodeError): + raise unauthorized(basic=True) from None + + +def bearer(header): + try: + scheme, token = header.split(" ", 1) + if scheme.lower() != "bearer" or re.fullmatch(r"[A-Za-z0-9_-]{43}", token) is None: + raise ValueError + return token + except (AttributeError, ValueError): + raise unauthorized() from None + + +def identifier(value): + try: + return UUID(value) + except (ValueError, AttributeError, TypeError): + raise invalid("Invalid UUID") from None + + +def stamp(value): + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +class Cursors: + def __init__(self, key): + self.key = key + + def encode(self, scope, item): + payload = json.dumps([scope, item["created_at"], item["id"]], separators=(",", ":")).encode() + signature = hmac.digest(self.key, payload, hashlib.sha256) + return base64.urlsafe_b64encode(signature + payload).decode().rstrip("=") + + def decode(self, scope, token): + try: + if not token or len(token) > 1024: + raise ValueError + raw = base64.b64decode(token + "=" * (-len(token) % 4), altchars=b"-_", validate=True) + signature, payload = raw[:32], raw[32:] + if not hmac.compare_digest(signature, hmac.digest(self.key, payload, hashlib.sha256)): + raise ValueError + parts = json.loads(payload) + if not isinstance(parts, list) or len(parts) != 3 or parts[0] != scope: + raise ValueError + if not all(isinstance(x, str) for x in parts) or not parts[1].endswith("Z"): + raise ValueError + return datetime.fromisoformat(parts[1].replace("Z", "+00:00")), UUID(parts[2]) + except (ValueError, TypeError, UnicodeError): + raise invalid("Invalid cursor for this resource") from None diff --git a/app/store.py b/app/store.py new file mode 100644 index 00000000..7386fd5c --- /dev/null +++ b/app/store.py @@ -0,0 +1,211 @@ +"""Persistent business data and durable Redis sessions; no local state cache.""" +import asyncio +from datetime import datetime, timezone +import hashlib +import json +import secrets +from uuid import UUID, uuid4 + +from psycopg.errors import ForeignKeyViolation, UniqueViolation +from psycopg.rows import dict_row +from psycopg_pool import AsyncConnectionPool +import redis.asyncio as redis +from redis.asyncio.retry import Retry +from redis.backoff import NoBackoff + +from .errors import APIError, invalid, unauthorized +from .security import Cursors, bearer, password_hash, password_matches, stamp + +USER_COLUMNS = "id, username, display_name, created_at" +MESSAGE_COLUMNS = "id, chat_id, sender_id, text, created_at" + + +def public(row): + return {key: (str(value) if isinstance(value, UUID) else + stamp(value) if isinstance(value, datetime) else value) + for key, value in row.items()} + + +class Store: + def __init__(self, settings): + self.settings = settings + self.cursors = Cursors(settings.cursor_key) + self.kdf_slots = asyncio.Semaphore(4) + self.dummy_hash = password_hash("dummy-password-for-missing-user", b"0" * 16) + self.pool = AsyncConnectionPool( + settings.database_url, min_size=1, max_size=10, max_waiting=20, + timeout=1, open=False, reconnect_timeout=5, + check=AsyncConnectionPool.check_connection, + kwargs={"row_factory": dict_row, "connect_timeout": 2, + "keepalives": 1, "keepalives_idle": 2, "keepalives_interval": 1, + "keepalives_count": 2, "tcp_user_timeout": 2000, + "options": "-c timezone=UTC -c statement_timeout=2000 -c lock_timeout=1000"}) + self.sessions = redis.Redis.from_url( + settings.cache_url, decode_responses=True, max_connections=10, + socket_connect_timeout=1, socket_timeout=1, + retry=Retry(NoBackoff(), 0), retry_on_timeout=False) + + async def open(self): + await self.pool.open() + await self.pool.wait(timeout=10) + await self.sessions.ping() + + async def close(self): + await self.sessions.aclose() + await self.pool.close() + + async def ready(self): + async with self.pool.connection() as conn: + await conn.execute("SELECT 1") + await self.sessions.ping() + + async def create_user(self, data): + async with self.kdf_slots: + encoded = await asyncio.to_thread(password_hash, data.password) + try: + async with self.pool.connection() as conn: + cur = await conn.execute( + "INSERT INTO users(id, username, display_name, password_hash) " + "VALUES (%s, %s, %s, %s) RETURNING " + USER_COLUMNS, + (uuid4(), data.username, data.display_name, encoded)) + result = public(await cur.fetchone()) + return result + except UniqueViolation: + raise APIError(409, "conflict", "Username is already taken") from None + + async def login(self, username, password): + async with self.pool.connection() as conn: + cur = await conn.execute("SELECT " + USER_COLUMNS + ", password_hash FROM users WHERE username=%s", + (username,)) + row = await cur.fetchone() + async with self.kdf_slots: + valid = await asyncio.to_thread(password_matches, password, + row["password_hash"] if row else self.dummy_hash) + if not valid or row is None: + raise unauthorized(basic=True) + row.pop("password_hash") + token = secrets.token_urlsafe(32) + expires_ms = int(datetime.now(timezone.utc).timestamp() * 1000) + self.settings.session_ttl * 1000 + await self.sessions.set(self.session_key(token), json.dumps( + {"user_id": str(row["id"]), "expires_ms": expires_ms}), pxat=expires_ms) + return {"token": token, "token_type": "Bearer", + "expires_at": stamp(datetime.fromtimestamp(expires_ms / 1000, timezone.utc)), + "user": public(row)} + + @staticmethod + def session_key(token): + return "session:" + hashlib.sha256(token.encode("ascii")).hexdigest() + + async def authenticate(self, header): + token = bearer(header) + value = await self.sessions.get(self.session_key(token)) + if value is None: + raise unauthorized() + session = json.loads(value) + if session["expires_ms"] <= int(datetime.now(timezone.utc).timestamp() * 1000): + raise unauthorized() + async with self.pool.connection() as conn: + cur = await conn.execute("SELECT " + USER_COLUMNS + " FROM users WHERE id=%s", + (UUID(session["user_id"]),)) + row = await cur.fetchone() + if row is None: + raise unauthorized() + return public(row), token + + async def logout(self, token): + await self.sessions.delete(self.session_key(token)) + + async def create_chat(self, actor, data): + if actor not in data.member_ids: + raise invalid("Members must include the current user") + try: + async with self.pool.connection() as conn: + cur = await conn.execute("INSERT INTO chats(id, title) VALUES (%s, %s) " + "RETURNING id, title, created_at", (uuid4(), data.title)) + row = await cur.fetchone() + async with conn.cursor() as cur: + await cur.executemany("INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)", + [(row["id"], UUID(member)) for member in data.member_ids]) + result = public(row) + result["member_ids"] = sorted(data.member_ids) + return result + except ForeignKeyViolation: + raise invalid("All members must exist") from None + + async def accessible_chat(self, conn, actor, chat_id): + cur = await conn.execute("""SELECT c.id, c.title, c.created_at FROM chats c + JOIN chat_members m ON m.chat_id=c.id + WHERE c.id=%s AND m.user_id=%s""", (chat_id, UUID(actor))) + row = await cur.fetchone() + if row is None: + raise APIError(404, "not_found", "Chat not found") + return row + + async def get_chat(self, actor, chat_id): + async with self.pool.connection() as conn: + row = await self.accessible_chat(conn, actor, chat_id) + cur = await conn.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (chat_id,)) + result = public(row) + result["member_ids"] = [str(x["user_id"]) for x in await cur.fetchall()] + return result + + async def create_message(self, actor, chat_id, data): + async with self.pool.connection() as conn: + await self.accessible_chat(conn, actor, chat_id) + # Evaluate clock_timestamp AFTER obtaining the per-chat lock. + await conn.execute("SELECT id FROM chats WHERE id=%s FOR UPDATE", (chat_id,)) + cur = await conn.execute("""UPDATE chats SET last_message_at= + greatest(clock_timestamp(), last_message_at + interval '1 microsecond') + WHERE id=%s RETURNING last_message_at""", (chat_id,)) + created_at = (await cur.fetchone())["last_message_at"] + cur = await conn.execute("INSERT INTO messages(id, chat_id, sender_id, text, created_at) " + "VALUES (%s, %s, %s, %s, %s) RETURNING " + MESSAGE_COLUMNS, + (uuid4(), chat_id, UUID(actor), data.text, created_at)) + result = public(await cur.fetchone()) + return result + + def page(self, rows, scope, limit): + items = rows[:limit] + return {"items": items, "next_cursor": self.cursors.encode(scope, items[-1]) + if len(rows) > limit else None} + + async def list_messages(self, actor, chat_id, limit, cursor): + scope = "messages:" + str(chat_id) + boundary = self.cursors.decode(scope, cursor) if cursor is not None else None + async with self.pool.connection() as conn: + await self.accessible_chat(conn, actor, chat_id) + query = "SELECT " + MESSAGE_COLUMNS + " FROM messages WHERE chat_id=%s" + params = [chat_id] + if boundary: + query += " AND (created_at, id) > (%s, %s)" + params.extend(boundary) + query += " ORDER BY created_at, id LIMIT %s" + params.append(limit + 1) + cur = await conn.execute(query, params) + rows = [public(row) for row in await cur.fetchall()] + return self.page(rows, scope, limit) + + async def list_chats(self, actor, limit, cursor): + scope = "chats:" + actor + boundary = self.cursors.decode(scope, cursor) if cursor is not None else None + query = """SELECT c.id, c.title, c.created_at FROM chats c + JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s""" + params = [UUID(actor)] + if boundary: + query += " AND (c.created_at, c.id) > (%s, %s)" + params.extend(boundary) + query += " ORDER BY c.created_at, c.id LIMIT %s" + params.append(limit + 1) + async with self.pool.connection() as conn: + cur = await conn.execute(query, params) + rows = [public(row) for row in await cur.fetchall()] + if rows: + ids = [UUID(row["id"]) for row in rows] + cur = await conn.execute("SELECT chat_id, user_id FROM chat_members WHERE chat_id=ANY(%s) ORDER BY user_id", + (ids,)) + members = {row["id"]: [] for row in rows} + for member in await cur.fetchall(): + members[str(member["chat_id"])].append(str(member["user_id"])) + for row in rows: + row["member_ids"] = members[row["id"]] + return self.page(rows, scope, limit) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..56acec2e --- /dev/null +++ b/compose.yaml @@ -0,0 +1,118 @@ +name: mtusi-lab2 + +x-app: &app + image: mtusi-messenger:lab2 + build: + context: . + target: runtime + environment: &environment + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: redis + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + CURSOR_KEY_FILE: /run/secrets/cursor_key + secrets: + - database_url + - cache_url + - cursor_key + +services: + postgres: + image: postgres:17.6-bookworm + environment: + POSTGRES_USER: messenger + POSTGRES_DB: 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: 2s + retries: 20 + cpus: 1.0 + mem_limit: 512m + stop_grace_period: 10s + + redis: + image: redis:7.4.5-bookworm + command: + - sh + - -ec + - 'exec redis-server /usr/local/etc/redis/redis.conf --requirepass "$$(cat /run/secrets/redis_password)"' + secrets: + - redis_password + volumes: + - redis_data:/data + - ./infra/redis.conf:/usr/local/etc/redis/redis.conf:ro + healthcheck: + test: [CMD-SHELL, 'REDISCLI_AUTH="$$(cat /run/secrets/redis_password)" redis-cli ping | grep -q PONG'] + interval: 3s + timeout: 2s + retries: 20 + cpus: 0.5 + mem_limit: 192m + stop_grace_period: 10s + + migrate: + <<: *app + command: [python, -m, app.migrate] + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api: + <<: *app + depends_on: + migrate: + condition: service_completed_successfully + redis: + condition: service_healthy + ports: + - "127.0.0.1:${API_PORT:-8080}:8080" + cpus: 1.0 + mem_limit: 256m + stop_grace_period: 8s + + checks: + profiles: [tools] + image: mtusi-messenger:lab2-checks + build: + context: . + target: checks + environment: + <<: *environment + BASE_URL: http://api:8080 + COMPOSE_PROJECT_NAME: ${COMPOSE_PROJECT_NAME:-mtusi-lab2} + CHECKS_PROJECT_DIR: /checks + secrets: + - database_url + - cache_url + - cursor_key + volumes: + - .:/checks + - /var/run/docker.sock:/var/run/docker.sock + cpus: 1.0 + mem_limit: 256m + +volumes: + postgres_data: + redis_data: + +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 + cursor_key: + file: ./secrets/cursor_key diff --git a/docs/DATABASE.md b/docs/DATABASE.md new file mode 100644 index 00000000..f99c7146 --- /dev/null +++ b/docs/DATABASE.md @@ -0,0 +1,33 @@ +# Хранение и транзакции + +Схема спроектирована для одного локального стенда: API → PostgreSQL для бизнес-данных; API → Redis для сессий. PostgreSQL и Redis — независимые источники истины для своих данных. История сообщений не кэшируется. + +## Таблицы PostgreSQL + +| Таблица | Назначение и ограничения | +| --- | --- | +| `schema_migrations` | Имя и SHA-256 применённой миграции; изменение уже применённого SQL запрещено | +| `users` | UUID PK, уникальный username, display_name, scrypt-хеш, время регистрации | +| `chats` | UUID PK, title, время создания, внутренняя последняя метка сообщения | +| `chat_members` | Составной PK `(chat_id, user_id)`, FK на чаты и пользователей | +| `messages` | UUID PK, chat_id, sender_id, text, created_at; составной FK `(chat_id, sender_id)` на членство | + +Индекс `chat_members(user_id, chat_id)` выбирает доступные чаты. Индекс `messages(chat_id, created_at, id)` обслуживает равенство по чату, диапазон после курсора и сортировку. Следующая страница использует `(created_at, id) > (%s, %s)` и `LIMIT limit + 1`, без OFFSET и загрузки всей истории. Приложение запрашивает только нужную страницу. + +## Границы транзакций + +- Регистрация: один INSERT, уникальность обеспечивается БД, проигравшая конкурентная запись получает 409. +- Создание чата: INSERT чата и всех участников в одной транзакции. Неизвестный участник нарушает FK; вся операция откатывается, включая уже вставленный чат. +- Отправка: блокировка строки чата, проверка членства, назначение метки времени, обновление метки и INSERT сообщения в одной транзакции. COMMIT заканчивается до HTTP 201. Составной FK дополнительно запрещает сообщение неучастника. +- Чтение: READ COMMITTED. Между HTTP-страницами snapshot отсутствует. В одном чате запись сериализуется блокировкой строки: `max(clock_timestamp(), last_message_at + 1 microsecond)` сохраняет возрастающий порядок даже при совпадении времени или откате часов. Соседние чаты не делят эту блокировку. При откате часов логическое время может опережать часы. Параллельно создаваемые чаты сортируются по назначенному времени; общий snapshot их списка не обещается. +- Миграции: advisory lock, проверка контрольной суммы, SQL и регистрация версии в одной транзакции. Для checksum окончания строк приводятся к LF, поэтому checkout Windows не меняет версию миграции. Повторный запуск ничего не вставляет. Миграция запускается отдельным одноразовым сервисом до API. + +## Сессии Redis + +Клиент получает 32 случайных байта в URL-safe base64. Ключ Redis — `session:`, значение — UUID пользователя и абсолютное `expires_at`; исходный токен на сервере не сохраняется. `SET ... PXAT` назначает срок в момент создания, чтение его не продлевает. API дополнительно проверяет абсолютную дату. Logout удаляет ключ до ответа 204. При отказе Redis защищённый запрос получает 503, вход по X-User-Id или локальному запасному словарю отсутствует. + +Redis использует именованный volume, AOF, `appendfsync always` и `maxmemory-policy noeviction`. Обычный рестарт и аварийное завершение Redis проверяются отдельно. Потеря/удаление volume не покрывается; PostgreSQL не содержит резервной копии сессий. Потеря любого источника истины делает readiness равным 503; liveness остаётся 200. + +## Пределы ожидания + +PostgreSQL: pool 1–10 соединений, очередь максимум 20, ожидание pool 1 s, connect 2 s, SQL 2 s, блокировка 1 s, TCP keepalive/TCP_USER_TIMEOUT. Redis: максимум 10 соединений, connect/read 1 s, без повторов команды. Общий бюджет HTTP-обработки 5 s. KDF выполняется вне event loop, не более четырёх параллельных вычислений. Секреты читаются из локальных файлов; в логах нет SQL, DSN, паролей, токенов и текстов сообщений. diff --git a/docs/DEFENSE.md b/docs/DEFENSE.md new file mode 100644 index 00000000..963accc2 --- /dev/null +++ b/docs/DEFENSE.md @@ -0,0 +1,52 @@ +# Защита лабораторной 2 + +Целевая оценка — 4. Основа первой работы сохранена: пользователи, чаты, участники, сообщения, проверки доступа и cursor-пагинация. Изменилось хранение и подтверждение личности. + +## Суть решения за минуту + +В первой работе всё лежало в RAM одного процесса и исчезало после рестарта. Теперь бизнес-данные хранятся в PostgreSQL на именованном volume. Redis хранит серверные сессии с TTL и AOF. Регистрация принимает пароль, scrypt сохраняет его хеш. Вход с Basic выдаёт случайный Bearer-токен. По токену сервер находит пользователя, затем отдельно проверяет его участие в чате. + +## Демонстрация + +Из папки проекта: + +```powershell +python scripts/init_local.py +docker compose --env-file .env up -d --build --wait +docker compose --env-file .env build checks +python scripts/verify.py --skip-build +``` + +Команда проверки создаёт только синтетические данные. Она временно останавливает хранилища этого Compose-проекта, восстанавливает их и оставляет основной стенд запущенным. Её выполняют на учебном стенде. + +1. Открыть `docs/DATABASE.md`: показать таблицы, FK, уникальный username и транзакцию создания чата. +2. Открыть `evidence/smoke.txt` и `evidence/student-tests.txt`: публичный сценарий, гонка регистрации, rollback, 100 сообщений из 10 клиентов. +3. Открыть `scripts/restart.sh`, `evidence/persistence.txt`, `evidence/restart.json`: перезапущены API, PostgreSQL и Redis; `StartedAt` изменился у всех трёх, имена volumes сохранились. Публичный тест использовал старый токен без повторного входа. +4. Показать `infra/redis.conf`: `appendonly yes`, `appendfsync always`. В тесте Redis выдерживает также SIGKILL; срок сессии не продлевается. +5. Показать `evidence/expiry.json`: отдельный API с TTL=2 возвращает 200 сразу и 401 после 2.3 s. Logout и неверный пароль покрыты интеграционными тестами. +6. Показать `evidence/failures.json`: readiness и защищённый запрос дают 503 при отказе каждого хранилища; liveness остаётся 200, X-User-Id не даёт доступ. +7. Показать `evidence/explain.txt`: 10 000 сообщений, индекс истории, начало/середина/конец. SQL читает 51 строку, API отдаёт 50 и формирует следующий cursor. + +## Что понимать в коде + +`app/api.py` обрабатывает HTTP, аутентификацию, валидацию, request ID и ошибки. `app/store.py` выполняет SQL и операции Redis. `app/security.py` содержит KDF, разбор Basic/Bearer и подпись курсоров. `app/migrate.py` применяет миграции; `migrations/001_initial.sql` задаёт схему. + +- **COMMIT:** операция PostgreSQL завершена до HTTP 201. В стенде включены `synchronous_commit` и `fsync`; потеря самого диска или volume этим не покрывается. +- **Образ, контейнер, volume:** образ содержит код, контейнер запускает процесс, volume хранит данные независимо от жизни контейнера. `down` сохраняет volumes, `down --volumes` удаляет учебные данные. +- **Сессии:** Redis — источник истины для них. TTL отвечает за время жизни, AOF — за восстановление после рестарта. Flush/удаление volume уничтожит сессии; одного TTL недостаточно. +- **Basic и Bearer:** Basic передаёт username:password в base64 при входе. Bearer — случайный ключ действующей серверной сессии для остальных запросов. Base64 не шифрует пароль. +- **Аутентификация и доступ:** действительная сессия определяет пользователя, членство определяет доступ к конкретному чату. Чужой чат возвращает 404. +- **Хеш пароля:** scrypt использует соль и затраты CPU/RAM. SHA-256 токена допустим для уже случайного 256-битного значения, но быстрый SHA-256 не заменяет password KDF. +- **Гонка username:** проверка SELECT перед INSERT не гарантирует уникальность. Нужен UNIQUE в PostgreSQL; проигравший INSERT превращается в 409. +- **Rollback:** INSERT чата и участников выполняются вместе. Ошибка второго участника отменяет первый INSERT, что проверяется прямым подсчётом строк. +- **Keyset:** cursor хранит подписанную границу `(created_at, id)` и область чата. B-tree сразу переходит к нужному диапазону. OFFSET заставил бы пропускать предыдущие строки. +- **Конкурентная история:** блокировка одной строки чата упорядочивает записи этого чата; разные чаты пишут независимо. Между страницами общего snapshot нет. +- **Отказы:** ошибка зависимости даёт ограниченный 503, а не анонимный вход. Один Docker-host и одиночные хранилища не дают высокой доступности. + +## Остановка после защиты + +```powershell +docker compose --env-file .env stop +# Повторный запуск с прежними данными: +docker compose --env-file .env up -d --wait +``` diff --git a/docs/SUBMISSION.md b/docs/SUBMISSION.md new file mode 100644 index 00000000..6a38225b --- /dev/null +++ b/docs/SUBMISSION.md @@ -0,0 +1,15 @@ +# Передача работы на площадку + +Рабочая папка — `mtusi2026lab2`. Исходное задание и публичные тесты оставлены в ней. Реализация и доказательства самодостаточны; соседняя первая лабораторная для запуска не нужна. + +Перед публикацией проверить список файлов: в него входят `app/`, `migrations/`, `compose.yaml`, `Dockerfile`, `infra/redis.conf`, `scripts/`, `student-tests/`, `docs/`, `REPORT.md`, `requirements.txt`, `.env.example` и текстовые результаты `evidence/`. Папка `secrets/` и файл `.env` локальные и исключены через `.gitignore`. Volumes находятся в Docker, в репозитории их нет. + +Копировать пароли и токены в описание PR не требуется. Файл `.github/pull_request_template.md` содержит готовое описание реализации и проверок. При переносе файлов в свой fork сохранить executable bit для `scripts/restart.sh`: + +```sh +git add . +git update-index --chmod=+x scripts/restart.sh +git diff --cached --stat +``` + +Адрес fork, удалённую ветку и PR оформить на Gitea отдельно. Отчёт содержит фактические локальные результаты, оценка выставляется преподавателем после проверки и защиты. diff --git a/evidence/README.md b/evidence/README.md index 8df70015..2a70c686 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -1,5 +1,5 @@ -# Доказательства - -Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. - -Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. +# Доказательства + +Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. + +Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. diff --git a/evidence/build.txt b/evidence/build.txt new file mode 100644 index 00000000..a4afe355 --- /dev/null +++ b/evidence/build.txt @@ -0,0 +1,58 @@ +#1 [internal] load local bake definitions +#1 reading from stdin 994B 0.1s done +#1 DONE 0.1s + +#2 [internal] load build definition from Dockerfile +#2 transferring dockerfile: 1.20kB done +#2 DONE 0.0s + +#3 [internal] load metadata for docker.io/library/python:3.13.15-slim-bookworm +#3 DONE 0.0s + +#4 [internal] load .dockerignore +#4 transferring context: 155B done +#4 DONE 0.0s + +#5 [runtime 1/7] FROM docker.io/library/python:3.13.15-slim-bookworm@sha256:ed86c82274b3c69b52fb5820f358f0bd7df0b603332063cb5c6e32bd220c3e6e +#5 resolve docker.io/library/python:3.13.15-slim-bookworm@sha256:ed86c82274b3c69b52fb5820f358f0bd7df0b603332063cb5c6e32bd220c3e6e 0.0s done +#5 DONE 0.0s + +#6 [internal] load build context +#6 transferring context: 144.46kB 0.0s done +#6 DONE 0.1s + +#7 [runtime 2/7] WORKDIR /app +#7 CACHED + +#8 [runtime 3/7] COPY requirements.txt . +#8 CACHED + +#9 [runtime 4/7] RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger +#9 CACHED + +#10 [runtime 5/7] COPY app ./app +#10 DONE 0.1s + +#11 [runtime 6/7] COPY migrations ./migrations +#11 DONE 0.1s + +#12 [runtime 7/7] COPY contracts/openapi.json ./contracts/openapi.json +#12 DONE 0.1s + +#13 exporting to image +#13 exporting layers +#13 exporting layers 0.2s done +#13 exporting manifest sha256:eabb6884a68e4d764d61d946a247e898543ffd0b0f83fadbffe9b0f51e402923 0.0s done +#13 exporting config sha256:b9bb26dbe47aeeaf9edf195d019c7fd878d2c385e9a8e49536df8b213b068991 0.0s done +#13 exporting attestation manifest sha256:69e5892af7011393aaa969ec7fc9c4b97b3daad4675ea8e646b3e405478b0db3 0.0s done +#13 exporting manifest list sha256:925ffec97353c6a6533ff61927bbce197e8b4a0ab26fe7e84c76d3ba3366a879 0.0s done +#13 naming to docker.io/library/mtusi-messenger:lab2 +#13 naming to docker.io/library/mtusi-messenger:lab2 done +#13 unpacking to docker.io/library/mtusi-messenger:lab2 +#13 unpacking to docker.io/library/mtusi-messenger:lab2 0.4s done +#13 DONE 0.7s + +#14 resolving provenance for metadata file +#14 DONE 0.0s + Image mtusi-messenger:lab2 Building + Image mtusi-messenger:lab2 Built diff --git a/evidence/clean-build.txt b/evidence/clean-build.txt new file mode 100644 index 00000000..fbc78050 --- /dev/null +++ b/evidence/clean-build.txt @@ -0,0 +1,221 @@ +#1 [internal] load local bake definitions +#1 reading from stdin 1.67kB 0.1s done +#1 DONE 0.1s + +#2 [api internal] load build definition from Dockerfile +#2 transferring dockerfile: 1.23kB done +#2 DONE 0.0s + +#3 [api internal] load metadata for docker.io/library/python:3.13.15-slim-bookworm +#3 DONE 0.0s + +#4 [checks internal] load metadata for docker.io/library/docker:28.5.1-cli +#4 DONE 0.1s + +#5 [api internal] load .dockerignore +#5 transferring context: 164B done +#5 DONE 0.0s + +#6 [api internal] load build context +#6 transferring context: 95.03kB 0.0s done +#6 transferring context: 95.03kB 0.0s done +#6 DONE 0.1s + +#7 [checks runtime 1/7] FROM docker.io/library/python:3.13.15-slim-bookworm@sha256:ed86c82274b3c69b52fb5820f358f0bd7df0b603332063cb5c6e32bd220c3e6e +#7 resolve docker.io/library/python:3.13.15-slim-bookworm@sha256:ed86c82274b3c69b52fb5820f358f0bd7df0b603332063cb5c6e32bd220c3e6e 0.1s done +#7 DONE 0.1s + +#8 [checks docker_cli 1/1] FROM docker.io/library/docker:28.5.1-cli@sha256:9190b0613792e658a7783cf14b2d5ace5941bb68ede7276922ea36ee457d76ad +#8 resolve docker.io/library/docker:28.5.1-cli@sha256:9190b0613792e658a7783cf14b2d5ace5941bb68ede7276922ea36ee457d76ad 0.1s done +#8 CACHED + +#9 [checks runtime 2/7] WORKDIR /app +#9 CACHED + +#10 [api runtime 3/7] COPY requirements.txt . +#10 DONE 0.1s + +#11 [checks runtime 4/7] RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger +#11 1.859 Ignoring colorama: markers 'sys_platform == "win32"' don't match your environment +#11 2.149 Collecting annotated-doc==0.0.5 (from -r requirements.txt (line 1)) +#11 7.503 Downloading annotated_doc-0.0.5-py3-none-any.whl.metadata (6.5 kB) +#11 7.565 Collecting annotated-types==0.8.0 (from -r requirements.txt (line 2)) +#11 7.622 Downloading annotated_types-0.8.0-py3-none-any.whl.metadata (15 kB) +#11 7.710 Collecting anyio==4.15.1 (from -r requirements.txt (line 3)) +#11 7.770 Downloading anyio-4.15.1-py3-none-any.whl.metadata (4.7 kB) +#11 7.847 Collecting click==8.5.0 (from -r requirements.txt (line 4)) +#11 7.899 Downloading click-8.5.0-py3-none-any.whl.metadata (2.6 kB) +#11 8.059 Collecting fastapi==0.141.1 (from -r requirements.txt (line 6)) +#11 8.109 Downloading fastapi-0.141.1-py3-none-any.whl.metadata (27 kB) +#11 8.195 Collecting h11==0.16.0 (from -r requirements.txt (line 7)) +#11 8.246 Downloading h11-0.16.0-py3-none-any.whl.metadata (8.3 kB) +#11 8.312 Collecting idna==3.20 (from -r requirements.txt (line 8)) +#11 8.363 Downloading idna-3.20-py3-none-any.whl.metadata (7.2 kB) +#11 8.594 Collecting pydantic==2.13.5 (from -r requirements.txt (line 9)) +#11 8.646 Downloading pydantic-2.13.5-py3-none-any.whl.metadata (110 kB) +#11 9.596 Collecting pydantic-core==2.46.5 (from -r requirements.txt (line 10)) +#11 9.647 Downloading pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB) +#11 9.717 Collecting starlette==1.6.0 (from -r requirements.txt (line 11)) +#11 9.769 Downloading starlette-1.6.0-py3-none-any.whl.metadata (6.4 kB) +#11 9.831 Collecting typing-extensions==4.16.0 (from -r requirements.txt (line 12)) +#11 9.882 Downloading typing_extensions-4.16.0-py3-none-any.whl.metadata (3.3 kB) +#11 9.939 Collecting typing-inspection==0.4.4 (from -r requirements.txt (line 13)) +#11 9.989 Downloading typing_inspection-0.4.4-py3-none-any.whl.metadata (2.6 kB) +#11 10.06 Collecting uvicorn==0.53.0 (from -r requirements.txt (line 14)) +#11 10.11 Downloading uvicorn-0.53.0-py3-none-any.whl.metadata (6.6 kB) +#11 10.17 Collecting psycopg==3.2.10 (from psycopg[binary]==3.2.10->-r requirements.txt (line 15)) +#11 10.22 Downloading psycopg-3.2.10-py3-none-any.whl.metadata (4.6 kB) +#11 10.29 Collecting psycopg-pool==3.2.6 (from -r requirements.txt (line 16)) +#11 10.35 Downloading psycopg_pool-3.2.6-py3-none-any.whl.metadata (2.6 kB) +#11 10.42 Collecting redis==6.4.0 (from -r requirements.txt (line 17)) +#11 10.47 Downloading redis-6.4.0-py3-none-any.whl.metadata (10 kB) +#11 10.72 Collecting psycopg-binary==3.2.10 (from psycopg[binary]==3.2.10->-r requirements.txt (line 15)) +#11 10.77 Downloading psycopg_binary-3.2.10-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (3.0 kB) +#11 10.82 Downloading annotated_doc-0.0.5-py3-none-any.whl (5.3 kB) +#11 10.88 Downloading annotated_types-0.8.0-py3-none-any.whl (13 kB) +#11 10.93 Downloading anyio-4.15.1-py3-none-any.whl (132 kB) +#11 11.02 Downloading click-8.5.0-py3-none-any.whl (125 kB) +#11 11.09 Downloading fastapi-0.141.1-py3-none-any.whl (131 kB) +#11 11.16 Downloading h11-0.16.0-py3-none-any.whl (37 kB) +#11 11.22 Downloading idna-3.20-py3-none-any.whl (69 kB) +#11 11.28 Downloading pydantic-2.13.5-py3-none-any.whl (472 kB) +#11 11.40 Downloading pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.1 MB) +#11 11.53 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2.1/2.1 MB 17.4 MB/s 0:00:00 +#11 11.58 Downloading starlette-1.6.0-py3-none-any.whl (75 kB) +#11 11.63 Downloading typing_extensions-4.16.0-py3-none-any.whl (45 kB) +#11 11.69 Downloading typing_inspection-0.4.4-py3-none-any.whl (14 kB) +#11 11.74 Downloading uvicorn-0.53.0-py3-none-any.whl (87 kB) +#11 11.80 Downloading psycopg-3.2.10-py3-none-any.whl (206 kB) +#11 11.86 Downloading psycopg_pool-3.2.6-py3-none-any.whl (38 kB) +#11 11.91 Downloading redis-6.4.0-py3-none-any.whl (279 kB) +#11 12.00 Downloading psycopg_binary-3.2.10-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (4.4 MB) +#11 12.16 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.4/4.4 MB 27.5 MB/s 0:00:00 +#11 12.31 Installing collected packages: typing-extensions, redis, psycopg-binary, psycopg, idna, h11, click, annotated-types, annotated-doc, uvicorn, typing-inspection, pydantic-core, psycopg-pool, anyio, starlette, pydantic, fastapi +#11 13.78 +#11 13.78 Successfully installed annotated-doc-0.0.5 annotated-types-0.8.0 anyio-4.15.1 click-8.5.0 fastapi-0.141.1 h11-0.16.0 idna-3.20 psycopg-3.2.10 psycopg-binary-3.2.10 psycopg-pool-3.2.6 pydantic-2.13.5 pydantic-core-2.46.5 redis-6.4.0 starlette-1.6.0 typing-extensions-4.16.0 typing-inspection-0.4.4 uvicorn-0.53.0 +#11 13.78 WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning. +#11 13.78 +#11 13.78 [notice] A new release of pip is available: 26.2.1 -> 26.2.2 +#11 13.78 [notice] To update, run: pip install --upgrade pip +#11 DONE 15.2s + +#11 [api runtime 4/7] RUN pip install --no-cache-dir -r requirements.txt && useradd --uid 10001 --create-home messenger +#11 DONE 15.2s + +#12 [api runtime 5/7] COPY app ./app +#12 DONE 0.1s + +#12 [checks runtime 5/7] COPY app ./app +#12 DONE 0.1s + +#13 [api runtime 6/7] COPY migrations ./migrations +#13 DONE 0.1s + +#13 [checks runtime 6/7] COPY migrations ./migrations +#13 DONE 0.1s + +#14 [checks runtime 7/7] COPY contracts/openapi.json ./contracts/openapi.json +#14 DONE 0.1s + +#14 [api runtime 7/7] COPY contracts/openapi.json ./contracts/openapi.json +#14 DONE 0.1s + +#15 [api] exporting to image +#15 exporting layers +#15 ... + +#16 [checks checks 1/4] COPY --from=docker_cli /usr/local/bin/docker /usr/local/bin/docker +#16 DONE 0.7s + +#17 [checks checks 2/4] COPY --from=docker_cli /usr/local/libexec/docker/cli-plugins/docker-compose /usr/local/libexec/docker/cli-plugins/docker-compose +#17 DONE 0.4s + +#15 [api] exporting to image +#15 exporting layers 1.9s done +#15 exporting manifest sha256:88629bd895cdfe4491719cd197009564003e40c7cc2bfb55a17ac03ddf0a6b5b 0.0s done +#15 exporting config sha256:469b05afaf80badba696a75e674adf0714ffc38f07a869cc88a5dcb17990d33d 0.0s done +#15 exporting attestation manifest sha256:f202ed4c417fa9a384abaf2228985367c07dff7c1d0a71bfb9ea9e3e93e7a2ac 0.0s done +#15 exporting manifest list sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d 0.0s done +#15 naming to docker.io/library/mtusi-messenger:lab2 done +#15 unpacking to docker.io/library/mtusi-messenger:lab2 +#15 unpacking to docker.io/library/mtusi-messenger:lab2 0.4s done +#15 DONE 2.4s + +#18 [checks checks 3/4] RUN apt-get update && apt-get install -y --no-install-recommends make && rm -rf /var/lib/apt/lists/* +#18 0.680 Get:1 http://deb.debian.org/debian bookworm InRelease [151 kB] +#18 0.922 Get:2 http://deb.debian.org/debian bookworm-updates InRelease [55.4 kB] +#18 1.154 Get:3 http://deb.debian.org/debian-security bookworm-security InRelease [34.8 kB] +#18 ... + +#19 [api] resolving provenance for metadata file +#19 DONE 0.0s + +#18 [checks checks 3/4] RUN apt-get update && apt-get install -y --no-install-recommends make && rm -rf /var/lib/apt/lists/* +#18 1.704 Get:4 http://deb.debian.org/debian bookworm/main amd64 Packages [8790 kB] +#18 2.174 Get:5 http://deb.debian.org/debian bookworm-updates/main amd64 Packages [6924 B] +#18 2.500 Get:6 http://deb.debian.org/debian-security bookworm-security/main amd64 Packages [359 kB] +#18 2.917 Fetched 9398 kB in 3s (3541 kB/s) +#18 2.917 Reading package lists... +#18 3.394 Reading package lists... +#18 3.847 Building dependency tree... +#18 3.985 Reading state information... +#18 4.133 Suggested packages: +#18 4.133 make-doc +#18 4.160 The following NEW packages will be installed: +#18 4.160 make +#18 4.506 0 upgraded, 1 newly installed, 0 to remove and 7 not upgraded. +#18 4.506 Need to get 396 kB of archives. +#18 4.506 After this operation, 1630 kB of additional disk space will be used. +#18 4.506 Get:1 http://deb.debian.org/debian bookworm/main amd64 make amd64 4.3-4.1 [396 kB] +#18 4.624 debconf: delaying package configuration, since apt-utils is not installed +#18 4.652 Fetched 396 kB in 0s (1129 kB/s) +#18 4.680 Selecting previously unselected package make. +#18 4.680 (Reading database ... +(Reading database ... 5% +(Reading database ... 10% +(Reading database ... 15% +(Reading database ... 20% +(Reading database ... 25% +(Reading database ... 30% +(Reading database ... 35% +(Reading database ... 40% +(Reading database ... 45% +(Reading database ... 50% +(Reading database ... 55% +(Reading database ... 60% +(Reading database ... 65% +(Reading database ... 70% +(Reading database ... 75% +(Reading database ... 80% +(Reading database ... 85% +(Reading database ... 90% +(Reading database ... 95% +(Reading database ... 100% +(Reading database ... 6647 files and directories currently installed.) +#18 4.683 Preparing to unpack .../make_4.3-4.1_amd64.deb ... +#18 4.689 Unpacking make (4.3-4.1) ... +#18 4.773 Setting up make (4.3-4.1) ... +#18 DONE 6.3s + +#20 [checks checks 4/4] WORKDIR /checks +#20 DONE 0.1s + +#21 [checks] exporting to image +#21 exporting layers +#21 exporting layers 2.9s done +#21 exporting manifest sha256:49d6d008bb2c3cb03b97fe58083398e88721321a85a9aa84c8ea336b20c44762 0.0s done +#21 exporting config sha256:ddb92bb96530abdc7d8ec600f3cec2e343316c4264847262460e1821895ee1ab 0.0s done +#21 exporting attestation manifest sha256:697058f72f4a5bda4c65bbec5924e1f324bda75c8a159347ae5a8346cb153291 0.0s done +#21 exporting manifest list sha256:191de4b93466a8945a8e8653f764d4473d9ab919c8b925c86b902b7df5d9da7e 0.0s done +#21 naming to docker.io/library/mtusi-messenger:lab2-checks +#21 naming to docker.io/library/mtusi-messenger:lab2-checks done +#21 unpacking to docker.io/library/mtusi-messenger:lab2-checks +#21 unpacking to docker.io/library/mtusi-messenger:lab2-checks 0.7s done +#21 DONE 3.8s + +#22 [checks] resolving provenance for metadata file +#22 DONE 0.0s + Image mtusi-messenger:lab2-checks Building + Image mtusi-messenger:lab2 Building + Image mtusi-messenger:lab2-checks Built + Image mtusi-messenger:lab2 Built diff --git a/evidence/clean-expiry.json b/evidence/clean-expiry.json new file mode 100644 index 00000000..1ed76edd --- /dev/null +++ b/evidence/clean-expiry.json @@ -0,0 +1,7 @@ +{ + "session_ttl_seconds": 2, + "wait_seconds": 2.3, + "before_expiry_status": 200, + "after_expiry_status": 401, + "result": "PASS" +} diff --git a/evidence/clean-explain.txt b/evidence/clean-explain.txt new file mode 100644 index 00000000..9dde520b --- /dev/null +++ b/evidence/clean-explain.txt @@ -0,0 +1,29 @@ +FIRST +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s ORDER BY created_at, id LIMIT %s +Limit (cost=0.29..4.29 rows=51 width=70) (actual time=0.010..0.023 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..786.29 rows=10000 width=70) (actual time=0.010..0.019 rows=51 loops=1) + Index Cond: (chat_id = 'e430ecd3-d167-42cf-923e-9d8864aa454a'::uuid) + Buffers: shared hit=4 +Planning Time: 0.057 ms +Execution Time: 0.032 ms + +MIDDLE +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s +Limit (cost=0.29..5.65 rows=51 width=70) (actual time=0.013..0.022 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..520.50 rows=4945 width=70) (actual time=0.012..0.019 rows=51 loops=1) + Index Cond: ((chat_id = 'e430ecd3-d167-42cf-923e-9d8864aa454a'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:47:47.309662+00'::timestamp with time zone, '09540584-a18b-4d60-8a4d-6090097999ba'::uuid))) + Buffers: shared hit=4 +Planning Time: 0.055 ms +Execution Time: 0.033 ms + +LATE +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s +Limit (cost=0.29..70.42 rows=51 width=70) (actual time=0.017..0.027 rows=51 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..135.06 rows=98 width=70) (actual time=0.017..0.023 rows=51 loops=1) + Index Cond: ((chat_id = 'e430ecd3-d167-42cf-923e-9d8864aa454a'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:47:47.314562+00'::timestamp with time zone, '6a60bce1-7a0f-45d3-9836-95b9d7797e39'::uuid))) + Buffers: shared hit=3 +Planning Time: 0.072 ms +Execution Time: 0.041 ms diff --git a/evidence/clean-failures.json b/evidence/clean-failures.json new file mode 100644 index 00000000..b18543d0 --- /dev/null +++ b/evidence/clean-failures.json @@ -0,0 +1,14 @@ +{ + "redis": { + "ready_status": 503, + "protected_status": 503, + "elapsed_seconds": 2.002, + "anonymous_status": 401 + }, + "postgres": { + "ready_status": 503, + "protected_status": 503, + "elapsed_seconds": 1.004, + "anonymous_status": 401 + } +} diff --git a/evidence/clean-persistence.txt b/evidence/clean-persistence.txt new file mode 100644 index 00000000..9941997d --- /dev/null +++ b/evidence/clean-persistence.txt @@ -0,0 +1,5 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://api:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. + Container mtusi-lab2-clean-v2-checks-run-75cfed86c889 Creating + Container mtusi-lab2-clean-v2-checks-run-75cfed86c889 Created diff --git a/evidence/clean-published-smoke.txt b/evidence/clean-published-smoke.txt new file mode 100644 index 00000000..4d4c5535 --- /dev/null +++ b/evidence/clean-published-smoke.txt @@ -0,0 +1 @@ +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/clean-restart.json b/evidence/clean-restart.json new file mode 100644 index 00000000..4842c841 --- /dev/null +++ b/evidence/clean-restart.json @@ -0,0 +1,68 @@ +{ + "before": { + "api": { + "id": "c999209e71f1e05cf73dd96ed6a8d332f1d7bdb81961b3fdf44656c54207ddb3", + "started_at": "2026-10-30T21:46:56.799081876Z", + "image_id": "sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d", + "user": "messenger", + "volumes": [], + "memory_limit_bytes": 268435456, + "nano_cpus": 1000000000 + }, + "postgres": { + "id": "921d8a5c2d722009d9946de24218aad6ca7ab83dcb1b5e3291793830bf7dfd0b", + "started_at": "2026-10-30T21:47:18.268247786Z", + "image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3", + "user": "", + "volumes": [ + "mtusi-lab2-clean-v2_postgres_data" + ], + "memory_limit_bytes": 536870912, + "nano_cpus": 1000000000 + }, + "redis": { + "id": "eee46ebafd47d00f403ef05b6630ce26559ffcb81f33414f2d08712149a3100d", + "started_at": "2026-10-30T21:47:21.369108706Z", + "image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb", + "user": "", + "volumes": [ + "mtusi-lab2-clean-v2_redis_data" + ], + "memory_limit_bytes": 201326592, + "nano_cpus": 500000000 + } + }, + "after": { + "api": { + "id": "c999209e71f1e05cf73dd96ed6a8d332f1d7bdb81961b3fdf44656c54207ddb3", + "started_at": "2026-10-30T21:47:30.173918792Z", + "image_id": "sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d", + "user": "messenger", + "volumes": [], + "memory_limit_bytes": 268435456, + "nano_cpus": 1000000000 + }, + "postgres": { + "id": "921d8a5c2d722009d9946de24218aad6ca7ab83dcb1b5e3291793830bf7dfd0b", + "started_at": "2026-10-30T21:47:30.087996017Z", + "image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3", + "user": "", + "volumes": [ + "mtusi-lab2-clean-v2_postgres_data" + ], + "memory_limit_bytes": 536870912, + "nano_cpus": 1000000000 + }, + "redis": { + "id": "eee46ebafd47d00f403ef05b6630ce26559ffcb81f33414f2d08712149a3100d", + "started_at": "2026-10-30T21:47:29.894086274Z", + "image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb", + "user": "", + "volumes": [ + "mtusi-lab2-clean-v2_redis_data" + ], + "memory_limit_bytes": 201326592, + "nano_cpus": 500000000 + } + } +} diff --git a/evidence/clean-source.json b/evidence/clean-source.json new file mode 100644 index 00000000..ac901c6c --- /dev/null +++ b/evidence/clean-source.json @@ -0,0 +1,18 @@ +{ + "commit": "3b65e93a4996f5093315ff935ccbd8ec53cddeb5", + "status_before": "", + "secrets_present_before": false, + "project": "mtusi-lab2-clean-v2", + "published_port": 18082, + "build_no_cache": true, + "sql_checkout_lf": true, + "result": "PASS", + "independent_secrets": true, + "restart_services": [ + "api", + "postgres", + "redis" + ], + "public_smoke_through_published_port": "PASS", + "source_clone": "local git clone --no-local" +} diff --git a/evidence/clean-startup.txt b/evidence/clean-startup.txt new file mode 100644 index 00000000..952a72a9 --- /dev/null +++ b/evidence/clean-startup.txt @@ -0,0 +1,42 @@ + Network mtusi-lab2-clean-v2_default Creating + Network mtusi-lab2-clean-v2_default Creating + Volume mtusi-lab2-clean-v2_redis_data Creating + Volume mtusi-lab2-clean-v2_redis_data Creating + Volume mtusi-lab2-clean-v2_postgres_data Creating + Volume mtusi-lab2-clean-v2_postgres_data Creating + Volume mtusi-lab2-clean-v2_postgres_data Created + Volume mtusi-lab2-clean-v2_postgres_data Created + Volume mtusi-lab2-clean-v2_redis_data Created + Volume mtusi-lab2-clean-v2_redis_data Created + Network mtusi-lab2-clean-v2_default Created + Network mtusi-lab2-clean-v2_default Created + Container mtusi-lab2-clean-v2-redis-1 Creating + Container mtusi-lab2-clean-v2-postgres-1 Creating + Container mtusi-lab2-clean-v2-redis-1 Created + Container mtusi-lab2-clean-v2-postgres-1 Created + Container mtusi-lab2-clean-v2-migrate-1 Creating + Container mtusi-lab2-clean-v2-migrate-1 Created + Container mtusi-lab2-clean-v2-api-1 Creating + Container mtusi-lab2-clean-v2-api-1 Created + Container mtusi-lab2-clean-v2-redis-1 Starting + Container mtusi-lab2-clean-v2-postgres-1 Starting + Container mtusi-lab2-clean-v2-redis-1 Started + Container mtusi-lab2-clean-v2-postgres-1 Started + Container mtusi-lab2-clean-v2-postgres-1 Waiting + Container mtusi-lab2-clean-v2-postgres-1 Healthy + Container mtusi-lab2-clean-v2-migrate-1 Starting + Container mtusi-lab2-clean-v2-migrate-1 Started + Container mtusi-lab2-clean-v2-migrate-1 Waiting + Container mtusi-lab2-clean-v2-redis-1 Waiting + Container mtusi-lab2-clean-v2-redis-1 Healthy + Container mtusi-lab2-clean-v2-migrate-1 Exited + Container mtusi-lab2-clean-v2-api-1 Starting + Container mtusi-lab2-clean-v2-api-1 Started + Container mtusi-lab2-clean-v2-api-1 Waiting + Container mtusi-lab2-clean-v2-postgres-1 Waiting + Container mtusi-lab2-clean-v2-redis-1 Waiting + Container mtusi-lab2-clean-v2-migrate-1 Waiting + Container mtusi-lab2-clean-v2-migrate-1 Exited + Container mtusi-lab2-clean-v2-redis-1 Healthy + Container mtusi-lab2-clean-v2-postgres-1 Healthy + Container mtusi-lab2-clean-v2-api-1 Healthy diff --git a/evidence/clean-student-tests.txt b/evidence/clean-student-tests.txt new file mode 100644 index 00000000..23077c85 --- /dev/null +++ b/evidence/clean-student-tests.txt @@ -0,0 +1,21 @@ +python3 -m unittest discover -s student-tests -v +ROLLBACK: invalid second member left no chat or membership rows +CONCURRENCY: 10 clients, 100 confirmations, 100 unique messages +FAILURES: Redis/PostgreSQL -> bounded 503, live 200, anonymous 401, recovery with old session +REDIS CRASH: old session survived SIGKILL/AOF replay, expiry deadline unchanged +RACE: 10 requests, 1 created, 9 conflicts, 1 database row + Container mtusi-lab2-clean-v2-checks-run-05a68e33bccb Creating + Container mtusi-lab2-clean-v2-checks-run-05a68e33bccb Created +test_composite_chat_rollback (test_api.APITests.test_composite_chat_rollback) ... ok +test_concurrent_messages (test_api.APITests.test_concurrent_messages) ... ok +test_cursor_binding_and_chat_pages (test_api.APITests.test_cursor_binding_and_chat_pages) ... ok +test_dependency_failures (test_api.APITests.test_dependency_failures) ... ok +test_passwords_and_authentication (test_api.APITests.test_passwords_and_authentication) ... ok +test_redis_crash_durability (test_api.APITests.test_redis_crash_durability) ... ok +test_registration_race (test_api.APITests.test_registration_race) ... ok +test_validation_and_access (test_api.APITests.test_validation_and_access) ... ok + +---------------------------------------------------------------------- +Ran 8 tests in 12.384s + +OK diff --git a/evidence/clean-verification.json b/evidence/clean-verification.json new file mode 100644 index 00000000..3a6b0c01 --- /dev/null +++ b/evidence/clean-verification.json @@ -0,0 +1,61 @@ +{ + "result": "PASS", + "utc": "2026-10-30T21:47:57.331317+00:00", + "checks": [ + "contract", + "public_smoke", + "8_student_tests", + "all_stores_restart", + "short_expiry", + "explain_10000", + "migration_replay", + "final_smoke" + ], + "versions": { + "python": "3.13.15", + "packages": { + "fastapi": "0.141.1", + "pydantic": "2.13.5", + "uvicorn": "0.53.0", + "psycopg": "3.2.10", + "psycopg-pool": "3.2.6", + "redis": "6.4.0" + } + }, + "migration_counts_before": "27|12|10113", + "migration_counts_after": "27|12|10113", + "deployment": { + "api": { + "id": "c999209e71f1e05cf73dd96ed6a8d332f1d7bdb81961b3fdf44656c54207ddb3", + "started_at": "2026-10-30T21:47:30.173918792Z", + "image_id": "sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d", + "user": "messenger", + "volumes": [], + "memory_limit_bytes": 268435456, + "nano_cpus": 1000000000 + }, + "postgres": { + "id": "921d8a5c2d722009d9946de24218aad6ca7ab83dcb1b5e3291793830bf7dfd0b", + "started_at": "2026-10-30T21:47:30.087996017Z", + "image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3", + "user": "", + "volumes": [ + "mtusi-lab2-clean-v2_postgres_data" + ], + "memory_limit_bytes": 536870912, + "nano_cpus": 1000000000 + }, + "redis": { + "id": "eee46ebafd47d00f403ef05b6630ce26559ffcb81f33414f2d08712149a3100d", + "started_at": "2026-10-30T21:47:29.894086274Z", + "image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb", + "user": "", + "volumes": [ + "mtusi-lab2-clean-v2_redis_data" + ], + "memory_limit_bytes": 201326592, + "nano_cpus": 500000000 + } + }, + "published_base_url": "http://127.0.0.1:18082" +} diff --git a/evidence/contract-check.txt b/evidence/contract-check.txt new file mode 100644 index 00000000..374ce235 --- /dev/null +++ b/evidence/contract-check.txt @@ -0,0 +1,4 @@ +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. + Container mtusi-lab2-checks-run-b4e1706cc8d3 Creating + Container mtusi-lab2-checks-run-b4e1706cc8d3 Created diff --git a/evidence/expiry.json b/evidence/expiry.json new file mode 100644 index 00000000..1ed76edd --- /dev/null +++ b/evidence/expiry.json @@ -0,0 +1,7 @@ +{ + "session_ttl_seconds": 2, + "wait_seconds": 2.3, + "before_expiry_status": 200, + "after_expiry_status": 401, + "result": "PASS" +} diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 00000000..5c5dad37 --- /dev/null +++ b/evidence/expiry.txt @@ -0,0 +1,3 @@ +PASS: TTL=2s, initial 200, after 2.3s -> 401; normal API TTL unchanged + Container mtusi-lab2-checks-run-7bb72261a3d9 Creating + Container mtusi-lab2-checks-run-7bb72261a3d9 Created diff --git a/evidence/explain-run.txt b/evidence/explain-run.txt new file mode 100644 index 00000000..7ed24035 --- /dev/null +++ b/evidence/explain-run.txt @@ -0,0 +1,4 @@ +python3 scripts/explain_history.py +PASS: 10000 messages, first/middle/late pages use history index; 51 SQL rows for 50 HTTP items + Container mtusi-lab2-checks-run-ce830e513aa3 Creating + Container mtusi-lab2-checks-run-ce830e513aa3 Created diff --git a/evidence/explain.json b/evidence/explain.json new file mode 100644 index 00000000..2c728aea --- /dev/null +++ b/evidence/explain.json @@ -0,0 +1,235 @@ +{ + "messages_in_chat": 10000, + "page_limit": 50, + "index": "messages_chat_created_id_idx", + "cases": { + "first": { + "after_message": 0, + "sql": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s ORDER BY created_at, id LIMIT %s", + "plan": { + "Plan": { + "Node Type": "Limit", + "Parallel Aware": false, + "Async Capable": false, + "Startup Cost": 0.29, + "Total Cost": 5.58, + "Plan Rows": 51, + "Plan Width": 70, + "Actual Startup Time": 0.009, + "Actual Total Time": 0.017, + "Actual Rows": 51, + "Actual Loops": 1, + "Shared Hit Blocks": 3, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Plans": [ + { + "Node Type": "Index Scan", + "Parent Relationship": "Outer", + "Parallel Aware": false, + "Async Capable": false, + "Scan Direction": "Forward", + "Index Name": "messages_chat_created_id_idx", + "Relation Name": "messages", + "Alias": "messages", + "Startup Cost": 0.29, + "Total Cost": 1038.88, + "Plan Rows": 10000, + "Plan Width": 70, + "Actual Startup Time": 0.008, + "Actual Total Time": 0.014, + "Actual Rows": 51, + "Actual Loops": 1, + "Index Cond": "(chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid)", + "Rows Removed by Index Recheck": 0, + "Shared Hit Blocks": 3, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + } + ] + }, + "Planning": { + "Shared Hit Blocks": 107, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + }, + "Planning Time": 0.214, + "Triggers": [], + "Execution Time": 0.036 + } + }, + "middle": { + "after_message": 5000, + "sql": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s", + "plan": { + "Plan": { + "Node Type": "Limit", + "Parallel Aware": false, + "Async Capable": false, + "Startup Cost": 0.29, + "Total Cost": 7.15, + "Plan Rows": 51, + "Plan Width": 70, + "Actual Startup Time": 0.019, + "Actual Total Time": 0.029, + "Actual Rows": 51, + "Actual Loops": 1, + "Shared Hit Blocks": 4, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Plans": [ + { + "Node Type": "Index Scan", + "Parent Relationship": "Outer", + "Parallel Aware": false, + "Async Capable": false, + "Scan Direction": "Forward", + "Index Name": "messages_chat_created_id_idx", + "Relation Name": "messages", + "Alias": "messages", + "Startup Cost": 0.29, + "Total Cost": 665.89, + "Plan Rows": 4945, + "Plan Width": 70, + "Actual Startup Time": 0.018, + "Actual Total Time": 0.025, + "Actual Rows": 51, + "Actual Loops": 1, + "Index Cond": "((chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:30:51.163748+00'::timestamp with time zone, '49e8083b-b366-420a-a42e-7dd94e84e990'::uuid)))", + "Rows Removed by Index Recheck": 0, + "Shared Hit Blocks": 4, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + } + ] + }, + "Planning": { + "Shared Hit Blocks": 0, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + }, + "Planning Time": 0.044, + "Triggers": [], + "Execution Time": 0.05 + } + }, + "late": { + "after_message": 9900, + "sql": "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s", + "plan": { + "Plan": { + "Node Type": "Limit", + "Parallel Aware": false, + "Async Capable": false, + "Startup Cost": 0.29, + "Total Cost": 83.03, + "Plan Rows": 51, + "Plan Width": 70, + "Actual Startup Time": 0.006, + "Actual Total Time": 0.017, + "Actual Rows": 51, + "Actual Loops": 1, + "Shared Hit Blocks": 4, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0, + "Plans": [ + { + "Node Type": "Index Scan", + "Parent Relationship": "Outer", + "Parallel Aware": false, + "Async Capable": false, + "Scan Direction": "Forward", + "Index Name": "messages_chat_created_id_idx", + "Relation Name": "messages", + "Alias": "messages", + "Startup Cost": 0.29, + "Total Cost": 159.29, + "Plan Rows": 98, + "Plan Width": 70, + "Actual Startup Time": 0.006, + "Actual Total Time": 0.014, + "Actual Rows": 51, + "Actual Loops": 1, + "Index Cond": "((chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:30:51.168648+00'::timestamp with time zone, '15bb3004-514a-4d41-b783-327659c3269a'::uuid)))", + "Rows Removed by Index Recheck": 0, + "Shared Hit Blocks": 4, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + } + ] + }, + "Planning": { + "Shared Hit Blocks": 0, + "Shared Read Blocks": 0, + "Shared Dirtied Blocks": 0, + "Shared Written Blocks": 0, + "Local Hit Blocks": 0, + "Local Read Blocks": 0, + "Local Dirtied Blocks": 0, + "Local Written Blocks": 0, + "Temp Read Blocks": 0, + "Temp Written Blocks": 0 + }, + "Planning Time": 0.032, + "Triggers": [], + "Execution Time": 0.025 + } + } + } +} diff --git a/evidence/explain.txt b/evidence/explain.txt new file mode 100644 index 00000000..66974030 --- /dev/null +++ b/evidence/explain.txt @@ -0,0 +1,29 @@ +FIRST +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s ORDER BY created_at, id LIMIT %s +Limit (cost=0.29..5.58 rows=51 width=70) (actual time=0.012..0.020 rows=51 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..1038.88 rows=10000 width=70) (actual time=0.011..0.017 rows=51 loops=1) + Index Cond: (chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) + Buffers: shared hit=3 +Planning Time: 0.053 ms +Execution Time: 0.030 ms + +MIDDLE +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s +Limit (cost=0.29..7.15 rows=51 width=70) (actual time=0.011..0.021 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..665.89 rows=4945 width=70) (actual time=0.011..0.017 rows=51 loops=1) + Index Cond: ((chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:30:51.163748+00'::timestamp with time zone, '49e8083b-b366-420a-a42e-7dd94e84e990'::uuid))) + Buffers: shared hit=4 +Planning Time: 0.052 ms +Execution Time: 0.031 ms + +LATE +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s +Limit (cost=0.29..83.03 rows=51 width=70) (actual time=0.008..0.020 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..159.29 rows=98 width=70) (actual time=0.007..0.016 rows=51 loops=1) + Index Cond: ((chat_id = '24b671da-2531-454f-9569-2d97c3d3b45e'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 21:30:51.168648+00'::timestamp with time zone, '15bb3004-514a-4d41-b783-327659c3269a'::uuid))) + Buffers: shared hit=4 +Planning Time: 0.043 ms +Execution Time: 0.029 ms diff --git a/evidence/failures.json b/evidence/failures.json new file mode 100644 index 00000000..c55d9e5a --- /dev/null +++ b/evidence/failures.json @@ -0,0 +1,14 @@ +{ + "redis": { + "ready_status": 503, + "protected_status": 503, + "elapsed_seconds": 1.003, + "anonymous_status": 401 + }, + "postgres": { + "ready_status": 503, + "protected_status": 503, + "elapsed_seconds": 1.003, + "anonymous_status": 401 + } +} diff --git a/evidence/final-status.json b/evidence/final-status.json new file mode 100644 index 00000000..67cc4f1f --- /dev/null +++ b/evidence/final-status.json @@ -0,0 +1,37 @@ +{ + "api_url": "http://127.0.0.1:18080", + "ready_status": 200, + "services": { + "api": { + "id": "d7b43b2f4a744721ee10aea864bb3defbb13c84e5c242e37cbf79956dc626261", + "started_at": "2026-10-30T21:48:46.355604781Z", + "image_id": "sha256:dab3ec7c7d69de21873d119e07d6348bce002537737d1265baf0908c206fc29d", + "user": "messenger", + "volumes": [], + "memory_limit_bytes": 268435456, + "nano_cpus": 1000000000 + }, + "postgres": { + "id": "d8375ea156feb08c83f85a4b94e192b60e61d6f3df09f671e9c50750b9f2b46e", + "started_at": "2026-10-30T21:35:48.155522719Z", + "image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3", + "user": "", + "volumes": [ + "mtusi-lab2_postgres_data" + ], + "memory_limit_bytes": 536870912, + "nano_cpus": 1000000000 + }, + "redis": { + "id": "ddd6a9fad24efbcb9c3025fe4cd10ce2500772d417379bccb35c7c3a90bfee97", + "started_at": "2026-10-30T21:35:48.37486311Z", + "image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb", + "user": "", + "volumes": [ + "mtusi-lab2_redis_data" + ], + "memory_limit_bytes": 201326592, + "nano_cpus": 500000000 + } + } +} diff --git a/evidence/host.json b/evidence/host.json new file mode 100644 index 00000000..46ebef68 --- /dev/null +++ b/evidence/host.json @@ -0,0 +1,15 @@ +{ + "cpu": [ + { + "Name": "Intel(R) Core(TM) i5-9600K CPU @ 3.70GHz", + "NumberOfCores": 6, + "NumberOfLogicalProcessors": 6 + } + ], + "memory_gib": 31.9, + "docker_server": "29.8.1", + "compose": "5.5.1", + "published_port": "127.0.0.1:18080", + "readiness": 200, + "default_port_8080": "Connection reset on this host; local API_PORT overridden to 18080" +} diff --git a/evidence/migration-newlines.txt b/evidence/migration-newlines.txt new file mode 100644 index 00000000..6f735483 --- /dev/null +++ b/evidence/migration-newlines.txt @@ -0,0 +1,6 @@ +Unchanged: 001_initial.sql +PASS: migrations committed +PASS: LF checkout kept migration ledger unchanged +Unchanged: 001_initial.sql +PASS: migrations committed +PASS: CRLF checkout kept migration ledger unchanged diff --git a/evidence/migrations-repeat.txt b/evidence/migrations-repeat.txt new file mode 100644 index 00000000..6abdfa50 --- /dev/null +++ b/evidence/migrations-repeat.txt @@ -0,0 +1,4 @@ +Unchanged: 001_initial.sql +PASS: migrations committed + Container mtusi-lab2-migrate-run-ebe3f2f5eae7 Creating + Container mtusi-lab2-migrate-run-ebe3f2f5eae7 Created diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..b172d413 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,5 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://api:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. + Container mtusi-lab2-checks-run-c6a8abec432a Creating + Container mtusi-lab2-checks-run-c6a8abec432a Created diff --git a/evidence/published-smoke.txt b/evidence/published-smoke.txt new file mode 100644 index 00000000..4d4c5535 --- /dev/null +++ b/evidence/published-smoke.txt @@ -0,0 +1 @@ +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/restart.json b/evidence/restart.json new file mode 100644 index 00000000..752aaa9b --- /dev/null +++ b/evidence/restart.json @@ -0,0 +1,68 @@ +{ + "before": { + "api": { + "id": "afbb0567726afe4b878da238a10d935f05860485b3b8d538303fe87ec8a09480", + "started_at": "2026-10-30T21:30:01.813974621Z", + "image_id": "sha256:fb326ae35c17b3e6e8eac43b314a198acc0cb35768a89afbbc1dad80089004c5", + "user": "messenger", + "volumes": [], + "memory_limit_bytes": 268435456, + "nano_cpus": 1000000000 + }, + "postgres": { + "id": "d8375ea156feb08c83f85a4b94e192b60e61d6f3df09f671e9c50750b9f2b46e", + "started_at": "2026-10-30T21:30:21.917882257Z", + "image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3", + "user": "", + "volumes": [ + "mtusi-lab2_postgres_data" + ], + "memory_limit_bytes": 536870912, + "nano_cpus": 1000000000 + }, + "redis": { + "id": "ddd6a9fad24efbcb9c3025fe4cd10ce2500772d417379bccb35c7c3a90bfee97", + "started_at": "2026-10-30T21:30:25.782358865Z", + "image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb", + "user": "", + "volumes": [ + "mtusi-lab2_redis_data" + ], + "memory_limit_bytes": 201326592, + "nano_cpus": 500000000 + } + }, + "after": { + "api": { + "id": "afbb0567726afe4b878da238a10d935f05860485b3b8d538303fe87ec8a09480", + "started_at": "2026-10-30T21:30:34.407753279Z", + "image_id": "sha256:fb326ae35c17b3e6e8eac43b314a198acc0cb35768a89afbbc1dad80089004c5", + "user": "messenger", + "volumes": [], + "memory_limit_bytes": 268435456, + "nano_cpus": 1000000000 + }, + "postgres": { + "id": "d8375ea156feb08c83f85a4b94e192b60e61d6f3df09f671e9c50750b9f2b46e", + "started_at": "2026-10-30T21:30:34.034926172Z", + "image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3", + "user": "", + "volumes": [ + "mtusi-lab2_postgres_data" + ], + "memory_limit_bytes": 536870912, + "nano_cpus": 1000000000 + }, + "redis": { + "id": "ddd6a9fad24efbcb9c3025fe4cd10ce2500772d417379bccb35c7c3a90bfee97", + "started_at": "2026-10-30T21:30:34.206318985Z", + "image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb", + "user": "", + "volumes": [ + "mtusi-lab2_redis_data" + ], + "memory_limit_bytes": 201326592, + "nano_cpus": 500000000 + } + } +} diff --git a/evidence/smoke-final.txt b/evidence/smoke-final.txt new file mode 100644 index 00000000..74e4ca93 --- /dev/null +++ b/evidence/smoke-final.txt @@ -0,0 +1,4 @@ +python3 tests/smoke.py --base-url "http://api:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. + Container mtusi-lab2-checks-run-942aef800efa Creating + Container mtusi-lab2-checks-run-942aef800efa Created diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..39f0d118 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,4 @@ +python3 tests/smoke.py --base-url "http://api:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. + Container mtusi-lab2-checks-run-b2982f811b3b Creating + Container mtusi-lab2-checks-run-b2982f811b3b Created diff --git a/evidence/source-integrity.json b/evidence/source-integrity.json new file mode 100644 index 00000000..26458fe8 --- /dev/null +++ b/evidence/source-integrity.json @@ -0,0 +1,16 @@ +{ + "result": "PASS", + "files_checked": 9, + "scope": "all original contracts and public tests", + "sha256": { + "contracts\\examples.json": "0A71CEC72903AF556DF85F939C7E347FC73A86A1A4FFC39FB9C8DED169B7DF45", + "contracts\\infrastructure.json": "7EFD8B1E6023DDC3FF9747D4F663EE772C1293B782BB9E74BD1C3FBCCA9C68D8", + "contracts\\openapi.json": "CFF3AA6B34855B573401B0AC393FDFE327B6A12DA51F315FBBD67168CE3762C4", + "contracts\\README.md": "72DF27A559F88FFA3FD8C3C79D3C32F6DB2C5986A0602677C51994C434A3FC4F", + "tests\\client.py": "8D50976FC7C7BBB81E88A152F613C61AB25EAF53DBA33C6A9DFAB19F868D546D", + "tests\\load.py": "6D3511EA719C7A7E841083E73D435C86DCBFD9F4E5C2A07D62EB9614B01D9933", + "tests\\README.md": "E0BFA7E196797F6A5BF6E44D8AD2FFEB82651927FF5D8484EB1C2DDA1EC7DEC5", + "tests\\resilience.py": "1F96663A174B3978D24EFF66F2741F5F8C9B788D3242261D37A972720C52788B", + "tests\\smoke.py": "52AC38EB343FF7D43E7543588E1DA58CA06C9FCE74B2B0D0BF0E4982BC23C1DB" + } +} diff --git a/evidence/startup.txt b/evidence/startup.txt new file mode 100644 index 00000000..1398e8b0 --- /dev/null +++ b/evidence/startup.txt @@ -0,0 +1,24 @@ + Container mtusi-lab2-postgres-1 Running + Container mtusi-lab2-redis-1 Running + Container mtusi-lab2-migrate-1 Recreate + Container mtusi-lab2-migrate-1 Recreated + Container mtusi-lab2-api-1 Recreate + Container mtusi-lab2-api-1 Recreated + Container mtusi-lab2-postgres-1 Waiting + Container mtusi-lab2-postgres-1 Healthy + Container mtusi-lab2-migrate-1 Starting + Container mtusi-lab2-migrate-1 Started + Container mtusi-lab2-migrate-1 Waiting + Container mtusi-lab2-redis-1 Waiting + Container mtusi-lab2-redis-1 Healthy + Container mtusi-lab2-migrate-1 Exited + Container mtusi-lab2-api-1 Starting + Container mtusi-lab2-api-1 Started + Container mtusi-lab2-api-1 Waiting + Container mtusi-lab2-postgres-1 Waiting + Container mtusi-lab2-redis-1 Waiting + Container mtusi-lab2-migrate-1 Waiting + Container mtusi-lab2-redis-1 Healthy + Container mtusi-lab2-migrate-1 Exited + Container mtusi-lab2-postgres-1 Healthy + Container mtusi-lab2-api-1 Healthy diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..8fb214f8 --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,21 @@ +python3 -m unittest discover -s student-tests -v +ROLLBACK: invalid second member left no chat or membership rows +CONCURRENCY: 10 clients, 100 confirmations, 100 unique messages +FAILURES: Redis/PostgreSQL -> bounded 503, live 200, anonymous 401, recovery with old session +REDIS CRASH: old session survived SIGKILL/AOF replay, expiry deadline unchanged +RACE: 10 requests, 1 created, 9 conflicts, 1 database row + Container mtusi-lab2-checks-run-7f723776bde2 Creating + Container mtusi-lab2-checks-run-7f723776bde2 Created +test_composite_chat_rollback (test_api.APITests.test_composite_chat_rollback) ... ok +test_concurrent_messages (test_api.APITests.test_concurrent_messages) ... ok +test_cursor_binding_and_chat_pages (test_api.APITests.test_cursor_binding_and_chat_pages) ... ok +test_dependency_failures (test_api.APITests.test_dependency_failures) ... ok +test_passwords_and_authentication (test_api.APITests.test_passwords_and_authentication) ... ok +test_redis_crash_durability (test_api.APITests.test_redis_crash_durability) ... ok +test_registration_race (test_api.APITests.test_registration_race) ... ok +test_validation_and_access (test_api.APITests.test_validation_and_access) ... ok + +---------------------------------------------------------------------- +Ran 8 tests in 12.538s + +OK diff --git a/evidence/verification.json b/evidence/verification.json new file mode 100644 index 00000000..d682c87e --- /dev/null +++ b/evidence/verification.json @@ -0,0 +1,60 @@ +{ + "result": "PASS", + "utc": "2026-10-30T21:30:59.870582+00:00", + "checks": [ + "contract", + "public_smoke", + "8_student_tests", + "all_stores_restart", + "short_expiry", + "explain_10000", + "migration_replay", + "final_smoke" + ], + "versions": { + "python": "3.13.15", + "packages": { + "fastapi": "0.141.1", + "pydantic": "2.13.5", + "uvicorn": "0.53.0", + "psycopg": "3.2.10", + "psycopg-pool": "3.2.6", + "redis": "6.4.0" + } + }, + "migration_counts_before": "27|12|10113", + "migration_counts_after": "27|12|10113", + "deployment": { + "api": { + "id": "afbb0567726afe4b878da238a10d935f05860485b3b8d538303fe87ec8a09480", + "started_at": "2026-10-30T21:30:34.407753279Z", + "image_id": "sha256:fb326ae35c17b3e6e8eac43b314a198acc0cb35768a89afbbc1dad80089004c5", + "user": "messenger", + "volumes": [], + "memory_limit_bytes": 268435456, + "nano_cpus": 1000000000 + }, + "postgres": { + "id": "d8375ea156feb08c83f85a4b94e192b60e61d6f3df09f671e9c50750b9f2b46e", + "started_at": "2026-10-30T21:30:34.034926172Z", + "image_id": "sha256:f3bd19c606e442c3d7bdfa8002e03fe260a1023351e0ea4598032022b68dd6e3", + "user": "", + "volumes": [ + "mtusi-lab2_postgres_data" + ], + "memory_limit_bytes": 536870912, + "nano_cpus": 1000000000 + }, + "redis": { + "id": "ddd6a9fad24efbcb9c3025fe4cd10ce2500772d417379bccb35c7c3a90bfee97", + "started_at": "2026-10-30T21:30:34.206318985Z", + "image_id": "sha256:90e7a336d044f1abc9e9dbc05d65566850896d11453bbd1dd0fb7e5059f0e8fb", + "user": "", + "volumes": [ + "mtusi-lab2_redis_data" + ], + "memory_limit_bytes": 201326592, + "nano_cpus": 500000000 + } + } +} diff --git a/infra/redis.conf b/infra/redis.conf new file mode 100644 index 00000000..7a88410a --- /dev/null +++ b/infra/redis.conf @@ -0,0 +1,9 @@ +bind 0.0.0.0 +protected-mode yes +port 6379 +dir /data +appendonly yes +appendfsync always +save "" +maxmemory 128mb +maxmemory-policy noeviction diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..244f2d4b --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,32 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + last_message_at timestamptz NOT NULL DEFAULT '-infinity' +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats(id), + user_id uuid NOT NULL REFERENCES users(id), + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX chat_members_user_chat_idx ON chat_members(user_id, chat_id); +CREATE INDEX chats_created_id_idx ON chats(created_at, id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id), + sender_id uuid NOT NULL, + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL, + FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id) +); +CREATE INDEX messages_chat_created_id_idx ON messages(chat_id, created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..d23554bd --- /dev/null +++ b/requirements.txt @@ -0,0 +1,17 @@ +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +click==8.5.0 +colorama==0.4.6; sys_platform == 'win32' +fastapi==0.141.1 +h11==0.16.0 +idna==3.20 +pydantic==2.13.5 +pydantic-core==2.46.5 +starlette==1.6.0 +typing-extensions==4.16.0 +typing-inspection==0.4.4 +uvicorn==0.53.0 +psycopg[binary]==3.2.10 +psycopg-pool==3.2.6 +redis==6.4.0 diff --git a/scripts/check_expiry.py b/scripts/check_expiry.py new file mode 100644 index 00000000..fca24d0d --- /dev/null +++ b/scripts/check_expiry.py @@ -0,0 +1,35 @@ +"""Run against a separate API configured with SESSION_TTL_SECONDS=2.""" +from pathlib import Path +import json +import os +import sys +import time + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client, check + + +def main(): + c = Client(os.environ["EXPIRY_BASE_URL"]) + deadline = time.monotonic() + 30 + while True: + try: + c.call("GET", "/health/ready", schema="Health") + break + except AssertionError: + check(time.monotonic() < deadline, "TTL API did not become ready") + time.sleep(0.25) + actor = c.user("expiry") + c.call("GET", "/api/v1/users/me", actor=actor, schema="User") + time.sleep(2.3) + response = c.call("GET", "/api/v1/users/me", 401, actor=actor) + report = {"session_ttl_seconds": 2, "wait_seconds": 2.3, + "before_expiry_status": 200, "after_expiry_status": response["status"], + "result": "PASS"} + (ROOT / "evidence" / "expiry.json").write_text(json.dumps(report, indent=2) + "\n") + print("PASS: TTL=2s, initial 200, after 2.3s -> 401; normal API TTL unchanged") + + +if __name__ == "__main__": + main() diff --git a/scripts/explain_history.py b/scripts/explain_history.py new file mode 100644 index 00000000..fa5e5715 --- /dev/null +++ b/scripts/explain_history.py @@ -0,0 +1,76 @@ +"""Seed an isolated synthetic chat, measure the actual keyset SQL, keep raw plans.""" +from datetime import datetime, timedelta, timezone +import json +from pathlib import Path +import sys +from urllib.parse import quote +from uuid import UUID + +import psycopg + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT)) +sys.path.insert(0, str(ROOT / "tests")) +from app.config import secret +from app.security import Cursors, stamp +from client import Client, check + + +def walk(node): + yield node + for child in node.get("Plans", []): + yield from walk(child) + + +def main(): + c = Client() + actor = c.user("explain") + chat = c.call("POST", "/api/v1/chats", 201, actor=actor, + body={"title": "EXPLAIN 10000", "member_ids": [actor["id"]]}, schema="Chat")["json"] + base = datetime.now(timezone.utc) + with psycopg.connect(secret("DATABASE_URL"), connect_timeout=2) as conn: + conn.execute("""INSERT INTO messages(id, chat_id, sender_id, text, created_at) + SELECT gen_random_uuid(), %s, %s, 'synthetic-' || i, + %s + i * interval '1 microsecond' + FROM generate_series(1, 10000) AS i""", (UUID(chat["id"]), UUID(actor["id"]), base)) + conn.execute("UPDATE chats SET last_message_at=%s WHERE id=%s", + (base + timedelta(microseconds=10000), UUID(chat["id"]))) + conn.execute("ANALYZE messages") + report = {"messages_in_chat": 10000, "page_limit": 50, + "index": "messages_chat_created_id_idx", "cases": {}} + text_plans = [] + cursors = Cursors(secret("CURSOR_KEY").encode()) + with psycopg.connect(secret("DATABASE_URL"), connect_timeout=2) as conn: + for label, offset in (("first", 0), ("middle", 5000), ("late", 9900)): + sql = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id=%s" + params = [UUID(chat["id"])] + path = "/api/v1/chats/" + chat["id"] + "/messages?limit=50" + if offset: + boundary = conn.execute("SELECT created_at, id FROM messages WHERE chat_id=%s AND text=%s", + (UUID(chat["id"]), "synthetic-" + str(offset))).fetchone() + sql += " AND (created_at, id) > (%s, %s)" + params.extend(boundary) + token = cursors.encode("messages:" + chat["id"], + {"created_at": stamp(boundary[0]), "id": str(boundary[1])}) + path += "&cursor=" + quote(token, safe="") + sql += " ORDER BY created_at, id LIMIT %s" + params.append(51) + data = conn.execute("EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) " + sql, params).fetchone()[0][0] + nodes = list(walk(data["Plan"])) + check(not any(x["Node Type"] == "Seq Scan" for x in nodes), "Unexpected full scan in keyset query") + check(any(x.get("Index Name") == report["index"] for x in nodes), "History index not used") + check(data["Plan"]["Actual Rows"] == 51, "LIMIT was not respected") + page = c.call("GET", path, actor=actor, schema="MessagePage")["json"] + check(len(page["items"]) == 50 and page["next_cursor"], "HTTP page differs from measured SQL") + expected = ["synthetic-" + str(i) for i in range(offset + 1, offset + 51)] + check([x["text"] for x in page["items"]] == expected, "HTTP keyset boundary differs") + report["cases"][label] = {"after_message": offset, "sql": sql, "plan": data} + text_plans.append(label.upper() + "\n" + sql + "\n" + "\n".join( + row[0] for row in conn.execute("EXPLAIN (ANALYZE, BUFFERS) " + sql, params).fetchall())) + (ROOT / "evidence" / "explain.json").write_text(json.dumps(report, indent=2) + "\n") + (ROOT / "evidence" / "explain.txt").write_text("\n\n".join(text_plans) + "\n") + print("PASS: 10000 messages, first/middle/late pages use history index; 51 SQL rows for 50 HTTP items") + + +if __name__ == "__main__": + main() diff --git a/scripts/init_local.py b/scripts/init_local.py new file mode 100644 index 00000000..5489c980 --- /dev/null +++ b/scripts/init_local.py @@ -0,0 +1,35 @@ +"""Create local synthetic credentials once without printing secret values.""" +from pathlib import Path +import secrets + +ROOT = Path(__file__).resolve().parents[1] + + +def main(): + directory = ROOT / "secrets" + directory.mkdir(exist_ok=True) + for name in ("postgres_password", "redis_password", "cursor_key"): + path = directory / name + if not path.exists(): + path.write_text(secrets.token_hex(32) + "\n", encoding="utf-8", newline="\n") + else: + # Shell command substitution on Linux must not retain a Windows CR. + value = path.read_text(encoding="utf-8").strip() + path.write_text(value + "\n", encoding="utf-8", newline="\n") + pg_password = (directory / "postgres_password").read_text().strip() + redis_password = (directory / "redis_password").read_text().strip() + for name, value in { + "database_url": f"postgresql://messenger:{pg_password}@postgres:5432/messenger", + "cache_url": f"redis://:{redis_password}@redis:6379/0", + }.items(): + path = directory / name + if not path.exists(): + path.write_text(value + "\n", encoding="utf-8", newline="\n") + env = ROOT / ".env" + if not env.exists(): + env.write_bytes((ROOT / ".env.example").read_bytes()) + print("PASS: local .env and secret files exist; existing values preserved") + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..fc7bb637 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart --timeout 5 api postgres redis diff --git a/scripts/verify.py b/scripts/verify.py new file mode 100644 index 00000000..ccab0026 --- /dev/null +++ b/scripts/verify.py @@ -0,0 +1,114 @@ +"""One reproducible local check: public tests, failures, expiry and SQL plans.""" +import argparse +from datetime import datetime, timezone +import json +import os +from pathlib import Path +import subprocess + +ROOT = Path(__file__).resolve().parents[1] +EVIDENCE = ROOT / "evidence" + + +def command(args, output=None, timeout=300): + result = subprocess.run(args, cwd=ROOT, capture_output=True, text=True, + encoding="utf-8", errors="replace", timeout=timeout) + if output: + (EVIDENCE / output).write_text(result.stdout + result.stderr, encoding="utf-8") + if result.returncode: + raise RuntimeError("Command failed; see " + (output or "local Docker status")) + return result.stdout.strip() + + +def compose(*args, **kwargs): + return command(["docker", "compose", "--env-file", ".env", *args], **kwargs) + + +def checks(*args, output): + return compose("run", "--rm", "--no-deps", "checks", *args, output=output) + + +def snapshot(): + result = {} + for service in ("api", "postgres", "redis"): + identifier = compose("ps", "--all", "--quiet", service) + data = json.loads(command(["docker", "inspect", identifier]))[0] + result[service] = {"id": data["Id"], "started_at": data["State"]["StartedAt"], + "image_id": data["Image"], "user": data["Config"]["User"], + "volumes": [item["Name"] for item in data["Mounts"] if item["Type"] == "volume"], + "memory_limit_bytes": data["HostConfig"]["Memory"], + "nano_cpus": data["HostConfig"]["NanoCpus"]} + return result + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--skip-build", action="store_true") + parser.add_argument("--published-base-url", help="Optional host URL for a second public smoke through the published port") + args = parser.parse_args() + EVIDENCE.mkdir(exist_ok=True) + command([os.sys.executable, "scripts/init_local.py"]) + compose("config", "--quiet") + if not args.skip_build: + print("Building runtime and check images", flush=True) + compose("build", "api", "checks", output="build.txt", timeout=600) + compose("up", "-d", "--wait", "--wait-timeout", "90", output="startup.txt", timeout=150) + print("Running contract, public smoke and student integration tests", flush=True) + checks("make", "check", output="contract-check.txt") + checks("make", "test", output="smoke.txt") + checks("make", "test-student", output="student-tests.txt") + print("Running unchanged public persistence test", flush=True) + before = snapshot() + checks("sh", "-ec", "chmod +x scripts/restart.sh; make test-persistence ACTION_SCRIPT=scripts/restart.sh", + output="persistence.txt") + after = snapshot() + for service in before: + assert before[service]["id"] == after[service]["id"], "Unexpected container replacement" + assert before[service]["started_at"] != after[service]["started_at"], "Service was not restarted" + assert before[service]["volumes"] == after[service]["volumes"], "Volumes changed" + (EVIDENCE / "restart.json").write_text(json.dumps({"before": before, "after": after}, indent=2) + "\n") + print("Testing short expiry in a separate API process", flush=True) + project = os.environ.get("COMPOSE_PROJECT_NAME", "mtusi-lab2") + # Read the configured project name from normalized compose metadata, not local paths. + project = json.loads(compose("config", "--format", "json"))["name"] + ttl_name = project + "-ttl-check" + existing = command(["docker", "ps", "-a", "--filter", "name=^/" + ttl_name + "$", "--format", "{{.ID}}"]) + if existing: + raise RuntimeError("TTL test container name already exists; it was not removed") + created = False + try: + compose("run", "-d", "--no-deps", "--name", ttl_name, "-e", "SESSION_TTL_SECONDS=2", "api") + created = True + compose("run", "--rm", "--no-deps", "-e", "EXPIRY_BASE_URL=http://" + ttl_name + ":8080", + "checks", "python", "scripts/check_expiry.py", output="expiry.txt") + finally: + if created: + command(["docker", "stop", "--time", "5", ttl_name]) + command(["docker", "rm", ttl_name]) + print("Measuring first, middle and late history pages on 10000 messages", flush=True) + checks("make", "explain", output="explain-run.txt") + counts_before = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-Atc", + "SELECT (SELECT count(*) FROM users),(SELECT count(*) FROM chats),(SELECT count(*) FROM messages)") + compose("run", "--rm", "--no-deps", "migrate", output="migrations-repeat.txt") + counts_after = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-Atc", + "SELECT (SELECT count(*) FROM users),(SELECT count(*) FROM chats),(SELECT count(*) FROM messages)") + assert counts_before == counts_after, "Migration replay changed business data" + checks("make", "test", output="smoke-final.txt") + if args.published_base_url: + command([os.sys.executable, "tests/smoke.py", "--base-url", args.published_base_url], + output="published-smoke.txt") + versions = compose("exec", "-T", "api", "python", "-c", + "import importlib.metadata as m,json,platform; print(json.dumps({'python':platform.python_version()," + "'packages':{p:m.version(p) for p in ['fastapi','pydantic','uvicorn','psycopg','psycopg-pool','redis']}}))") + summary = {"result": "PASS", "utc": datetime.now(timezone.utc).isoformat(), + "checks": ["contract", "public_smoke", "8_student_tests", "all_stores_restart", "short_expiry", + "explain_10000", "migration_replay", "final_smoke"], + "versions": json.loads(versions), "migration_counts_before": counts_before, + "migration_counts_after": counts_after, "deployment": after, + "published_base_url": args.published_base_url} + (EVIDENCE / "verification.json").write_text(json.dumps(summary, indent=2) + "\n") + print("PASS: all grade-4 checks; summaries saved under evidence/", flush=True) + + +if __name__ == "__main__": + main() diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..f48e58ae --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,215 @@ +"""Integration tests against real HTTP, PostgreSQL and Redis on the local stack.""" +from concurrent.futures import ThreadPoolExecutor +import base64 +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import time +import unittest +from urllib.parse import quote +from uuid import uuid4 + +import psycopg +import redis + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client +from app.config import secret + + +class APITests(unittest.TestCase): + def setUp(self): + self.c = Client(timeout=8) + self.alice = self.c.user("student") + self.bob = self.c.user("member") + self.chat = self.c.call("POST", "/api/v1/chats", 201, actor=self.alice, + body={"title": "Учебный чат", "member_ids": [self.alice["id"], self.bob["id"]]}, + schema="Chat")["json"] + self.path = "/api/v1/chats/" + self.chat["id"] + + def scalar(self, query, params=()): + with psycopg.connect(secret("DATABASE_URL"), connect_timeout=2) as conn: + return conn.execute(query, params).fetchone()[0] + + def history(self, limit=17): + result, cursor = [], None + for _ in range(100): + path = self.path + "/messages?limit=" + str(limit) + if cursor: + path += "&cursor=" + quote(cursor, safe="") + page = self.c.call("GET", path, actor=self.alice, schema="MessagePage")["json"] + result.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + return result + self.fail("Pagination did not terminate") + + def test_registration_race(self): + registration = {"username": "race_" + uuid4().hex[:16], "display_name": "Гонка", + "password": "Synthetic-password-12345"} + def register(_): + return self.c.call("POST", "/api/v1/users", [201, 409], body=registration, + schema="User")["status"] + with ThreadPoolExecutor(max_workers=10) as pool: + statuses = list(pool.map(register, range(10))) + self.assertEqual(statuses.count(201), 1) + self.assertEqual(statuses.count(409), 9) + self.assertEqual(self.scalar("SELECT count(*) FROM users WHERE username=%s", + (registration["username"],)), 1) + print("RACE: 10 requests, 1 created, 9 conflicts, 1 database row", flush=True) + + def test_composite_chat_rollback(self): + before = self.scalar("SELECT count(*) FROM chats") + memberships = self.scalar("SELECT count(*) FROM chat_members") + self.c.call("POST", "/api/v1/chats", 400, actor=self.alice, + body={"title": "Rollback", "member_ids": [self.alice["id"], str(uuid4())]}) + self.assertEqual(self.scalar("SELECT count(*) FROM chats"), before) + self.assertEqual(self.scalar("SELECT count(*) FROM chat_members"), memberships) + self.assertEqual(self.scalar("SELECT count(*) FROM chats c WHERE NOT EXISTS " + "(SELECT 1 FROM chat_members m WHERE m.chat_id=c.id)"), 0) + print("ROLLBACK: invalid second member left no chat or membership rows", flush=True) + + def test_concurrent_messages(self): + def send(index): + return self.c.message(self.alice, self.chat, "parallel-" + str(index))["json"]["id"] + with ThreadPoolExecutor(max_workers=10) as pool: + ids = list(pool.map(send, range(100))) + messages = self.history() + self.assertEqual(len(messages), 100) + self.assertEqual(len(set(ids)), 100) + self.assertEqual({row["id"] for row in messages}, set(ids)) + self.assertEqual({row["text"] for row in messages}, {"parallel-" + str(i) for i in range(100)}) + self.assertEqual(messages, sorted(messages, key=lambda row: (row["created_at"], row["id"]))) + print("CONCURRENCY: 10 clients, 100 confirmations, 100 unique messages", flush=True) + + def test_validation_and_access(self): + for payload in [b"{", b"null", b"[]", b"\xff", b'{"text":NaN}']: + self.c.call("POST", self.path + "/messages", 400, actor=self.alice, raw=payload, + headers={"Content-Type": "application/json"}) + for body in [{"text": ""}, {"text": " \n\t"}, {"text": 123}, {"text": "x" * 4001}, + {"text": "hello", "sender_id": self.bob["id"]}]: + self.c.call("POST", self.path + "/messages", 400, actor=self.alice, body=body) + outsider = self.c.user("outsider") + for suffix in ("", "/messages"): + self.c.call("GET", self.path + suffix, 404, actor=outsider) + self.c.call("POST", self.path + "/messages", 404, actor=outsider, body={"text": "hidden"}) + for members in [[self.bob["id"]], [self.alice["id"], self.alice["id"]], ["bad"], []]: + self.c.call("POST", "/api/v1/chats", 400, actor=self.alice, + body={"title": "Invalid", "member_ids": members}) + self.c.call("GET", "/api/v1/chats/not-uuid", 400, actor=self.alice) + for limit in ("0", "101", "1.1", "-1", "", "true"): + self.c.call("GET", self.path + "/messages?limit=" + limit, 400, actor=self.alice) + self.c.call("POST", "/api/v1/users", 409, body=self.alice["registration"]) + for raw in (b"{}", b'{"username":123}', b'{"username":"ab","display_name":"x","password":"123456789012"}'): + self.c.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": "application/json"}) + + def test_passwords_and_authentication(self): + registration = {"username": "unicode_" + uuid4().hex[:12], "display_name": "Имя 🧪", + "password": "я:🧪" + "密" * 125} + user = self.c.call("POST", "/api/v1/users", 201, body=registration, schema="User")["json"] + credential = base64.b64encode((registration["username"] + ":" + registration["password"]).encode()).decode() + session = self.c.call("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": "Basic " + credential}, schema="Session")["json"] + self.assertEqual(session["user"]["id"], user["id"]) + encoded = self.scalar("SELECT password_hash FROM users WHERE id=%s", (user["id"],)) + algorithm, n, r, p, salt, digest = encoded.split("$") + self.assertEqual(algorithm, "scrypt") + actual = hashlib.scrypt(registration["password"].encode(), salt=bytes.fromhex(salt), + n=int(n), r=int(r), p=int(p), dklen=32, maxmem=64 * 1024 * 1024).hex() + self.assertTrue(actual == digest) + self.assertNotIn("password", user) + for username in (registration["username"], "missing_" + uuid4().hex[:12]): + bad = base64.b64encode((username + ":wrong-password-123").encode()).decode() + response = self.c.call("POST", "/api/v1/auth/sessions", 401, + headers={"Authorization": "Basic " + bad}) + self.assertEqual(response["headers"]["WWW-Authenticate"], 'Basic realm="messenger", charset="UTF-8"') + self.assertEqual(response["json"]["error"]["message"], "Valid credentials required") + self.c.call("GET", "/api/v1/users/me", 401, headers={"Authorization": "Basic " + credential}) + self.c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": user["id"]}) + self.c.call("GET", "/api/v1/users/me", 401, headers={"Authorization": "Bearer " + "x" * 43}) + actor = {"id": user["id"], "token": session["token"]} + self.c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=actor) + self.c.call("GET", "/api/v1/users/me", 401, actor=actor) + self.c.call("DELETE", "/api/v1/auth/sessions/current", 401, actor=actor) + + def test_cursor_binding_and_chat_pages(self): + sent = [self.c.message(self.alice, self.chat, "page-" + str(i))["json"] for i in range(7)] + self.assertEqual(self.history(limit=2), sent) + page = self.c.call("GET", self.path + "/messages?limit=2", actor=self.alice, schema="MessagePage")["json"] + cursor = page["next_cursor"] + other = self.c.call("POST", "/api/v1/chats", 201, actor=self.alice, + body={"title": "Other", "member_ids": [self.alice["id"]]}, schema="Chat")["json"] + self.c.call("GET", "/api/v1/chats/" + other["id"] + "/messages?cursor=" + quote(cursor), 400, actor=self.alice) + for token in ("bad", "", cursor[:-3] + "xxx"): + self.c.call("GET", self.path + "/messages?cursor=" + quote(token), 400, actor=self.alice) + later = self.c.message(self.alice, self.chat, "later")["json"] + continued = self.c.call("GET", self.path + "/messages?limit=100&cursor=" + quote(cursor), + actor=self.alice, schema="MessagePage")["json"] + self.assertEqual(continued["items"], sent[2:] + [later]) + first = self.c.call("GET", "/api/v1/chats?limit=1", actor=self.alice, schema="ChatPage")["json"] + second = self.c.call("GET", "/api/v1/chats?limit=100&cursor=" + quote(first["next_cursor"]), + actor=self.alice, schema="ChatPage")["json"] + self.assertEqual([row["id"] for row in first["items"] + second["items"]], + [self.chat["id"], other["id"]]) + + def compose(self, *args): + result = subprocess.run(["docker", "compose", "--env-file", ".env", *args], cwd=ROOT, + capture_output=True, text=True, timeout=45) + if result.returncode: + self.fail("Compose action failed: " + " ".join(args[:2])) + + def wait_ready(self): + deadline = time.monotonic() + 40 + while time.monotonic() < deadline: + try: + self.c.call("GET", "/health/ready", schema="Health") + return + except AssertionError: + time.sleep(0.25) + self.fail("Stack did not recover") + + def test_dependency_failures(self): + report = {} + for service in ("redis", "postgres"): + self.compose("stop", "--timeout", "2", service) + try: + self.c.call("GET", "/health/live", schema="Health") + ready = self.c.call("GET", "/health/ready", 503) + started = time.monotonic() + response = self.c.call("GET", "/api/v1/users/me", 503, actor=self.alice) + elapsed = time.monotonic() - started + self.assertEqual(response["json"]["error"]["code"], "unavailable") + self.assertLess(elapsed, 6) + self.c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": self.alice["id"]}) + report[service] = {"ready_status": ready["status"], "protected_status": response["status"], + "elapsed_seconds": round(elapsed, 3), "anonymous_status": 401} + finally: + self.compose("start", service) + self.wait_ready() + self.c.call("GET", "/api/v1/users/me", actor=self.alice, schema="User") + self.c.message(self.alice, self.chat, "after-" + service) + (ROOT / "evidence" / "failures.json").write_text(json.dumps(report, indent=2) + "\n") + print("FAILURES: Redis/PostgreSQL -> bounded 503, live 200, anonymous 401, recovery with old session", flush=True) + + def test_redis_crash_durability(self): + client = redis.Redis.from_url(secret("CACHE_URL"), decode_responses=True) + try: + self.assertEqual(client.config_get("appendonly")["appendonly"], "yes") + self.assertEqual(client.config_get("appendfsync")["appendfsync"], "always") + key = "session:" + hashlib.sha256(self.alice["token"].encode()).hexdigest() + deadline_before = client.pexpiretime(key) + self.compose("kill", "--signal", "SIGKILL", "redis") + self.compose("start", "redis") + self.wait_ready() + self.c.call("GET", "/api/v1/users/me", actor=self.alice, schema="User") + self.assertEqual(client.pexpiretime(key), deadline_before) + finally: + client.close() + print("REDIS CRASH: old session survived SIGKILL/AOF replay, expiry deadline unchanged", flush=True) + + +if __name__ == "__main__": + unittest.main()