diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..a1c22612 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +* text=auto +*.sh text eol=lf +*.py text eol=lf +*.sql text eol=lf +*.yaml text eol=lf diff --git a/.github/workflows/application.yml b/.github/workflows/application.yml new file mode 100644 index 00000000..e2098231 --- /dev/null +++ b/.github/workflows/application.yml @@ -0,0 +1,25 @@ +name: Application lab4 +on: [push, pull_request] +permissions: + contents: read +jobs: + application: + runs-on: ubuntu-latest + timeout-minutes: 30 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - run: python scripts/bootstrap.py + - run: docker compose build api s3 + - run: docker compose up -d + - run: python scripts/wait_ready.py --base-url http://localhost:8084 --replicas 2 + - run: make check test PYTHON=python BASE_URL=http://localhost:8084 + - run: docker compose stop reconciler + - run: docker compose run --rm --no-deps -T -v "$PWD:/suite:ro" -w /suite api python student-tests/test_attachments.py + - run: docker compose run --rm --no-deps -T -v "$PWD:/suite:ro" -w /suite api python student-tests/test_reconcile.py + - run: chmod +x scripts/restart.sh scripts/stop-one.sh + - run: make test-persistence PYTHON=python BASE_URL=http://localhost:8084 ACTION_SCRIPT=scripts/restart.sh + - if: always() + run: docker compose down diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..4e389d7a --- /dev/null +++ b/Dockerfile @@ -0,0 +1,12 @@ +FROM python:3.11.10-slim-bookworm@sha256:840e180ebcc6e5c8efab209c43f5e40fd2af98cb49db5c7103c90539c56bb30e +WORKDIR /app +# Приложение работает без прав root. +RUN groupadd -r appuser && useradd -r -g appuser appuser +COPY requirements.lock.txt . +RUN pip install --no-cache-dir -r requirements.lock.txt +COPY src/ src/ +COPY migrations/ migrations/ +USER appuser +HEALTHCHECK --interval=2s --timeout=2s --start-period=10s --retries=3 CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready',timeout=1)" +EXPOSE 8080 +CMD ["python", "-m", "uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "8", "--timeout-keep-alive", "2", "--no-access-log"] diff --git a/Dockerfile.s3 b/Dockerfile.s3 new file mode 100644 index 00000000..b813ecf0 --- /dev/null +++ b/Dockerfile.s3 @@ -0,0 +1,17 @@ +# Reproducible fallback: official MinIO images are unavailable from registries. +FROM golang:1.24.6-bookworm@sha256:ab1d1823abb55a9504d2e3e003b75b36dbeb1cbcc4c92593d85a84ee46becc6c AS build +WORKDIR /build +ADD --checksum=sha256:8819e3e7817e46b7b3798f8f200ead208562e571563c2e040352378031abe9f2 https://github.com/minio/minio/archive/07c3a429bfed433e49018cb0f78a52145d4bedeb.tar.gz /tmp/minio.tar.gz +RUN tar -xzf /tmp/minio.tar.gz --strip-components=1 && CGO_ENABLED=0 go build -trimpath -o /out/minio . +WORKDIR /build-mc +ADD --checksum=sha256:526ec538e7f83e4bfa631788129b08ec85898ca572ce0523ebf9a597946bea27 https://github.com/minio/mc/archive/refs/tags/RELEASE.2025-04-16T18-13-26Z.tar.gz /tmp/mc.tar.gz +RUN tar -xzf /tmp/mc.tar.gz --strip-components=1 && CGO_ENABLED=0 go build -trimpath -o /out/mc . +FROM debian:bookworm-20251020-slim@sha256:78d2f66e0fec9e5a39fb2c72ea5e052b548df75602b5215ed01a17171529f706 +LABEL org.opencontainers.image.source="https://github.com/minio/minio" org.opencontainers.image.revision="07c3a429bfed433e49018cb0f78a52145d4bedeb" +COPY --from=build /build/LICENSE /usr/share/doc/minio/LICENSE +COPY --from=build /build-mc/LICENSE /usr/share/doc/mc/LICENSE +COPY --from=build /out/minio /out/mc /usr/bin/ +COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt +COPY infra/s3-entrypoint.sh /usr/local/bin/s3-entrypoint.sh +ENTRYPOINT ["/bin/sh","/usr/local/bin/s3-entrypoint.sh"] +CMD ["server","/data"] diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..563e3d8a 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,274 @@ -# Отчёт — лабораторная 4 +# Отчёт — лабораторная работа №4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +Автор: **Ляхонов Сергей**, группа **БВТ2301**. Дата: **30 октября 2026 года**. +Целевая оценка: **5**, выбран **трек 2 — согласованность двух хранилищ**. Пользователь выбрал трек до реализации. +Ветка: `solution/BVT2301-lyakhonov`. Только локальные русскоязычные коммиты; push и PR не выполнялись. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Engine/Compose с Linux-контейнерами, Python 3.12+ на хосте и make (самим публичным тестам достаточно Python 3.9+) (либо прямые эквивалентные Python-команды ниже). +Проверено: Windows, Python хоста 3.13.7, Docker Engine 28.5.1 / Docker Desktop, i5-1340P, 16 логических CPU и 16 GB RAM. +Docker VM: 16 CPU, 8 126 664 704 bytes RAM. См. [CPU](evidence/cpu.json), [RAM](evidence/hardware.json), [Docker](evidence/docker-resources.json). +Для сборки исходников S3 и всех экспериментов разумно выделить Docker около 8 GB RAM и иметь около 10 GB свободного диска под build cache/образы/учебные данные. +Постоянные runtime-лимиты стенда: суммарно 4 CPU и 2816 MiB; генератор и одноразовые сервисы требуют дополнительного ресурса. +Это лимиты, а не гарантированное фактическое потребление. -## Архитектура и решения +PowerShell, из корня лабораторной 4: -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```powershell +$env:PYTHONUTF8='1' +python scripts/bootstrap.py +docker compose --env-file .env config --quiet +docker compose --env-file .env build api s3 +docker compose --env-file .env up -d +python scripts/wait_ready.py --base-url http://localhost:8084 --replicas 2 +make check test PYTHON=python BASE_URL=http://localhost:8084 +python -m venv .venv +.venv/Scripts/python -m pip install -r requirements-research.txt +make validate PYTHON=.venv/Scripts/python +``` + +Bootstrap создаёт случайные DB/S3 secrets и `.env` из `lab4.env.example` **только при отсутствии**; существующие файлы сохраняются. +Пароли и ключи не выводятся и не попадают в Git. Отдельный migrate применяет версии 001–003 под advisory lock до старта API. +Bucket-init создаёт приватный bucket и ограниченного пользователя приложения; повтор безопасен. +Все зависимости запускаются из этого репозитория; установленные ранее БД/S3 не используются. + +Реестр отказал в скачивании официальных образов MinIO/mc (Docker Hub denied, Quay 401), поэтому окончательный стенд +собирает S3 из исходников через `Dockerfile.s3`: MinIO commit `07c3a429bfed433e49018cb0f78a52145d4bedeb` +(исходники RELEASE.2025-09-07T16-13-09Z), mc RELEASE.2025-04-16T18-13-26Z. +Оба архива закреплены SHA-256 в ADD; Go и Debian закреплены digest, Go-зависимости проверяются go.sum. +Первичная сборка реально прошла, повтор использует build cache. Нужен доступ к GitHub, Docker Hub и Go module proxy; +наличие локального старого MinIO-образа не требуется. Версия самосборного бинарника может выводиться как DEVELOPMENT.GOGET; +точная идентичность задаётся commit и архивом, не этой строкой. Лицензии MinIO/mc AGPL включены в образ. +[Контрольные суммы](evidence/s3-source-hashes.json), [рецепт](Dockerfile.s3). + +Остановка без удаления данных: `docker compose down`. Стенд №3 не затрагивается. +Только при намеренном удалении собственных учебных данных: `docker compose down --volumes`. +Последняя команда необратима; в проверках основного стенда она не используется. Одноразовый стенд проверки чистого экспорта удаляет только собственные вновь созданные scratch volumes. Внешние volumes и чужие Compose projects не удаляются. +На POSIX использовать python3 и executable `.sh` hooks (`chmod +x scripts/restart.sh scripts/stop-one.sh`). + +Чистый Git-экспорт коммита `6c87ed2` отдельно проверен скриптом `python scripts/verify_clean_export.py`: +новые secrets, уникальные project/images/volumes и свободный loopback-порт; сборка API/S3, две готовые реплики и публичный smoke прошли. +Основные стенды не изменялись. После проверки одноразовые контейнеры/сеть/тома удалены. +[Результат](evidence/clean-export.json), [сборка](evidence/repro-build.txt). + +## Архитектура и конфигурация + +```mermaid +flowchart LR + Client[Клиент] --> LB[HAProxy localhost:8084] + LB --> API1[API 1] + LB --> API2[API 2] + API1 --> DB[(PostgreSQL: метаданные и сессии)] + API2 --> DB + API1 --> S3[(MinIO: приватные оригиналы)] + API2 --> S3 + API1 --> Redis[(Redis: необязательный кэш профилей)] + API2 --> Redis + Reconciler[Периодическая сверка] --> DB + Reconciler --> S3 +``` + +| Роль → service | Версия / CPU / RAM | Готовность / durable state / доступ | +| --- | --- | --- | +| API → api ×2 | Python 3.11.10, lock dependencies; 0.5 CPU / 512 MiB каждая | `/health/ready`: PostgreSQL + S3; без durable локальных оригиналов; только внутренняя сеть | +| БД → db | PostgreSQL 16.6-alpine; 1 CPU / 512 MiB | pg_isready; отдельный postgres_data; порт не опубликован | +| S3 → s3 | Собственная сборка из закреплённых исходников; 1 CPU / 768 MiB | bootstrap ждёт S3; API проверяет LIST рабочего prefix; отдельный s3_data; без внешних портов | +| LB → lb | HAProxy 3.0.6-alpine; 0.5 CPU / 128 MiB | HTTP readiness API; только 127.0.0.1:8084 | +| Кэш → redis | Redis 7.4.1-alpine; 0.25 CPU / 128 MiB | Необязателен; профили, без сессий/истории; persistence отключён | +| Миграции → migrate | Тот же исходный образ; 0.5 CPU / 512 MiB | Одноразовый exit 0 до API, schema_migrations | +| Bucket bootstrap → bucket-init | Тот же S3-образ, mc; 0.25 CPU / 128 MiB | Одноразовый exit 0; приватность и политика; root secrets доступны только здесь и S3 | +| Сверка → reconciler | Тот же исходный образ; 0.25 CPU / 256 MiB | Apply каждые 300 с, grace 3600 с; отдельный процесс, restart unless-stopped | + +Compose project `lyakhonov-lab4`, собственные сеть, `lyakhonov-lab4_postgres_data`, `lyakhonov-lab4_s3_data`, +образы `lyakhonov-messenger:lab4` и `lyakhonov-storage:lab4`. Нет container_name и наружных портов API/БД/S3/Redis. +Консоль MinIO слушает только loopback самого S3-контейнера. Пароли передаются через read-only Compose secrets files. +Приложение имеет S3 LIST только своего bucket/prefix и Get/Put/Delete только `attachments/originals/*`; +не имеет административного доступа, list buckets, delete bucket или записи вне prefix. Bucket — `attachments`, публичного чтения нет. +API работает без root. Единственные PostgreSQL, S3, LB и Docker-host остаются SPOF. + +`lab4.env.example` задаёт реальные пользовательские параметры LAB4_PORT, API_REPLICAS, API_CPUS, API_MEMORY, +POOL_SIZE, SESSION_TTL_SECONDS и OPTIMIZED_WRITES. Исходный `.env.example` skeleton сохранён как список логических интерфейсов: +APP_HOST/APP_PORT соответствуют фиксированному listener 0.0.0.0:8080; APP_ENV не используется; SESSION_STORE=postgres фиксирован; +CACHE_URL_FILE заменён внутренним CACHE_URL=redis://redis:6379/0; DATABASE_URL_FILE совпадает. +S3_ENDPOINT и регион совпадают; S3_BUCKET в решении фиксирован `attachments` вместо предложенного messenger-attachments. +S3_ACCESS_KEY_ID_FILE/S3_SECRET_ACCESS_KEY_FILE отображаются на внутренние S3_ACCESS_KEY_FILE/S3_SECRET_KEY_FILE. +IDEMPOTENCY_TTL_SECONDS=86400, MAX_UPLOAD_BYTES=10485760, MAX_IMAGE_PIXELS=40000000 — обязательные фиксированные лимиты, +не произвольные пользовательские настройки. Изменение старого `.env.example` не меняет эти внутренние значения. + +## Перенос и границы транзакций + +Источник: собственная лабораторная №3, HEAD `374c43e`, только чтение. Оба рабочих дерева до начала были чистыми. +Перенесены исходники, миграции, зависимости, Dockerfile и необходимые конфигурации/scripts. +README, COURSE, обязательные contracts, публичные tests и fixture лабораторной №4 сохранены. +Не переносились .git, .env, secrets, volumes, venv, старые измерения/графики. [Акт переноса](evidence/transfer.md). + +Сохранены PostgreSQL-сессии, Argon2id, ACL чатов, пагинация, две реплики и общая транзакционная идемпотентность. +В отличие от lab3, Message теперь всегда содержит attachment_ids; допускает пустой текст с вложениями. +Ключ сравнивает полный нормализованный body, включая порядок ID; отсутствующее attachment_ids равно []. +Результат ключа, Message и связи вложений фиксируются атомарно. Конкурентные повторы сериализуются общей блокировкой. +Миграция 003 переносит старые текстовые результаты ключей в JSON и добавляет Attachment/message_attachments. +Обратное смешивание lab3/lab4 API после этой миграции не поддерживается: требуется согласованный переход. +В этой работе использован новый отдельный volume, исходная БД lab3 не изменялась. + +Upload: авторизация/ACL → bounded temporary spool → MIME/размер/пиксели/verify/load → уникальный S3 PUT → INSERT → COMMIT → 201 ready. +Оригинал сохраняется побайтно. Приём <=10 MiB, <=40 млн px; один декодер на реплику, <=20 с на body, <=25 с ожидания слота. +Только временный spool живёт локально до PUT; download читает S3 блоками 64 KiB без redirect. +S3 timeout connect=2/read=5 с и без retry, LB client=60/server=45 с и без повторов POST. +Неопределённый COMMIT не вызывает слепое удаление объекта. Подробный протокол и инварианты: [infra/reconciliation.md](infra/reconciliation.md). ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий | Команда/сценарий | Реальный результат / доказательство | +| --- | --- | --- | +| Обязательная база lab3 и контракт lab4 | make check/test/validate | PASS: [make](evidence/make-check-test.txt), [validate](evidence/validate.txt) | +| Upload 201 ready, сообщение, checksum, ACL | публичный smoke | PASS: [smoke](evidence/smoke.txt); PNG/JPEG неизменны | +| ≥2 API, остановка именно загрузившей реплики | python student-tests/test_operations.py | Обе разные реальные реплики остановлены по очереди; другой процесс вернул оригинал: [JSON](evidence/operations.json) | +| Retry и сохранность при failover | публичный resilience --mode failover | PASS, ошибки перехода учтены: [1](evidence/failover-1.txt), [2](evidence/failover-2.txt) | +| Рестарт с volumes и прежней сессией | публичный persistence + test_operations.py | PASS, реальные StartedAt до/после API/БД/Redis/S3/LB: [persistence](evidence/persistence.txt), [operations](evidence/operations.json) | +| S3 недоступен / восстановлен | test_operations.py | Ограниченный 503, после восстановления те же bytes и сессия | +| Bytes/пиксели/MIME/filename/повреждения | test_attachments.py | PASS, включая chunked body >10 MiB, >40 млн px и допустимые ровно 40 млн px: [negative suite](evidence/attachments.txt) | +| Чужой ID, другой чат, дубли ID | test_attachments.py | 404/400, без 500 | +| Обрыв body | реальный TCP disconnect | Постоянный объект не создан | +| Сбой после PUT до INSERT | ограниченный synthetic DB trigger | Получен 500, объект найден сверкой как orphan; trigger снят в finally | +| Ограничение RAM при ≥10 загрузках | python scripts/run_upload_load.py | 60/60 успешно, два размера, cgroup peak и Docker stats: [raw](evidence/upload-load.json), [CSV](evidence/upload-summary.csv) | +| Приватность и минимальные S3-права | unsigned GET + запрещённые S3 API | 403; отдельные credentials приложения: [suite](evidence/attachments.txt) | +| Идемпотентный bucket bootstrap | docker compose run --rm --no-deps bucket-init | Повтор exit 0: [вывод](evidence/bootstrap-repeat.txt) | +| Orphan/missing/corrupt | test_reconcile.py | Найдены; old orphan удалены; missing/corrupt изолированы без удаления метаданных | +| Dry-run, повтор и конкуренция | test_reconcile.py | Все метаданные до/после dry-run совпали; блокировка/свежесть/ссылки сохранены; два прохода безопасны | +| Безопасное восстановление | неверный, затем правильный оригинал | Неверные bytes не вернули ready; проверенный оригинал восстановил его: [исследование](evidence/reconcile.json) | +| Стоимость обхода | 0/50/200 дополнительных объектов ×3 | Время, LIST/HEAD/GET и bytes измерены, график ниже | + +## Эксперимент загрузки и память + +Фиксированный seed, PNG RGB 1024² и 1792², один прогрев на размер. Три партии по 10 клиентов на размер через LB, +прозрачных retry нет. Клиенты готовы до начала измерительного окна; все одновременно отпускаются event. +Суммарное timed elapsed для шести партий — 6.966 с; это короткий опыт, не steady-state soak test. +Elapsed включает завершение всех запросов, не подготовку клиентов и не последующее скачивание подтверждённых оригиналов. +p50/p95/p99 интерполируются линейно по успешным запросам; при 10 наблюдениях хвост оценён грубо. +Генератор — отдельный контейнер с 0.5 CPU / 512 MiB. API пересозданы перед замером; фоновая сверка остановлена и затем восстановлена. +Не менялись ресурсы/версии между размерами. Это closed-loop партии, без контроля arrival rate и с coordinated omission; +универсальная максимальная пропускная способность не заявляется. Ранние пилоты с подготовкой клиента внутри окна заменены этой серией. + +| Размер PNG, bytes | Успехи / попытки | RPS, медиана | p50 / p95 / p99, с (медианы) | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| 3151219 | 30 / 30 | 16.73 | 0.408 / 0.585 / 0.591 | +| 9648062 | 30 / 30 | 5.63 | 1.061 / 1.716 / 1.764 | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +![Скорость и задержка загрузки](evidence/figures/upload-throughput.png) -## Эксперименты и отказы +![Память API](evidence/figures/upload-memory.png) -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Docker stats показывает выборочный working set, cgroup memory.peak — kernel high-water mark за жизнь новых API-контейнеров +(включает старт, прогрев, загрузки и проверку скачивания). Эти два показателя различаются учётом cache и частотой наблюдения. +- API `68ab8db39c84`: kernel peak **167.95 MiB** при лимите 512 MiB. +- API `a6106479affd`: kernel peak **156.98 MiB** при лимите 512 MiB. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +Для CPU 100% Docker stats означает одно логическое ядро. Сырые CPU%/RAM, временные метки и cpu.stat сохранены +в upload-load.json; sampled memory для API ниже лимита. Выборки включают прогрев, подготовку клиентов и скачивание, поэтому это не интеграл CPU только внутри timed batches. + +| Служба | CPU%, медиана / максимум выборок | +| --- | --- | +| lyakhonov-lab4-api-1 | 7.90 / 49.68 | +| lyakhonov-lab4-api-2 | 7.60 / 51.60 | +| lyakhonov-lab4-db-1 | 1.54 / 4.78 | +| lyakhonov-lab4-lb-1 | 2.25 / 12.86 | +| lyakhonov-lab4-s3-1 | 1.21 / 27.30 | + + Это не доказательство нулевых аллокаций: +декодер допустимого 40 MP изображения может занять порядка 160 MB дополнительно; одновременно декодируется одна картинка на процесс. + +## Исследование согласованности: гипотеза и результаты + +Гипотеза: PostgreSQL/S3 нельзя объединить обычным локальным COMMIT; безопасная периодическая сверка с общей блокировкой +и защитным интервалом убирает orphan и отмечает missing, сохраняя свежие и используемые вложения. +Цена — обход всех объектов/строк и чтение подтверждаемых bytes, поэтому она растёт с числом объектов и объёмом оригиналов. + +Методика: реальный INSERT отказал после PUT; отдельно удалён S3-оригинал уже привязанного к сообщению вложения. +Созданы старый orphan, свежий orphan и объект под удерживаемой общей блокировкой (имитация окна upload до COMMIT). +Dry-run сверяет полный снимок id/state/updated_at; apply удаляет только безопасные orphan и ставит missing. +Следующий проход не дублирует изменение state. После снятия блокировки/истечения grace ранее защищённые orphan могут быть удалены — +это ожидаемое продолжение очистки, а не ошибка идемпотентности. Существующие строки Attachment защищаются независимо от возраста и наличия сообщения. +Два конкурентных reconciler пропускают занятые ключи. Неверные bytes оставляют missing; корректные bytes возвращают ready; +связь с исходным сообщением сохраняется. Тестовый grace=5 с, ожидание старения=6 с; рабочий default=3600 с. +[Полные агрегаты](evidence/reconcile.json), [сценарий](student-tests/test_reconcile.py). + +Измерение стоимости: фиксированный набор метаданных и оригиналов, добавляются 0/50/200 неучтённых объектов по 1 KiB. +По три dry-run на точку, page_size=50; сервис периодической сверки остановлен, другая нагрузка не запускается. +Порядок 0→50→200; cache состояния не сбрасывался. Выигрыш/регрессию оптимизации этот опыт не измеряет. + +| Всего объектов | Время, медиана [min; max], с | LIST / HEAD / GET | Проверено bytes за проход | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| 221 | 4.964 [4.835; 5.073] | 5 / 221 / 221 | 1193831654 | +| 271 | 5.185 [4.994; 5.314] | 6 / 271 / 221 | 1193831654 | +| 421 | 6.356 [6.225; 6.826] | 9 / 421 / 221 | 1193831654 | -## Ограничения и следующие шаги +![Стоимость сверки](evidence/figures/reconcile-cost.png) -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +В этой серии GET/проверенные bytes постоянны, рост дополнительных orphan увеличивает HEAD и LIST. +Это подтверждает рост цены обхода; три повтора и небольшой bucket не доказывают асимптотическую производительность большой инсталляции. +Чтение всех оригиналов ради проверки SHA-256 может доминировать над числом объектов. RAM ограничена страницей и chunk 64 KiB, +но трафик и общее время не являются константными. Между страницами нет общего snapshot: проход eventually consistent, +новые записи/пропуски блокировок проверяются следующим запуском. + +## Воспроизведение и отказы + +```powershell +docker compose stop reconciler +docker compose run --rm --no-deps -T -v "${PWD}:/suite:ro" -w /suite api python student-tests/test_attachments.py +docker compose run --rm --no-deps -T -v "${PWD}:/suite:ro" -w /suite api python student-tests/test_reconcile.py +docker compose start reconciler +python student-tests/test_operations.py +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:8084 +python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://localhost:8084 +docker compose start api +docker compose up -d --no-deps --force-recreate api +python scripts/wait_ready.py --base-url http://localhost:8084 --replicas 2 +python scripts/run_upload_load.py +.venv/Scripts/python scripts/plot_results.py +# Dry-run вручную: +docker compose run --rm --no-deps api python -m src.reconcile +``` + +Собственные suites создают данные; повтор увеличивает набор и меняет результаты времени, это не фиксированный golden benchmark. +Графики Matplotlib 3.10.7 построены из сохранённых JSON, PNG и SVG лежат в evidence/figures. +Отключённый сервис после ручных опытов следует восстановить; нагрузочный runner делает это в finally. +Подробности, включая временный DB trigger и восстановление после аварийного завершения suite: [student-tests/README.md](student-tests/README.md). + +| Воздействие | Наблюдение | Сохранность / граница | +| --- | --- | --- | +| Остановлена lyakhonov-lab4-api-1 | Download через другую API за 1.286 с от начала действия | SHA-256 совпал, target реально остановлен | +| Остановлена lyakhonov-lab4-api-2 | Download через другую API за 1.406 с от начала действия | SHA-256 совпал, target реально остановлен | +| Остановка S3 | Первый 503 за 4.043 с | После восстановления прежние bytes/сессия; при исключении обеих API весь LB недоступен | +| Рестарт API/БД/Redis/S3/LB | StartedAt изменились у всех | Подтверждённые данные и прежний токен сохранены | +| PUT прошёл, INSERT отказал | 500 + orphan | Reconciler удалил после grace; слепой rollback S3 не применяется | +| Утрата/порча используемого оригинала | missing / API 503 | Метаданные/ссылки не удалены; нужен правильный оригинал из backup | + +В ранних публичных failover-прогонах: 109 подтверждённых записей в каждом, 2 и 3 ошибки перехода, +первая успешная запись после начала hook через 2.439 и 2.442 с. Пользовательские операции не выдаются за мгновенный failover. +Публичный hook выбирает заданный процесс; отдельный test_operations доказывает остановку обеих именно загрузивших реплик. + +## Ограничения и источники + +Сверка обнаруживает утрату и возвращает состояние после восстановления из внешней копии, но не создаёт потерянные bytes из hash. +HTTP только localhost и синтетические данные. +Ключевые инварианты предполагают, что все писатели рабочего S3 namespace соблюдают общий протокол блокировки; +администратор с root credentials может его нарушить. Обрыв download после отправки headers может оборвать поток: +200 headers сами по себе не гарантируют полный файл, клиент проверяет длину/checksum. +Нагрузочные результаты зависят от Docker Desktop, CPU-квот, клиента и dataset; SLA и максимальные RPS не заявляются. +Добавлен отдельный application workflow без production secrets/privileged PR trigger. + +Использованы собственная лабораторная 3 и материалы курса; FastAPI/Uvicorn/Pydantic, psycopg, Redis, Argon2, boto3/botocore, +Pillow (версии в requirements.lock.txt), Matplotlib для графиков. Реализация, проверки, анализ и отчёт подготовлены с помощью Codex. +Исходный контракт и публичные проверки преподавателя не ослаблялись. + +Первичные источники: [Pillow Image / verify / pixel limits](https://pillow.readthedocs.io/en/stable/reference/Image.html), +[S3 PUT и условная запись](https://docs.aws.amazon.com/boto3/latest/reference/services/s3/client/put_object.html), +[LIST pagination](https://docs.aws.amazon.com/boto3/latest/reference/services/s3/paginator/ListObjectsV2.html), +[исходники MinIO](https://github.com/minio/minio/tree/07c3a429bfed433e49018cb0f78a52145d4bedeb), +[исходники mc](https://github.com/minio/mc/tree/RELEASE.2025-04-16T18-13-26Z), +[PostgreSQL advisory locks](https://www.postgresql.org/docs/16/explicit-locking.html#ADVISORY-LOCKS). + +Этапы истории: `2e5f5bf` — перенос; `4f85fb9` — обязательный минимум; `9dded97` — уровень 4; +`6c87ed2` — трек 2, графики и отчёт; последующий коммит сохраняет проверку чистого экспорта и заключительный аудит. +Манифест source-файлов использует UTF-8/LF, чтобы перенос строк Windows/Linux не менял контрольные суммы. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..38546b68 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,123 @@ +name: lyakhonov-lab4 +x-api: &api + image: lyakhonov-messenger:lab4 + build: . + environment: + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + POOL_SIZE: ${POOL_SIZE:-10} + S3_ENDPOINT: http://s3:9000 + S3_BUCKET: attachments + S3_ACCESS_KEY_FILE: /run/secrets/s3_access_key + S3_SECRET_KEY_FILE: /run/secrets/s3_secret_key + OPTIMIZED_WRITES: ${OPTIMIZED_WRITES:-1} + secrets: [database_url, s3_access_key, s3_secret_key] + depends_on: + migrate: + condition: service_completed_successfully + cpus: ${API_CPUS:-0.5} + mem_limit: ${API_MEMORY:-512m} + stop_grace_period: 12s +services: + db: + image: postgres:16.6-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/db_password + secrets: [db_password] + volumes: [postgres_data:/var/lib/postgresql/data] + healthcheck: + test: [CMD-SHELL, "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 2s + retries: 30 + cpus: 1 + mem_limit: 512m + redis: + image: redis:7.4.1-alpine + command: [redis-server, --maxmemory, 64mb, --maxmemory-policy, allkeys-lru, --save, "", --appendonly, "no"] + cpus: 0.25 + mem_limit: 128m + migrate: + <<: *api + command: [python, -m, src.migrate] + depends_on: + db: + condition: service_healthy + healthcheck: + disable: true + s3: + image: lyakhonov-storage:lab4 + build: + context: . + dockerfile: Dockerfile.s3 + command: [server, /data, --console-address, '127.0.0.1:9001'] + environment: + MINIO_ROOT_USER_FILE: /run/secrets/s3_root_user + MINIO_ROOT_PASSWORD_FILE: /run/secrets/s3_root_password + secrets: [s3_root_user, s3_root_password] + volumes: [s3_data:/data] + cpus: 1 + mem_limit: 768m + bucket-init: + image: lyakhonov-storage:lab4 + pull_policy: never + cpus: 0.25 + mem_limit: 128m + entrypoint: [/bin/sh, /bootstrap/bucket.sh] + secrets: [s3_root_user, s3_root_password, s3_access_key, s3_secret_key] + volumes: [./infra/bucket.sh:/bootstrap/bucket.sh:ro, ./infra/s3-policy.json:/bootstrap/policy.json:ro] + depends_on: [s3] + api: + <<: *api + depends_on: + migrate: + condition: service_completed_successfully + bucket-init: + condition: service_completed_successfully + deploy: + replicas: ${API_REPLICAS:-2} + reconciler: + <<: *api + command: [python, -m, src.reconcile, --apply, --interval, '300'] + restart: unless-stopped + cpus: 0.25 + mem_limit: 256m + healthcheck: + disable: true + depends_on: + migrate: + condition: service_completed_successfully + bucket-init: + condition: service_completed_successfully + lb: + image: haproxy:3.0.6-alpine + ports: ["127.0.0.1:${LAB4_PORT:-8084}:8080"] + volumes: [./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro] + depends_on: [api] + cpus: 0.5 + mem_limit: 128m + stop_grace_period: 12s + healthcheck: + test: [CMD, haproxy, -c, -f, /usr/local/etc/haproxy/haproxy.cfg] + interval: 5s + timeout: 2s + retries: 3 +secrets: + s3_root_user: + file: ./secrets/s3_root_user + s3_root_password: + file: ./secrets/s3_root_password + s3_access_key: + file: ./secrets/s3_access_key + s3_secret_key: + file: ./secrets/s3_secret_key + db_password: + file: ./secrets/db_password + database_url: + file: ./secrets/database_url +volumes: + postgres_data: + s3_data: diff --git a/evidence/attachments.txt b/evidence/attachments.txt new file mode 100644 index 00000000..c855b42e --- /dev/null +++ b/evidence/attachments.txt @@ -0,0 +1 @@ +{"result": "PASS", "concurrent_retries": 16, "failure_after_s3_put": true, "interrupted_upload_no_object": true, "private_bucket": true, "restricted_credentials": true} diff --git a/evidence/audit.txt b/evidence/audit.txt new file mode 100644 index 00000000..98368796 --- /dev/null +++ b/evidence/audit.txt @@ -0,0 +1 @@ +PASS: original materials unchanged; specified author/committer; no generated secrets in tracked/nonignored files; lab3 unchanged diff --git a/evidence/bootstrap-repeat.txt b/evidence/bootstrap-repeat.txt new file mode 100644 index 00000000..b7e057c3 --- /dev/null +++ b/evidence/bootstrap-repeat.txt @@ -0,0 +1 @@ +Private bucket and restricted application user ready diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 00000000..b62af9c5 --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1 @@ +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/clean-export.json b/evidence/clean-export.json new file mode 100644 index 00000000..b418b2fc --- /dev/null +++ b/evidence/clean-export.json @@ -0,0 +1,15 @@ +{ + "commit": "6c87ed2eba11e7f7d8a58aaab9844b8d202b4c46", + "project": "lyakhonov-lab4-repro-db8d7e24", + "port": 53378, + "fresh_secrets": true, + "isolated_images": true, + "result": "PASS", + "readiness": "PASS: API ready, replicas: 2", + "smoke": "PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.", + "scratch_volumes": [ + "lyakhonov-lab4-repro-db8d7e24_postgres_data", + "lyakhonov-lab4-repro-db8d7e24_s3_data" + ], + "scratch_cleaned": true +} \ No newline at end of file diff --git a/evidence/cpu.json b/evidence/cpu.json new file mode 100644 index 00000000..11aa23a8 --- /dev/null +++ b/evidence/cpu.json @@ -0,0 +1,5 @@ +{ + "Name": "13th Gen Intel(R) Core(TM) i5-1340P", + "NumberOfCores": 12, + "NumberOfLogicalProcessors": 16 +} diff --git a/evidence/docker-resources.json b/evidence/docker-resources.json new file mode 100644 index 00000000..8491cc0d --- /dev/null +++ b/evidence/docker-resources.json @@ -0,0 +1,8 @@ +{ + "ServerVersion": "28.5.1", + "NCPU": 16, + "MemTotal": 8126664704, + "OSType": "linux", + "OperatingSystem": "Docker Desktop", + "Architecture": "x86_64" +} diff --git a/evidence/failover-1.txt b/evidence/failover-1.txt new file mode 100644 index 00000000..8c478f30 --- /dev/null +++ b/evidence/failover-1.txt @@ -0,0 +1,3 @@ +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 109, "failed_attempts": 2, "first_recovery_seconds": 2.439} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/failover-2.txt b/evidence/failover-2.txt new file mode 100644 index 00000000..180e5083 --- /dev/null +++ b/evidence/failover-2.txt @@ -0,0 +1,3 @@ +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 109, "failed_attempts": 3, "first_recovery_seconds": 2.442} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/figures/reconcile-cost.png b/evidence/figures/reconcile-cost.png new file mode 100644 index 00000000..458e0b8c Binary files /dev/null and b/evidence/figures/reconcile-cost.png differ diff --git a/evidence/figures/reconcile-cost.svg b/evidence/figures/reconcile-cost.svg new file mode 100644 index 00000000..8c6f7f6e --- /dev/null +++ b/evidence/figures/reconcile-cost.svg @@ -0,0 +1,2322 @@ + + + + + + + + 2026-10-30T17:49:09.849194 + image/svg+xml + + + Matplotlib v3.10.7, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/evidence/figures/upload-memory.png b/evidence/figures/upload-memory.png new file mode 100644 index 00000000..81968138 Binary files /dev/null and b/evidence/figures/upload-memory.png differ diff --git a/evidence/figures/upload-memory.svg b/evidence/figures/upload-memory.svg new file mode 100644 index 00000000..fca43770 --- /dev/null +++ b/evidence/figures/upload-memory.svg @@ -0,0 +1,1715 @@ + + + + + + + + 2026-10-30T17:49:10.393928 + image/svg+xml + + + Matplotlib v3.10.7, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/evidence/figures/upload-throughput.png b/evidence/figures/upload-throughput.png new file mode 100644 index 00000000..126c709a Binary files /dev/null and b/evidence/figures/upload-throughput.png differ diff --git a/evidence/figures/upload-throughput.svg b/evidence/figures/upload-throughput.svg new file mode 100644 index 00000000..3ff1bf44 --- /dev/null +++ b/evidence/figures/upload-throughput.svg @@ -0,0 +1,2006 @@ + + + + + + + + 2026-10-30T17:49:10.222436 + image/svg+xml + + + Matplotlib v3.10.7, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/evidence/final-check-test.txt b/evidence/final-check-test.txt new file mode 100644 index 00000000..be2183ec --- /dev/null +++ b/evidence/final-check-test.txt @@ -0,0 +1,4 @@ +python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +python tests/smoke.py --base-url "http://localhost:8084" +PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/hardware.json b/evidence/hardware.json new file mode 100644 index 00000000..e1b6346e --- /dev/null +++ b/evidence/hardware.json @@ -0,0 +1,4 @@ +{ + "NumberOfLogicalProcessors": 16, + "TotalPhysicalMemory": 16778182656 +} diff --git a/evidence/level4.json b/evidence/level4.json new file mode 100644 index 00000000..4052dec6 --- /dev/null +++ b/evidence/level4.json @@ -0,0 +1,44 @@ +{ + "negative_suite": { + "result": "PASS", + "concurrent_retries": 16, + "failure_after_s3_put": true, + "interrupted_upload_no_object": true, + "private_bucket": true, + "restricted_credentials": true + }, + "uploads": [ + { + "size_bytes": 3151219, + "successful_rps_median": 16.729828936800814, + "p50_seconds_median": 0.4081998335022945, + "p95_seconds_median": 0.584588757907477, + "p99_seconds_median": 0.5914236595887633, + "errors": 0, + "attempts": 30, + "elapsed_seconds": 1.8537453600001754 + }, + { + "size_bytes": 9648062, + "successful_rps_median": 5.626450903085569, + "p50_seconds_median": 1.0610903210035758, + "p95_seconds_median": 1.7164175714497103, + "p99_seconds_median": 1.7635092142925715, + "errors": 0, + "attempts": 30, + "elapsed_seconds": 5.111771299998509 + } + ], + "kernel_memory_peak_mib": { + "68ab8db39c84": 167.9453125, + "a6106479affd": 156.98046875 + }, + "sampled_memory_max_mib": { + "lyakhonov-lab4-api-1": 157.2, + "lyakhonov-lab4-api-2": 149.2, + "lyakhonov-lab4-db-1": 40.3, + "lyakhonov-lab4-lb-1": 17.27, + "lyakhonov-lab4-s3-1": 312.1 + }, + "cleanup_mechanism": "src.reconcile, grace 3600 seconds, interval 300 seconds; explicit 5-second synthetic test in track evidence" +} \ No newline at end of file diff --git a/evidence/make-check-test.txt b/evidence/make-check-test.txt new file mode 100644 index 00000000..be2183ec --- /dev/null +++ b/evidence/make-check-test.txt @@ -0,0 +1,4 @@ +python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +python tests/smoke.py --base-url "http://localhost:8084" +PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/operations.json b/evidence/operations.json new file mode 100644 index 00000000..5e003977 --- /dev/null +++ b/evidence/operations.json @@ -0,0 +1,168 @@ +{ + "result": "PASS", + "each_uploading_replica_stopped": [ + { + "stopped": { + "id": "550435eb1893", + "hostname": "550435eb1893", + "name": "lyakhonov-lab4-api-1", + "running": true, + "started_at": "2026-10-30T14:38:55.142398594Z", + "project": "lyakhonov-lab4" + }, + "after": { + "id": "550435eb1893", + "hostname": "550435eb1893", + "name": "lyakhonov-lab4-api-1", + "running": false, + "started_at": "2026-10-30T14:38:55.142398594Z", + "project": "lyakhonov-lab4" + }, + "download_instance": "5c0c5d76b6ee-fbcdf384", + "sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75", + "recovery_seconds": 1.286 + }, + { + "stopped": { + "id": "5c0c5d76b6ee", + "hostname": "5c0c5d76b6ee", + "name": "lyakhonov-lab4-api-2", + "running": true, + "started_at": "2026-10-30T14:38:54.95782885Z", + "project": "lyakhonov-lab4" + }, + "after": { + "id": "5c0c5d76b6ee", + "hostname": "5c0c5d76b6ee", + "name": "lyakhonov-lab4-api-2", + "running": false, + "started_at": "2026-10-30T14:38:54.95782885Z", + "project": "lyakhonov-lab4" + }, + "download_instance": "550435eb1893-4bee0210", + "sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75", + "recovery_seconds": 1.406 + } + ], + "s3_503_seconds": 4.043458599830046, + "restart_before": { + "api": [ + { + "id": "550435eb1893", + "hostname": "550435eb1893", + "name": "lyakhonov-lab4-api-1", + "running": true, + "started_at": "2026-10-30T14:40:54.440796232Z", + "project": "lyakhonov-lab4" + }, + { + "id": "5c0c5d76b6ee", + "hostname": "5c0c5d76b6ee", + "name": "lyakhonov-lab4-api-2", + "running": true, + "started_at": "2026-10-30T14:40:59.474039309Z", + "project": "lyakhonov-lab4" + } + ], + "db": [ + { + "id": "10138b5c0bee", + "hostname": "10138b5c0bee", + "name": "lyakhonov-lab4-db-1", + "running": true, + "started_at": "2026-10-30T14:32:12.605184626Z", + "project": "lyakhonov-lab4" + } + ], + "redis": [ + { + "id": "68997bbba33b", + "hostname": "68997bbba33b", + "name": "lyakhonov-lab4-redis-1", + "running": true, + "started_at": "2026-10-30T14:32:12.532082166Z", + "project": "lyakhonov-lab4" + } + ], + "s3": [ + { + "id": "8d6296c66f50", + "hostname": "8d6296c66f50", + "name": "lyakhonov-lab4-s3-1", + "running": true, + "started_at": "2026-10-30T14:41:07.545035588Z", + "project": "lyakhonov-lab4" + } + ], + "lb": [ + { + "id": "e9682a892ad3", + "hostname": "e9682a892ad3", + "name": "lyakhonov-lab4-lb-1", + "running": true, + "started_at": "2026-10-30T14:32:13.55378444Z", + "project": "lyakhonov-lab4" + } + ] + }, + "restart_after": { + "api": [ + { + "id": "550435eb1893", + "hostname": "550435eb1893", + "name": "lyakhonov-lab4-api-1", + "running": true, + "started_at": "2026-10-30T14:41:12.906035738Z", + "project": "lyakhonov-lab4" + }, + { + "id": "5c0c5d76b6ee", + "hostname": "5c0c5d76b6ee", + "name": "lyakhonov-lab4-api-2", + "running": true, + "started_at": "2026-10-30T14:41:12.736844839Z", + "project": "lyakhonov-lab4" + } + ], + "db": [ + { + "id": "10138b5c0bee", + "hostname": "10138b5c0bee", + "name": "lyakhonov-lab4-db-1", + "running": true, + "started_at": "2026-10-30T14:41:12.415067466Z", + "project": "lyakhonov-lab4" + } + ], + "redis": [ + { + "id": "68997bbba33b", + "hostname": "68997bbba33b", + "name": "lyakhonov-lab4-redis-1", + "running": true, + "started_at": "2026-10-30T14:41:12.598940634Z", + "project": "lyakhonov-lab4" + } + ], + "s3": [ + { + "id": "8d6296c66f50", + "hostname": "8d6296c66f50", + "name": "lyakhonov-lab4-s3-1", + "running": true, + "started_at": "2026-10-30T14:41:12.309884842Z", + "project": "lyakhonov-lab4" + } + ], + "lb": [ + { + "id": "e9682a892ad3", + "hostname": "e9682a892ad3", + "name": "lyakhonov-lab4-lb-1", + "running": true, + "started_at": "2026-10-30T14:41:12.504270669Z", + "project": "lyakhonov-lab4" + } + ] + } +} \ No newline at end of file diff --git a/evidence/operations.txt b/evidence/operations.txt new file mode 100644 index 00000000..75c1eb2c --- /dev/null +++ b/evidence/operations.txt @@ -0,0 +1 @@ +PASS: both uploading API replicas stopped; S3 failure/recovery; all services really restarted; original and session preserved diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..749fd29b --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,2 @@ +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/reconcile.json b/evidence/reconcile.json new file mode 100644 index 00000000..ea3ee8c7 --- /dev/null +++ b/evidence/reconcile.json @@ -0,0 +1 @@ +{"result": "PASS", "dry_run": {"apply": false, "grace_seconds": 5, "page_size": 7, "elapsed_seconds": 4.696135, "counts": {"list_requests": 33, "objects_scanned": 225, "referenced_kept": 220, "head_requests": 225, "orphan_candidates": 3, "fresh_kept": 1, "locked_skipped": 1, "db_pages": 32, "metadata_scanned": 221, "get_requests": 220, "bytes_verified": 1193719837, "valid_objects": 220, "missing_objects": 1, "mark_missing_candidates": 1}}, "apply": {"apply": true, "grace_seconds": 5, "page_size": 7, "elapsed_seconds": 5.253011, "counts": {"list_requests": 33, "objects_scanned": 225, "referenced_kept": 220, "head_requests": 225, "orphan_candidates": 3, "objects_deleted": 3, "fresh_kept": 1, "locked_skipped": 1, "db_pages": 32, "metadata_scanned": 221, "get_requests": 220, "bytes_verified": 1193719837, "valid_objects": 220, "missing_objects": 1, "mark_missing_candidates": 1, "metadata_marked_missing": 1}}, "repeat": {"apply": true, "grace_seconds": 5, "page_size": 7, "elapsed_seconds": 5.53207, "counts": {"list_requests": 32, "objects_scanned": 222, "referenced_kept": 220, "head_requests": 223, "orphan_candidates": 2, "objects_deleted": 2, "db_pages": 32, "metadata_scanned": 221, "get_requests": 220, "bytes_verified": 1193719837, "valid_objects": 220, "missing_objects": 1}}, "corrupt": {"apply": true, "grace_seconds": 5, "page_size": 7, "elapsed_seconds": 4.835876, "counts": {"list_requests": 32, "objects_scanned": 221, "referenced_kept": 221, "db_pages": 32, "metadata_scanned": 221, "head_requests": 221, "get_requests": 221, "bytes_verified": 1193719844, "valid_objects": 220, "corrupt_objects": 1}}, "restored": {"apply": true, "grace_seconds": 5, "page_size": 7, "elapsed_seconds": 4.8535, "counts": {"list_requests": 32, "objects_scanned": 221, "referenced_kept": 221, "db_pages": 32, "metadata_scanned": 221, "head_requests": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221, "restore_candidates": 1, "metadata_restored": 1}}, "concurrent": [{"apply": true, "grace_seconds": 5, "page_size": 11, "elapsed_seconds": 11.069536, "counts": {"list_requests": 21, "objects_scanned": 221, "locked_skipped": 70, "referenced_kept": 163, "db_pages": 21, "metadata_scanned": 221, "head_requests": 209, "get_requests": 209, "bytes_verified": 1107081684, "valid_objects": 209}}, {"apply": true, "grace_seconds": 5, "page_size": 11, "elapsed_seconds": 10.992802, "counts": {"list_requests": 21, "objects_scanned": 221, "referenced_kept": 166, "locked_skipped": 68, "db_pages": 21, "metadata_scanned": 221, "head_requests": 208, "get_requests": 208, "bytes_verified": 1100891063, "valid_objects": 208}}], "cost": [{"extra_objects": 0, "repeat": 1, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 4.963795, "counts": {"list_requests": 5, "objects_scanned": 221, "referenced_kept": 221, "db_pages": 5, "metadata_scanned": 221, "head_requests": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, {"extra_objects": 0, "repeat": 2, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 4.835272, "counts": {"list_requests": 5, "objects_scanned": 221, "referenced_kept": 221, "db_pages": 5, "metadata_scanned": 221, "head_requests": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, {"extra_objects": 0, "repeat": 3, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 5.07319, "counts": {"list_requests": 5, "objects_scanned": 221, "referenced_kept": 221, "db_pages": 5, "metadata_scanned": 221, "head_requests": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, {"extra_objects": 50, "repeat": 1, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 5.184831, "counts": {"list_requests": 6, "objects_scanned": 271, "referenced_kept": 221, "head_requests": 271, "fresh_kept": 50, "db_pages": 5, "metadata_scanned": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, {"extra_objects": 50, "repeat": 2, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 5.314212, "counts": {"list_requests": 6, "objects_scanned": 271, "referenced_kept": 221, "head_requests": 271, "fresh_kept": 50, "db_pages": 5, "metadata_scanned": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, {"extra_objects": 50, "repeat": 3, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 4.994448, "counts": {"list_requests": 6, "objects_scanned": 271, "referenced_kept": 221, "head_requests": 271, "fresh_kept": 50, "db_pages": 5, "metadata_scanned": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, {"extra_objects": 200, "repeat": 1, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 6.356231, "counts": {"list_requests": 9, "objects_scanned": 421, "referenced_kept": 221, "head_requests": 421, "fresh_kept": 200, "db_pages": 5, "metadata_scanned": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, {"extra_objects": 200, "repeat": 2, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 6.826461, "counts": {"list_requests": 9, "objects_scanned": 421, "referenced_kept": 221, "head_requests": 421, "fresh_kept": 200, "db_pages": 5, "metadata_scanned": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, {"extra_objects": 200, "repeat": 3, "apply": false, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 6.225256, "counts": {"list_requests": 9, "objects_scanned": 421, "referenced_kept": 221, "head_requests": 421, "fresh_kept": 200, "db_pages": 5, "metadata_scanned": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}], "final": {"apply": true, "grace_seconds": 3600, "page_size": 50, "elapsed_seconds": 5.115164, "counts": {"list_requests": 5, "objects_scanned": 221, "referenced_kept": 221, "db_pages": 5, "metadata_scanned": 221, "head_requests": 221, "get_requests": 221, "bytes_verified": 1193831654, "valid_objects": 221}}, "scope": "isolated lab4, metadata retained, no backup reconstruction claimed"} diff --git a/evidence/repro-build.txt b/evidence/repro-build.txt new file mode 100644 index 00000000..8d6586e3 --- /dev/null +++ b/evidence/repro-build.txt @@ -0,0 +1,135 @@ +#1 [internal] load local bake definitions +#1 reading from stdin 1.67kB 0.0s done +#1 DONE 0.0s + +#2 [api internal] load build definition from Dockerfile +#2 transferring dockerfile: 793B done +#2 DONE 0.0s + +#3 [s3 internal] load build definition from Dockerfile.s3 +#3 transferring dockerfile: 1.51kB done +#3 DONE 0.0s + +#4 [s3 internal] load metadata for docker.io/library/golang:1.24.6-bookworm@sha256:ab1d1823abb55a9504d2e3e003b75b36dbeb1cbcc4c92593d85a84ee46becc6c +#4 DONE 0.1s + +#5 [s3 internal] load metadata for docker.io/library/debian:bookworm-20251020-slim@sha256:78d2f66e0fec9e5a39fb2c72ea5e052b548df75602b5215ed01a17171529f706 +#5 ... + +#6 [api internal] load metadata for docker.io/library/python:3.11.10-slim-bookworm@sha256:840e180ebcc6e5c8efab209c43f5e40fd2af98cb49db5c7103c90539c56bb30e +#6 DONE 1.9s + +#5 [s3 internal] load metadata for docker.io/library/debian:bookworm-20251020-slim@sha256:78d2f66e0fec9e5a39fb2c72ea5e052b548df75602b5215ed01a17171529f706 +#5 DONE 1.9s + +#7 [s3 internal] load .dockerignore +#7 transferring context: 216B done +#7 DONE 0.0s + +#8 [s3 build 6/7] ADD --checksum=sha256:526ec538e7f83e4bfa631788129b08ec85898ca572ce0523ebf9a597946bea27 https://github.com/minio/mc/archive/refs/tags/RELEASE.2025-04-16T18-13-26Z.tar.gz /tmp/mc.tar.gz +#8 DONE 0.0s + +#9 [s3 build 3/7] ADD --checksum=sha256:8819e3e7817e46b7b3798f8f200ead208562e571563c2e040352378031abe9f2 https://github.com/minio/minio/archive/07c3a429bfed433e49018cb0f78a52145d4bedeb.tar.gz /tmp/minio.tar.gz +#9 DONE 0.0s + +#10 [api 1/7] FROM docker.io/library/python:3.11.10-slim-bookworm@sha256:840e180ebcc6e5c8efab209c43f5e40fd2af98cb49db5c7103c90539c56bb30e +#10 resolve docker.io/library/python:3.11.10-slim-bookworm@sha256:840e180ebcc6e5c8efab209c43f5e40fd2af98cb49db5c7103c90539c56bb30e 0.0s done +#10 DONE 0.1s + +#11 [s3 build 1/7] FROM docker.io/library/golang:1.24.6-bookworm@sha256:ab1d1823abb55a9504d2e3e003b75b36dbeb1cbcc4c92593d85a84ee46becc6c +#11 resolve docker.io/library/golang:1.24.6-bookworm@sha256:ab1d1823abb55a9504d2e3e003b75b36dbeb1cbcc4c92593d85a84ee46becc6c 0.0s done +#11 DONE 0.1s + +#12 [s3 stage-1 1/6] FROM docker.io/library/debian:bookworm-20251020-slim@sha256:78d2f66e0fec9e5a39fb2c72ea5e052b548df75602b5215ed01a17171529f706 +#12 resolve docker.io/library/debian:bookworm-20251020-slim@sha256:78d2f66e0fec9e5a39fb2c72ea5e052b548df75602b5215ed01a17171529f706 0.0s done +#12 DONE 0.1s + +#13 [api internal] load build context +#13 transferring context: 57.99kB 0.0s done +#13 DONE 0.1s + +#14 [s3 internal] load build context +#14 transferring context: 234B done +#14 DONE 0.1s + +#15 [api 2/7] WORKDIR /app +#15 CACHED + +#16 [api 4/7] COPY requirements.lock.txt . +#16 CACHED + +#17 [api 3/7] RUN groupadd -r appuser && useradd -r -g appuser appuser +#17 CACHED + +#18 [api 5/7] RUN pip install --no-cache-dir -r requirements.lock.txt +#18 CACHED + +#19 [s3 build 3/7] ADD --checksum=sha256:8819e3e7817e46b7b3798f8f200ead208562e571563c2e040352378031abe9f2 https://github.com/minio/minio/archive/07c3a429bfed433e49018cb0f78a52145d4bedeb.tar.gz /tmp/minio.tar.gz +#19 CACHED + +#20 [s3 build 5/7] WORKDIR /build-mc +#20 CACHED + +#21 [s3 stage-1 2/6] COPY --from=build /build/LICENSE /usr/share/doc/minio/LICENSE +#21 CACHED + +#22 [s3 stage-1 4/6] COPY --from=build /out/minio /out/mc /usr/bin/ +#22 CACHED + +#23 [s3 build 4/7] RUN tar -xzf /tmp/minio.tar.gz --strip-components=1 && CGO_ENABLED=0 go build -trimpath -o /out/minio . +#23 CACHED + +#24 [s3 stage-1 5/6] COPY --from=build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt +#24 CACHED + +#25 [s3 stage-1 3/6] COPY --from=build /build-mc/LICENSE /usr/share/doc/mc/LICENSE +#25 CACHED + +#26 [s3 build 6/7] ADD --checksum=sha256:526ec538e7f83e4bfa631788129b08ec85898ca572ce0523ebf9a597946bea27 https://github.com/minio/mc/archive/refs/tags/RELEASE.2025-04-16T18-13-26Z.tar.gz /tmp/mc.tar.gz +#26 CACHED + +#27 [s3 build 7/7] RUN tar -xzf /tmp/mc.tar.gz --strip-components=1 && CGO_ENABLED=0 go build -trimpath -o /out/mc . +#27 CACHED + +#28 [s3 build 2/7] WORKDIR /build +#28 CACHED + +#29 [s3 stage-1 6/6] COPY infra/s3-entrypoint.sh /usr/local/bin/s3-entrypoint.sh +#29 CACHED + +#30 [api 6/7] COPY src/ src/ +#30 DONE 0.0s + +#31 [api 7/7] COPY migrations/ migrations/ +#31 DONE 0.1s + +#32 [s3] exporting to image +#32 exporting layers done +#32 exporting manifest sha256:bf8ac548b80bb21909d9212aa98b10abe02044abf4a83b3729052d6df17ca9b4 0.0s done +#32 exporting config sha256:b7bdf0dac5087838ac4dad6be600fcef004ebf9cc04d8f307d868ab37647051b 0.0s done +#32 exporting attestation manifest sha256:e050eab4ff5cac4722821f986671ba48f951367586c93458256b570c45541c72 0.0s done +#32 exporting manifest list sha256:dc92d6ae48897cabe88f308f536d2dc08c0cddbd9baabaca372f1c66824f9387 done +#32 naming to docker.io/library/lyakhonov-lab4-repro-db8d7e24-s3:latest done +#32 unpacking to docker.io/library/lyakhonov-lab4-repro-db8d7e24-s3:latest done +#32 DONE 0.1s + +#33 [api] exporting to image +#33 exporting layers 0.1s done +#33 ... + +#34 [s3] resolving provenance for metadata file +#34 DONE 0.0s + +#33 [api] exporting to image +#33 exporting manifest sha256:2e52cf73ce5a6c14eb32602a4be0064db4055f5807c8be285f718d1deca48814 0.0s done +#33 exporting config sha256:8348d0a7cdcfdfff5f33e567408bbb29bca5981511c2e1240e162777db01b345 0.0s done +#33 exporting attestation manifest sha256:4f36d724ca1c85b0fdc0c0d5b9ad68c5c9e4d1475a2d623be1e8332961971b6b 0.0s done +#33 exporting manifest list sha256:97526ba48c114144f2f0488c35c74946dd26c1d3aaa995f8f2ecc127496191bf done +#33 naming to docker.io/library/lyakhonov-lab4-repro-db8d7e24-api:latest done +#33 unpacking to docker.io/library/lyakhonov-lab4-repro-db8d7e24-api:latest 0.0s done +#33 DONE 0.3s + +#35 [api] resolving provenance for metadata file +#35 DONE 0.0s + lyakhonov-lab4-repro-db8d7e24-api Built + lyakhonov-lab4-repro-db8d7e24-s3 Built diff --git a/evidence/runtime.json b/evidence/runtime.json new file mode 100644 index 00000000..4a053dce --- /dev/null +++ b/evidence/runtime.json @@ -0,0 +1,99 @@ +[ + { + "id": "af9f952b1304", + "service": "api", + "project": "lyakhonov-lab4", + "image": "sha256:da31f98a9d1c6e6cc39e2f28e3a1de410451a7941d84d6ca46fccff13f23a2b6", + "started_at": "2026-10-30T14:46:59.471200143Z", + "memory_limit": 536870912, + "nano_cpus": 500000000, + "volumes": [], + "networks": [ + "lyakhonov-lab4_default" + ] + }, + { + "id": "99f4403277a7", + "service": "api", + "project": "lyakhonov-lab4", + "image": "sha256:da31f98a9d1c6e6cc39e2f28e3a1de410451a7941d84d6ca46fccff13f23a2b6", + "started_at": "2026-10-30T14:46:59.269605492Z", + "memory_limit": 536870912, + "nano_cpus": 500000000, + "volumes": [], + "networks": [ + "lyakhonov-lab4_default" + ] + }, + { + "id": "10138b5c0bee", + "service": "db", + "project": "lyakhonov-lab4", + "image": "sha256:1d04b9ba1d4996401f2552b51beda8187f175c0645c091e4781134fc9c9a3eef", + "started_at": "2026-10-30T14:45:44.07685361Z", + "memory_limit": 536870912, + "nano_cpus": 1000000000, + "volumes": [ + "lyakhonov-lab4_postgres_data" + ], + "networks": [ + "lyakhonov-lab4_default" + ] + }, + { + "id": "e9682a892ad3", + "service": "lb", + "project": "lyakhonov-lab4", + "image": "sha256:c22c8710886104a48b920306f063401f0d11811858e3c6b9d87d88a7556b2e61", + "started_at": "2026-10-30T14:45:44.017393725Z", + "memory_limit": 134217728, + "nano_cpus": 500000000, + "volumes": [], + "networks": [ + "lyakhonov-lab4_default" + ] + }, + { + "id": "7523f15dc398", + "service": "reconciler", + "project": "lyakhonov-lab4", + "image": "sha256:da31f98a9d1c6e6cc39e2f28e3a1de410451a7941d84d6ca46fccff13f23a2b6", + "started_at": "2026-10-30T14:49:08.477185174Z", + "memory_limit": 268435456, + "nano_cpus": 250000000, + "volumes": [], + "networks": [ + "lyakhonov-lab4_default" + ] + }, + { + "id": "68997bbba33b", + "service": "redis", + "project": "lyakhonov-lab4", + "image": "sha256:c1e88455c85225310bbea54816e9c3f4b5295815e6dbf80c34d40afc6df28275", + "started_at": "2026-10-30T14:45:43.846575438Z", + "memory_limit": 134217728, + "nano_cpus": 250000000, + "volumes": [ + "c2c6f149717b708d82beb471b6464d27f0c63cb02c7f97c1d8380274e7604f21" + ], + "networks": [ + "lyakhonov-lab4_default" + ] + }, + { + "id": "a6482b44d70a", + "service": "s3", + "project": "lyakhonov-lab4", + "image": "sha256:4222244a8b6792dac783b2bca633b34636e4b853092b3a0d805f9283562a83c5", + "started_at": "2026-10-30T14:45:43.938532131Z", + "memory_limit": 805306368, + "nano_cpus": 1000000000, + "volumes": [ + "lyakhonov-lab4_s3_data" + ], + "networks": [ + "lyakhonov-lab4_default" + ] + } +] \ No newline at end of file diff --git a/evidence/s3-source-hashes.json b/evidence/s3-source-hashes.json new file mode 100644 index 00000000..d3acd196 --- /dev/null +++ b/evidence/s3-source-hashes.json @@ -0,0 +1,10 @@ +{ + "minio": { + "url": "https://github.com/minio/minio/archive/07c3a429bfed433e49018cb0f78a52145d4bedeb.tar.gz", + "sha256": "8819e3e7817e46b7b3798f8f200ead208562e571563c2e040352378031abe9f2" + }, + "mc": { + "url": "https://github.com/minio/mc/archive/refs/tags/RELEASE.2025-04-16T18-13-26Z.tar.gz", + "sha256": "526ec538e7f83e4bfa631788129b08ec85898ca572ce0523ebf9a597946bea27" + } +} \ No newline at end of file diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..c554fd6f --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1 @@ +PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/sources-manifest.json b/evidence/sources-manifest.json new file mode 100644 index 00000000..ca66c2b0 --- /dev/null +++ b/evidence/sources-manifest.json @@ -0,0 +1,45 @@ +{ + "normalization": "UTF-8 text with LF", + "files": { + "src/app.py": "d8014bc8c4e5286cd02edec3b0da58cac974afbb773e05a16fd67210ce8dd20c", + "src/cache.py": "bfc8f1aa90bee4625b3887a3487be085560b7a2705cc94dcb557dd6c03062028", + "src/config.py": "aafa2db508658d2d5467d2c57ed5f4dea11609ab5928f86abc1e35fc8ba923d7", + "src/main.py": "7681d81d4cd82643064ab4fdb40c3806971804f74f8ed3391931a73d7e04f2c7", + "src/migrate.py": "48c2819b34e22ee099a97d8742a65c87bc0abf9cd617cf6b6caae8a1ad145af5", + "src/models.py": "0628459a90e143ac81fa044eb9943f494c4de3a9f7118ec75767e7e54d08a10b", + "src/objects.py": "f3e6b9279ed56096b0c5ae30e0bc1d55f27a30b92e44cfb4505b7e200554aa69", + "src/reconcile.py": "f5903451be530e15061140a1d47155733db21e7ed1bf528efaaa9d3a7880ed87", + "src/storage.py": "c1576481f9901014c0485b5bdd4bc3719560dc6b8c24fd67a265b030854b6557", + "src/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "src/routes/attachments.py": "40f36993e5f9ba23879082b011e6cef1c5e315abc00d7d4f8a0d640ee38a9782", + "src/routes/chats.py": "46ef834fce05037c2ecab26192ed58c28be81afc6a1db1375560f11bb9d63c12", + "src/routes/common.py": "fa2df76c819abe9a99b8b380a50b2aa4556aa43ac84afa95cac574aab8468a7e", + "src/routes/health.py": "ea527e417d10bb4ffd664e859ac11def9f5aade35f489cb360327045ea53975e", + "src/routes/messages.py": "79d5d0add108aedd948f725e9d821e020f8656d22e67fb7fa1b1500a6da3beb2", + "src/routes/users.py": "f5d4c7e4c4e5b1abfde7869a46e8a81a935b32f4809ddb8b2a4cb13175a24f50", + "src/routes/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "migrations/001_initial.sql": "d4c044482ba61b6a59b35cb02cff16b650fa0fb813242c0678d45a3564e86340", + "migrations/002_idempotency.sql": "b3938061613446d1676dfdf41af1b8417dd0396d2a65e4d3d6b263d311ccdbce", + "migrations/003_attachments.sql": "f84f73a7852635303b022840987894f175159138bb79cd6b6a26a8013b2a6a35", + "student-tests/README.md": "09f6964714abf1a00c0c9f8414d1d3f40d8d5dff2a12912e78b43c7cff0c6789", + "student-tests/test_attachments.py": "fccb56ec4f8565141fff8472f81f7f563652c96368c3aa18b2c07acc7a705080", + "student-tests/test_operations.py": "e38b4a766de69d05a8abde5549731d4b7a78ef046255c570b96d8381542ea322", + "student-tests/test_reconcile.py": "2759b12dc69d16f9aebd17c9041ca45cb0e9b40c12d41e5df50405021ae62a77", + "student-tests/upload_load.py": "d7a616a5cfa01706a3619dffd3ab08627a936b3701312fb4b68a3c3b9afc1bfa", + "scripts/actions.py": "f3314aee1fe6e437c10d8e73326b4b6d0db51dcab9653f97e35b63d0f87399d8", + "scripts/audit_solution.py": "2b519f719a852ba924d25d8997780fa2230da94080957daef3ca510620c15bbf", + "scripts/bootstrap.py": "9170092ff00c7e3c5f94c22e2f0ab4953306fe8aaa3d862562944f8ace709fb7", + "scripts/check_contract.py": "7c4402c2a6ab80d3b4676e1866d6ecc87b6daea14c080bcb9be9a7e8b959d671", + "scripts/plot_results.py": "917f1776e46551d28ebc4068302cc1197373b9b8d644bdcc6029d6e19aedc1de", + "scripts/restart.cmd": "27f84d4acea97ee3891551b5489ee72913128a164c7e5a22374e3f14b9c9b96f", + "scripts/restart.example.sh": "0328246ba75defbced992104e986fde973f63e3830d83251eced5953263e944b", + "scripts/restart.sh": "fcea33ea66beeb9b2ca6964a00c817a45afb7626eb9e4deb92d03adfc78a70b2", + "scripts/run_upload_load.py": "ebd4280428bb6b24979fb275c5e542d121891d292646547879749da4da4be3a1", + "scripts/stop-one.cmd": "e8f6106fd57e81214109f580959ecf9c460ab13df9a5e165c85ed0a9fdafc698", + "scripts/stop-one.example.sh": "1bcf34394520b89d95b7605ec56675be799eea920e83cfbba306d5dc0a6d9811", + "scripts/stop-one.sh": "82a0c50fd834c9ce330ec4b6b808c64c7d76dda7352ae4210a3322c9e0f2e125", + "scripts/validate_openapi.py": "4e981acbfc10dac58817bf922d5896e996798551fedc1b2385130e1cddb13d54", + "scripts/verify_clean_export.py": "97e511ef51a1324227383560d4b77acf3005f6cf4f75a44925feb7b2b56c79e4", + "scripts/wait_ready.py": "29e9965053ad2cba45dc68a4cc462a7ccd2c6cbd9da9ed89351721f926f5643c" + } +} \ No newline at end of file diff --git a/evidence/summary-output.txt b/evidence/summary-output.txt new file mode 100644 index 00000000..33fd2b71 --- /dev/null +++ b/evidence/summary-output.txt @@ -0,0 +1,90 @@ +{ + "uploads": [ + { + "size_bytes": 3151219, + "successful_rps_median": 16.729828936800814, + "p50_seconds_median": 0.4081998335022945, + "p95_seconds_median": 0.584588757907477, + "p99_seconds_median": 0.5914236595887633, + "errors": 0, + "attempts": 30, + "elapsed_seconds": 1.8537453600001754 + }, + { + "size_bytes": 9648062, + "successful_rps_median": 5.626450903085569, + "p50_seconds_median": 1.0610903210035758, + "p95_seconds_median": 1.7164175714497103, + "p99_seconds_median": 1.7635092142925715, + "errors": 0, + "attempts": 30, + "elapsed_seconds": 5.111771299998509 + } + ], + "cost": [ + { + "objects": 221, + "elapsed_median": 4.963795, + "elapsed_min": 4.835272, + "elapsed_max": 5.07319, + "counts": { + "list_requests": 5, + "objects_scanned": 221, + "referenced_kept": 221, + "db_pages": 5, + "metadata_scanned": 221, + "head_requests": 221, + "get_requests": 221, + "bytes_verified": 1193831654, + "valid_objects": 221 + } + }, + { + "objects": 271, + "elapsed_median": 5.184831, + "elapsed_min": 4.994448, + "elapsed_max": 5.314212, + "counts": { + "list_requests": 6, + "objects_scanned": 271, + "referenced_kept": 221, + "head_requests": 271, + "fresh_kept": 50, + "db_pages": 5, + "metadata_scanned": 221, + "get_requests": 221, + "bytes_verified": 1193831654, + "valid_objects": 221 + } + }, + { + "objects": 421, + "elapsed_median": 6.356231, + "elapsed_min": 6.225256, + "elapsed_max": 6.826461, + "counts": { + "list_requests": 9, + "objects_scanned": 421, + "referenced_kept": 221, + "head_requests": 421, + "fresh_kept": 200, + "db_pages": 5, + "metadata_scanned": 221, + "get_requests": 221, + "bytes_verified": 1193831654, + "valid_objects": 221 + } + } + ], + "sampled_memory_max_mib": { + "lyakhonov-lab4-api-1": 157.2, + "lyakhonov-lab4-api-2": 149.2, + "lyakhonov-lab4-db-1": 40.3, + "lyakhonov-lab4-lb-1": 17.27, + "lyakhonov-lab4-s3-1": 312.1 + }, + "kernel_memory_peak_mib": { + "68ab8db39c84": 167.9453125, + "a6106479affd": 156.98046875 + } +} diff --git a/evidence/summary.json b/evidence/summary.json new file mode 100644 index 00000000..9a7efa00 --- /dev/null +++ b/evidence/summary.json @@ -0,0 +1,90 @@ +{ + "uploads": [ + { + "size_bytes": 3151219, + "successful_rps_median": 16.729828936800814, + "p50_seconds_median": 0.4081998335022945, + "p95_seconds_median": 0.584588757907477, + "p99_seconds_median": 0.5914236595887633, + "errors": 0, + "attempts": 30, + "elapsed_seconds": 1.8537453600001754 + }, + { + "size_bytes": 9648062, + "successful_rps_median": 5.626450903085569, + "p50_seconds_median": 1.0610903210035758, + "p95_seconds_median": 1.7164175714497103, + "p99_seconds_median": 1.7635092142925715, + "errors": 0, + "attempts": 30, + "elapsed_seconds": 5.111771299998509 + } + ], + "cost": [ + { + "objects": 221, + "elapsed_median": 4.963795, + "elapsed_min": 4.835272, + "elapsed_max": 5.07319, + "counts": { + "list_requests": 5, + "objects_scanned": 221, + "referenced_kept": 221, + "db_pages": 5, + "metadata_scanned": 221, + "head_requests": 221, + "get_requests": 221, + "bytes_verified": 1193831654, + "valid_objects": 221 + } + }, + { + "objects": 271, + "elapsed_median": 5.184831, + "elapsed_min": 4.994448, + "elapsed_max": 5.314212, + "counts": { + "list_requests": 6, + "objects_scanned": 271, + "referenced_kept": 221, + "head_requests": 271, + "fresh_kept": 50, + "db_pages": 5, + "metadata_scanned": 221, + "get_requests": 221, + "bytes_verified": 1193831654, + "valid_objects": 221 + } + }, + { + "objects": 421, + "elapsed_median": 6.356231, + "elapsed_min": 6.225256, + "elapsed_max": 6.826461, + "counts": { + "list_requests": 9, + "objects_scanned": 421, + "referenced_kept": 221, + "head_requests": 421, + "fresh_kept": 200, + "db_pages": 5, + "metadata_scanned": 221, + "get_requests": 221, + "bytes_verified": 1193831654, + "valid_objects": 221 + } + } + ], + "sampled_memory_max_mib": { + "lyakhonov-lab4-api-1": 157.2, + "lyakhonov-lab4-api-2": 149.2, + "lyakhonov-lab4-db-1": 40.3, + "lyakhonov-lab4-lb-1": 17.27, + "lyakhonov-lab4-s3-1": 312.1 + }, + "kernel_memory_peak_mib": { + "68ab8db39c84": 167.9453125, + "a6106479affd": 156.98046875 + } +} \ No newline at end of file diff --git a/evidence/transfer.md b/evidence/transfer.md new file mode 100644 index 00000000..33627c7d --- /dev/null +++ b/evidence/transfer.md @@ -0,0 +1,7 @@ +# Перенос базы +Ляхонов Сергей, БВТ2301. Выбран трек 2 лабораторной 4. +Источник: собственная лабораторная 3, 374c43e, только чтение; оба рабочих дерева были чистыми. +Перенесены src, migrations, Dockerfile, зависимости и необходимые конфигурации/bootstrap/readiness. +Задание, README, COURSE, contracts и публичные tests лабораторной 4 сохранены. +Секреты, .env, Git, тома, старые измерения и виртуальное окружение не переносились. +Новый стенд: Compose project lyakhonov-lab4, порт 127.0.0.1:8084, отдельные тома/сеть/образ. diff --git a/evidence/upload-load-output.txt b/evidence/upload-load-output.txt new file mode 100644 index 00000000..1abd1934 --- /dev/null +++ b/evidence/upload-load-output.txt @@ -0,0 +1 @@ +{"result": "PASS", "profile": "closed-loop batch, 10 simultaneous uploads, 3 repeats per size, 1 warmup, all confirmed originals downloaded", "runs": [{"size_bytes": 3151219, "side": 1024, "repeat": 1, "concurrency": 10, "attempts": 10, "successes": 10, "errors": 0, "elapsed_seconds": 0.7838622859999305, "successful_rps": 12.75734293970215, "p50_seconds": 0.4336575634952169, "p95_seconds": 0.7340192681040206, "p99_seconds": 0.7722596784304188}, {"size_bytes": 3151219, "side": 1024, "repeat": 2, "concurrency": 10, "attempts": 10, "successes": 10, "errors": 0, "elapsed_seconds": 0.597734743001638, "successful_rps": 16.729828936800814, "p50_seconds": 0.4081998335022945, "p95_seconds": 0.584588757907477, "p99_seconds": 0.5914236595887633}, {"size_bytes": 3151219, "side": 1024, "repeat": 3, "concurrency": 10, "attempts": 10, "successes": 10, "errors": 0, "elapsed_seconds": 0.472148330998607, "successful_rps": 21.179784706322522, "p50_seconds": 0.2796381600055611, "p95_seconds": 0.4425103257497539, "p99_seconds": 0.4638570675504161}, {"size_bytes": 9648062, "side": 1792, "repeat": 1, "concurrency": 10, "attempts": 10, "successes": 10, "errors": 0, "elapsed_seconds": 1.5366208479972556, "successful_rps": 6.507786233040787, "p50_seconds": 1.0274780609979643, "p95_seconds": 1.4637623943453943, "p99_seconds": 1.5201743212681322}, {"size_bytes": 9648062, "side": 1792, "repeat": 2, "concurrency": 10, "attempts": 10, "successes": 10, "errors": 0, "elapsed_seconds": 1.7978311129991198, "successful_rps": 5.56225772693305, "p50_seconds": 1.1837765999953263, "p95_seconds": 1.746605640908092, "p99_seconds": 1.784828035391838}, {"size_bytes": 9648062, "side": 1792, "repeat": 3, "concurrency": 10, "attempts": 10, "successes": 10, "errors": 0, "elapsed_seconds": 1.7773193390021333, "successful_rps": 5.626450903085569, "p50_seconds": 1.0610903210035758, "p95_seconds": 1.7164175714497103, "p99_seconds": 1.7635092142925715}]} diff --git a/evidence/upload-load.json b/evidence/upload-load.json new file mode 100644 index 00000000..808501c7 --- /dev/null +++ b/evidence/upload-load.json @@ -0,0 +1,600 @@ +{ + "result": "PASS", + "profile": "closed-loop batch, 10 simultaneous uploads, 3 repeats per size, 1 warmup, all confirmed originals downloaded", + "runs": [ + { + "size_bytes": 3151219, + "side": 1024, + "repeat": 1, + "concurrency": 10, + "attempts": 10, + "successes": 10, + "errors": 0, + "elapsed_seconds": 0.7838622859999305, + "successful_rps": 12.75734293970215, + "p50_seconds": 0.4336575634952169, + "p95_seconds": 0.7340192681040206, + "p99_seconds": 0.7722596784304188 + }, + { + "size_bytes": 3151219, + "side": 1024, + "repeat": 2, + "concurrency": 10, + "attempts": 10, + "successes": 10, + "errors": 0, + "elapsed_seconds": 0.597734743001638, + "successful_rps": 16.729828936800814, + "p50_seconds": 0.4081998335022945, + "p95_seconds": 0.584588757907477, + "p99_seconds": 0.5914236595887633 + }, + { + "size_bytes": 3151219, + "side": 1024, + "repeat": 3, + "concurrency": 10, + "attempts": 10, + "successes": 10, + "errors": 0, + "elapsed_seconds": 0.472148330998607, + "successful_rps": 21.179784706322522, + "p50_seconds": 0.2796381600055611, + "p95_seconds": 0.4425103257497539, + "p99_seconds": 0.4638570675504161 + }, + { + "size_bytes": 9648062, + "side": 1792, + "repeat": 1, + "concurrency": 10, + "attempts": 10, + "successes": 10, + "errors": 0, + "elapsed_seconds": 1.5366208479972556, + "successful_rps": 6.507786233040787, + "p50_seconds": 1.0274780609979643, + "p95_seconds": 1.4637623943453943, + "p99_seconds": 1.5201743212681322 + }, + { + "size_bytes": 9648062, + "side": 1792, + "repeat": 2, + "concurrency": 10, + "attempts": 10, + "successes": 10, + "errors": 0, + "elapsed_seconds": 1.7978311129991198, + "successful_rps": 5.56225772693305, + "p50_seconds": 1.1837765999953263, + "p95_seconds": 1.746605640908092, + "p99_seconds": 1.784828035391838 + }, + { + "size_bytes": 9648062, + "side": 1792, + "repeat": 3, + "concurrency": 10, + "attempts": 10, + "successes": 10, + "errors": 0, + "elapsed_seconds": 1.7773193390021333, + "successful_rps": 5.626450903085569, + "p50_seconds": 1.0610903210035758, + "p95_seconds": 1.7164175714497103, + "p99_seconds": 1.7635092142925715 + } + ], + "samples": [ + { + "time": 1793371458.0681832, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.04%", + "Container": "68ab8db39c844427ad170edeb784590708e6fc3e69cd4abe43c05b8b6adce6d3", + "ID": "68ab8db39c84", + "MemPerc": "19.38%", + "MemUsage": "99.22MiB / 512MiB", + "Name": "lyakhonov-lab4-api-1", + "NetIO": "61.5kB / 61.2kB", + "PIDs": "11" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.49%", + "Container": "a6106479affd1937a2a56fae0888dc2c155b382a2e1325e94c99194491109dbb", + "ID": "a6106479affd", + "MemPerc": "19.54%", + "MemUsage": "100.1MiB / 512MiB", + "Name": "lyakhonov-lab4-api-2", + "NetIO": "3.22MB / 3.23MB", + "PIDs": "10" + }, + { + "BlockIO": "0B / 2.65MB", + "CPUPerc": "2.09%", + "Container": "10138b5c0beefe8a15a6679fdad81ddac663eea21e8f63bf3ca03545c2558f20", + "ID": "10138b5c0bee", + "MemPerc": "5.18%", + "MemUsage": "26.52MiB / 512MiB", + "Name": "lyakhonov-lab4-db-1", + "NetIO": "662kB / 705kB", + "PIDs": "9" + }, + { + "BlockIO": "741kB / 0B", + "CPUPerc": "0.18%", + "Container": "e9682a892ad30d5becf1fda8abbc16770aed81f261b0843f9cb047b5085baf76", + "ID": "e9682a892ad3", + "MemPerc": "10.57%", + "MemUsage": "13.52MiB / 128MiB", + "Name": "lyakhonov-lab4-lb-1", + "NetIO": "789MB / 789MB", + "PIDs": "17" + }, + { + "BlockIO": "0B / 3.19MB", + "CPUPerc": "2.00%", + "Container": "a6482b44d70a2031a2563b1b72d955435125453a48e95087464775c918801941", + "ID": "a6482b44d70a", + "MemPerc": "39.63%", + "MemUsage": "304.4MiB / 768MiB", + "Name": "lyakhonov-lab4-s3-1", + "NetIO": "4.08MB / 798MB", + "PIDs": "21" + } + ] + }, + { + "time": 1793371461.407941, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "2.06%", + "Container": "68ab8db39c844427ad170edeb784590708e6fc3e69cd4abe43c05b8b6adce6d3", + "ID": "68ab8db39c84", + "MemPerc": "20.62%", + "MemUsage": "105.6MiB / 512MiB", + "Name": "lyakhonov-lab4-api-1", + "NetIO": "31.7MB / 31.7MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "0.88%", + "Container": "a6106479affd1937a2a56fae0888dc2c155b382a2e1325e94c99194491109dbb", + "ID": "a6106479affd", + "MemPerc": "20.64%", + "MemUsage": "105.7MiB / 512MiB", + "Name": "lyakhonov-lab4-api-2", + "NetIO": "34.9MB / 34.9MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 2.74MB", + "CPUPerc": "0.14%", + "Container": "10138b5c0beefe8a15a6679fdad81ddac663eea21e8f63bf3ca03545c2558f20", + "ID": "10138b5c0bee", + "MemPerc": "6.84%", + "MemUsage": "35.02MiB / 512MiB", + "Name": "lyakhonov-lab4-db-1", + "NetIO": "705kB / 746kB", + "PIDs": "13" + }, + { + "BlockIO": "741kB / 0B", + "CPUPerc": "0.21%", + "Container": "e9682a892ad30d5becf1fda8abbc16770aed81f261b0843f9cb047b5085baf76", + "ID": "e9682a892ad3", + "MemPerc": "10.60%", + "MemUsage": "13.57MiB / 128MiB", + "Name": "lyakhonov-lab4-lb-1", + "NetIO": "852MB / 853MB", + "PIDs": "17" + }, + { + "BlockIO": "0B / 34.8MB", + "CPUPerc": "16.97%", + "Container": "a6482b44d70a2031a2563b1b72d955435125453a48e95087464775c918801941", + "ID": "a6482b44d70a", + "MemPerc": "39.90%", + "MemUsage": "306.5MiB / 768MiB", + "Name": "lyakhonov-lab4-s3-1", + "NetIO": "35.7MB / 830MB", + "PIDs": "21" + } + ] + }, + { + "time": 1793371464.4601676, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.26%", + "Container": "68ab8db39c844427ad170edeb784590708e6fc3e69cd4abe43c05b8b6adce6d3", + "ID": "68ab8db39c84", + "MemPerc": "21.66%", + "MemUsage": "110.9MiB / 512MiB", + "Name": "lyakhonov-lab4-api-1", + "NetIO": "63.5MB / 63.4MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "8.14%", + "Container": "a6106479affd1937a2a56fae0888dc2c155b382a2e1325e94c99194491109dbb", + "ID": "a6106479affd", + "MemPerc": "20.75%", + "MemUsage": "106.2MiB / 512MiB", + "Name": "lyakhonov-lab4-api-2", + "NetIO": "66.6MB / 66.6MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 2.84MB", + "CPUPerc": "2.95%", + "Container": "10138b5c0beefe8a15a6679fdad81ddac663eea21e8f63bf3ca03545c2558f20", + "ID": "10138b5c0bee", + "MemPerc": "6.88%", + "MemUsage": "35.23MiB / 512MiB", + "Name": "lyakhonov-lab4-db-1", + "NetIO": "745kB / 784kB", + "PIDs": "13" + }, + { + "BlockIO": "741kB / 0B", + "CPUPerc": "0.17%", + "Container": "e9682a892ad30d5becf1fda8abbc16770aed81f261b0843f9cb047b5085baf76", + "ID": "e9682a892ad3", + "MemPerc": "10.80%", + "MemUsage": "13.82MiB / 128MiB", + "Name": "lyakhonov-lab4-lb-1", + "NetIO": "916MB / 916MB", + "PIDs": "17" + }, + { + "BlockIO": "0B / 66.4MB", + "CPUPerc": "0.94%", + "Container": "a6482b44d70a2031a2563b1b72d955435125453a48e95087464775c918801941", + "ID": "a6482b44d70a", + "MemPerc": "40.05%", + "MemUsage": "307.6MiB / 768MiB", + "Name": "lyakhonov-lab4-s3-1", + "NetIO": "67.4MB / 861MB", + "PIDs": "21" + } + ] + }, + { + "time": 1793371467.8057384, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.27%", + "Container": "68ab8db39c844427ad170edeb784590708e6fc3e69cd4abe43c05b8b6adce6d3", + "ID": "68ab8db39c84", + "MemPerc": "24.28%", + "MemUsage": "124.3MiB / 512MiB", + "Name": "lyakhonov-lab4-api-1", + "NetIO": "105MB / 105MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "1.05%", + "Container": "a6106479affd1937a2a56fae0888dc2c155b382a2e1325e94c99194491109dbb", + "ID": "a6106479affd", + "MemPerc": "21.76%", + "MemUsage": "111.4MiB / 512MiB", + "Name": "lyakhonov-lab4-api-2", + "NetIO": "98.3MB / 98.2MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 2.94MB", + "CPUPerc": "0.38%", + "Container": "10138b5c0beefe8a15a6679fdad81ddac663eea21e8f63bf3ca03545c2558f20", + "ID": "10138b5c0bee", + "MemPerc": "7.74%", + "MemUsage": "39.62MiB / 512MiB", + "Name": "lyakhonov-lab4-db-1", + "NetIO": "786kB / 824kB", + "PIDs": "15" + }, + { + "BlockIO": "741kB / 0B", + "CPUPerc": "3.99%", + "Container": "e9682a892ad30d5becf1fda8abbc16770aed81f261b0843f9cb047b5085baf76", + "ID": "e9682a892ad3", + "MemPerc": "10.54%", + "MemUsage": "13.5MiB / 128MiB", + "Name": "lyakhonov-lab4-lb-1", + "NetIO": "989MB / 989MB", + "PIDs": "17" + }, + { + "BlockIO": "0B / 108MB", + "CPUPerc": "1.47%", + "Container": "a6482b44d70a2031a2563b1b72d955435125453a48e95087464775c918801941", + "ID": "a6482b44d70a", + "MemPerc": "40.25%", + "MemUsage": "309.1MiB / 768MiB", + "Name": "lyakhonov-lab4-s3-1", + "NetIO": "109MB / 893MB", + "PIDs": "21" + } + ] + }, + { + "time": 1793371471.140233, + "containers": [ + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.55%", + "Container": "68ab8db39c844427ad170edeb784590708e6fc3e69cd4abe43c05b8b6adce6d3", + "ID": "68ab8db39c84", + "MemPerc": "26.00%", + "MemUsage": "133.1MiB / 512MiB", + "Name": "lyakhonov-lab4-api-1", + "NetIO": "202MB / 202MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 0B", + "CPUPerc": "7.05%", + "Container": "a6106479affd1937a2a56fae0888dc2c155b382a2e1325e94c99194491109dbb", + "ID": "a6106479affd", + "MemPerc": "25.00%", + "MemUsage": "128MiB / 512MiB", + "Name": "lyakhonov-lab4-api-2", + "NetIO": "195MB / 195MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 3.03MB", + "CPUPerc": "0.17%", + "Container": "10138b5c0beefe8a15a6679fdad81ddac663eea21e8f63bf3ca03545c2558f20", + "ID": "10138b5c0bee", + "MemPerc": "7.79%", + "MemUsage": "39.86MiB / 512MiB", + "Name": "lyakhonov-lab4-db-1", + "NetIO": "828kB / 863kB", + "PIDs": "15" + }, + { + "BlockIO": "741kB / 0B", + "CPUPerc": "10.84%", + "Container": "e9682a892ad30d5becf1fda8abbc16770aed81f261b0843f9cb047b5085baf76", + "ID": "e9682a892ad3", + "MemPerc": "10.60%", + "MemUsage": "13.57MiB / 128MiB", + "Name": "lyakhonov-lab4-lb-1", + "NetIO": "1.18GB / 1.18GB", + "PIDs": "17" + }, + { + "BlockIO": "0B / 204MB", + "CPUPerc": "0.62%", + "Container": "a6482b44d70a2031a2563b1b72d955435125453a48e95087464775c918801941", + "ID": "a6482b44d70a", + "MemPerc": "40.63%", + "MemUsage": "312.1MiB / 768MiB", + "Name": "lyakhonov-lab4-s3-1", + "NetIO": "205MB / 990MB", + "PIDs": "21" + } + ] + }, + { + "time": 1793371474.203735, + "containers": [ + { + "BlockIO": "283kB / 9.65MB", + "CPUPerc": "42.97%", + "Container": "68ab8db39c844427ad170edeb784590708e6fc3e69cd4abe43c05b8b6adce6d3", + "ID": "68ab8db39c84", + "MemPerc": "27.88%", + "MemUsage": "142.8MiB / 512MiB", + "Name": "lyakhonov-lab4-api-1", + "NetIO": "298MB / 298MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 17.4MB", + "CPUPerc": "36.05%", + "Container": "a6106479affd1937a2a56fae0888dc2c155b382a2e1325e94c99194491109dbb", + "ID": "a6106479affd", + "MemPerc": "25.02%", + "MemUsage": "128.1MiB / 512MiB", + "Name": "lyakhonov-lab4-api-2", + "NetIO": "292MB / 292MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 3.11MB", + "CPUPerc": "4.78%", + "Container": "10138b5c0beefe8a15a6679fdad81ddac663eea21e8f63bf3ca03545c2558f20", + "ID": "10138b5c0bee", + "MemPerc": "7.84%", + "MemUsage": "40.12MiB / 512MiB", + "Name": "lyakhonov-lab4-db-1", + "NetIO": "867kB / 900kB", + "PIDs": "15" + }, + { + "BlockIO": "745kB / 0B", + "CPUPerc": "12.86%", + "Container": "e9682a892ad30d5becf1fda8abbc16770aed81f261b0843f9cb047b5085baf76", + "ID": "e9682a892ad3", + "MemPerc": "10.67%", + "MemUsage": "13.66MiB / 128MiB", + "Name": "lyakhonov-lab4-lb-1", + "NetIO": "1.38GB / 1.38GB", + "PIDs": "17" + }, + { + "BlockIO": "0B / 301MB", + "CPUPerc": "27.30%", + "Container": "a6482b44d70a2031a2563b1b72d955435125453a48e95087464775c918801941", + "ID": "a6482b44d70a", + "MemPerc": "40.42%", + "MemUsage": "310.5MiB / 768MiB", + "Name": "lyakhonov-lab4-s3-1", + "NetIO": "302MB / 1.09GB", + "PIDs": "21" + } + ] + }, + { + "time": 1793371477.556512, + "containers": [ + { + "BlockIO": "631kB / 15MB", + "CPUPerc": "49.68%", + "Container": "68ab8db39c844427ad170edeb784590708e6fc3e69cd4abe43c05b8b6adce6d3", + "ID": "68ab8db39c84", + "MemPerc": "30.71%", + "MemUsage": "157.2MiB / 512MiB", + "Name": "lyakhonov-lab4-api-1", + "NetIO": "343MB / 327MB", + "PIDs": "13" + }, + { + "BlockIO": "77.8kB / 24.7MB", + "CPUPerc": "51.60%", + "Container": "a6106479affd1937a2a56fae0888dc2c155b382a2e1325e94c99194491109dbb", + "ID": "a6106479affd", + "MemPerc": "29.14%", + "MemUsage": "149.2MiB / 512MiB", + "Name": "lyakhonov-lab4-api-2", + "NetIO": "340MB / 331MB", + "PIDs": "16" + }, + { + "BlockIO": "0B / 3.18MB", + "CPUPerc": "0.99%", + "Container": "10138b5c0beefe8a15a6679fdad81ddac663eea21e8f63bf3ca03545c2558f20", + "ID": "10138b5c0bee", + "MemPerc": "7.85%", + "MemUsage": "40.21MiB / 512MiB", + "Name": "lyakhonov-lab4-db-1", + "NetIO": "890kB / 920kB", + "PIDs": "15" + }, + { + "BlockIO": "827kB / 4.1kB", + "CPUPerc": "7.90%", + "Container": "e9682a892ad30d5becf1fda8abbc16770aed81f261b0843f9cb047b5085baf76", + "ID": "e9682a892ad3", + "MemPerc": "13.49%", + "MemUsage": "17.27MiB / 128MiB", + "Name": "lyakhonov-lab4-lb-1", + "NetIO": "1.47GB / 1.47GB", + "PIDs": "17" + }, + { + "BlockIO": "0B / 301MB", + "CPUPerc": "0.29%", + "Container": "a6482b44d70a2031a2563b1b72d955435125453a48e95087464775c918801941", + "ID": "a6482b44d70a", + "MemPerc": "36.71%", + "MemUsage": "281.9MiB / 768MiB", + "Name": "lyakhonov-lab4-s3-1", + "NetIO": "302MB / 1.09GB", + "PIDs": "21" + } + ] + }, + { + "time": 1793371480.9294415, + "containers": [ + { + "BlockIO": "750kB / 15MB", + "CPUPerc": "13.86%", + "Container": "68ab8db39c844427ad170edeb784590708e6fc3e69cd4abe43c05b8b6adce6d3", + "ID": "68ab8db39c84", + "MemPerc": "27.79%", + "MemUsage": "142.3MiB / 512MiB", + "Name": "lyakhonov-lab4-api-1", + "NetIO": "395MB / 395MB", + "PIDs": "13" + }, + { + "BlockIO": "77.8kB / 24.7MB", + "CPUPerc": "1.84%", + "Container": "a6106479affd1937a2a56fae0888dc2c155b382a2e1325e94c99194491109dbb", + "ID": "a6106479affd", + "MemPerc": "26.86%", + "MemUsage": "137.5MiB / 512MiB", + "Name": "lyakhonov-lab4-api-2", + "NetIO": "389MB / 389MB", + "PIDs": "14" + }, + { + "BlockIO": "0B / 3.21MB", + "CPUPerc": "2.21%", + "Container": "10138b5c0beefe8a15a6679fdad81ddac663eea21e8f63bf3ca03545c2558f20", + "ID": "10138b5c0bee", + "MemPerc": "7.87%", + "MemUsage": "40.3MiB / 512MiB", + "Name": "lyakhonov-lab4-db-1", + "NetIO": "910kB / 942kB", + "PIDs": "15" + }, + { + "BlockIO": "827kB / 4.1kB", + "CPUPerc": "0.51%", + "Container": "e9682a892ad30d5becf1fda8abbc16770aed81f261b0843f9cb047b5085baf76", + "ID": "e9682a892ad3", + "MemPerc": "10.84%", + "MemUsage": "13.88MiB / 128MiB", + "Name": "lyakhonov-lab4-lb-1", + "NetIO": "1.57GB / 1.57GB", + "PIDs": "17" + }, + { + "BlockIO": "0B / 397MB", + "CPUPerc": "0.44%", + "Container": "a6482b44d70a2031a2563b1b72d955435125453a48e95087464775c918801941", + "ID": "a6482b44d70a", + "MemPerc": "37.20%", + "MemUsage": "285.7MiB / 768MiB", + "Name": "lyakhonov-lab4-s3-1", + "NetIO": "399MB / 1.18GB", + "PIDs": "21" + } + ] + } + ], + "cgroup_before": [ + { + "id": "68ab8db39c84", + "memory.peak": "94355456", + "memory.current": "88948736", + "cpu.stat": "usage_usec 1520787\nuser_usec 1229926\nsystem_usec 290861\nnr_periods 100\nnr_throttled 20\nthrottled_usec 838500\nnr_bursts 0\nburst_usec 0" + }, + { + "id": "a6106479affd", + "memory.peak": "94523392", + "memory.current": "89448448", + "cpu.stat": "usage_usec 1465401\nuser_usec 1200760\nsystem_usec 264641\nnr_periods 97\nnr_throttled 18\nthrottled_usec 858421\nnr_bursts 0\nburst_usec 0" + } + ], + "cgroup_after": [ + { + "id": "68ab8db39c84", + "memory.peak": "176103424", + "memory.current": "155086848", + "cpu.stat": "usage_usec 6981108\nuser_usec 5342601\nsystem_usec 1638507\nnr_periods 318\nnr_throttled 84\nthrottled_usec 4194115\nnr_bursts 0\nburst_usec 0" + }, + { + "id": "a6106479affd", + "memory.peak": "164605952", + "memory.current": "150552576", + "cpu.stat": "usage_usec 6971952\nuser_usec 5392216\nsystem_usec 1579735\nnr_periods 304\nnr_throttled 84\nthrottled_usec 4096903\nnr_bursts 0\nburst_usec 0" + } + ] +} \ No newline at end of file diff --git a/evidence/upload-summary.csv b/evidence/upload-summary.csv new file mode 100644 index 00000000..502bb44c --- /dev/null +++ b/evidence/upload-summary.csv @@ -0,0 +1,7 @@ +size_bytes,side,repeat,concurrency,attempts,successes,errors,elapsed_seconds,successful_rps,p50_seconds,p95_seconds,p99_seconds +3151219,1024,1,10,10,10,0,0.7838622859999305,12.75734293970215,0.4336575634952169,0.7340192681040206,0.7722596784304188 +3151219,1024,2,10,10,10,0,0.597734743001638,16.729828936800814,0.4081998335022945,0.584588757907477,0.5914236595887633 +3151219,1024,3,10,10,10,0,0.472148330998607,21.179784706322522,0.2796381600055611,0.4425103257497539,0.4638570675504161 +9648062,1792,1,10,10,10,0,1.5366208479972556,6.507786233040787,1.0274780609979643,1.4637623943453943,1.5201743212681322 +9648062,1792,2,10,10,10,0,1.7978311129991198,5.56225772693305,1.1837765999953263,1.746605640908092,1.784828035391838 +9648062,1792,3,10,10,10,0,1.7773193390021333,5.626450903085569,1.0610903210035758,1.7164175714497103,1.7635092142925715 diff --git a/evidence/validate.txt b/evidence/validate.txt new file mode 100644 index 00000000..b6bb5737 --- /dev/null +++ b/evidence/validate.txt @@ -0,0 +1,2 @@ +.venv/Scripts/python scripts/validate_openapi.py +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. diff --git a/infra/bucket.sh b/infra/bucket.sh new file mode 100644 index 00000000..295b0271 --- /dev/null +++ b/infra/bucket.sh @@ -0,0 +1,20 @@ +#!/bin/sh + +set -eu + +# Не включать set -x: аргументы содержат учебные credentials. + +until mc alias set local http://s3:9000 "$(cat /run/secrets/s3_root_user)" "$(cat /run/secrets/s3_root_password)" >/dev/null 2>&1; do sleep 1; done + +mc mb --ignore-existing local/attachments >/dev/null + +mc anonymous set none local/attachments >/dev/null + +mc admin user add local "$(cat /run/secrets/s3_access_key)" "$(cat /run/secrets/s3_secret_key)" >/dev/null + +mc admin policy create local attachments-app /bootstrap/policy.json >/dev/null + +mc admin policy attach local attachments-app --user "$(cat /run/secrets/s3_access_key)" >/dev/null + +echo 'Private bucket and restricted application user ready' + diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..042a6cb2 --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,27 @@ +global + log stdout format raw local0 + maxconn 1024 +defaults + mode http + log global + timeout connect 1s + timeout client 60s + timeout server 45s + timeout check 1s + retries 0 +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 2 + timeout resolve 1s + timeout retry 1s + hold valid 1s + hold obsolete 1s +frontend public + bind :8080 + default_backend application +backend application + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 1s fastinter 500ms downinter 1s fall 2 rise 1 + server-template api 1-4 api:8080 check resolvers docker init-addr none diff --git a/infra/reconciliation.md b/infra/reconciliation.md new file mode 100644 index 00000000..30f3e437 --- /dev/null +++ b/infra/reconciliation.md @@ -0,0 +1,60 @@ +# Согласованность PostgreSQL и S3 + +Источник истины для доступа/связей — PostgreSQL; исходные bytes — приватный S3. +Upload принимает raw body в ограниченный временный spool (не durable storage), проверяет MIME/целостность/пиксели, +затем выбирает уникальный originals/UUID, берёт транзакционную advisory lock по ключу и выполняет S3 PUT → INSERT Attachment → COMMIT. +201 возвращается только после COMMIT. Оригинал не перекодируется. Сессия и ACL проверяются до чтения body. + +## Сбои и восстановление + +- Обрыв до PUT: временный spool закрывается, постоянного объекта нет. +- PUT не прошёл: INSERT/COMMIT не выполняются, ответ 503. +- PUT прошёл, INSERT/COMMIT не прошёл или результат COMMIT неизвестен: объект не удаляется вслепую. + Если COMMIT всё же прошёл, удаление уничтожило бы подтверждённое вложение. Reconciler после grace проверяет наличие строки заново. +- Метаданные есть, объекта нет/он повреждён: строка переводится во внутреннее missing. Публичное Attachment ready не подделывается: + GET метаданных/content даёт 503, добавление такого вложения в новое сообщение — 409. Ранее созданное сообщение и его связи остаются. +- Когда оператор вернул оригинал из резервной копии, reconciler читает реальные bytes потоково, сравнивает размер, SHA-256 и MIME. + Только совпадение возвращает ready. Сверка сама не может восстановить утраченные bytes; backup/репликация здесь не реализованы. + +## Алгоритм + +1. Время cutoff фиксируется в начале запуска. LIST обходится страницами (default 100). +2. Для каждого объекта попробовать ту же advisory lock. Активный uploader/другой reconciler приводит к skip. +3. Под блокировкой повторно прочитать метаданные; любая существующая строка сохраняет объект, даже если сообщение ещё не создано. +4. При отсутствии строки заново HEAD; только LastModified <= cutoff позволяет удаление orphan. Иначе fresh_kept. +5. Метаданные обойти keyset-страницами по UUID. Под той же блокировкой и FOR UPDATE проверить HEAD и SHA-256 тела блоками 64 KiB. + 404 означает missing, сетевой/авторизационный/серверный сбой не считается отсутствием и прерывает проход. +6. Dry-run имеет те же проверки, но не меняет ни один store. Apply атомарно фиксирует каждое изменение метаданных; + повтор после сбоя или конкурентный проход безопасен. Глобального snapshot между двумя store нет, изменения во время прохода могут попасть в следующий. + +Защита от гонки orphan/COMMIT — общая блокировка, а не только ожидание времени. +Область originals доступна на запись только приложению/оператору учебного стенда. Протокол не защищает от администратора, +который обходит advisory lock и одновременно перезаписывает/удаляет объекты. Случайная hash-коллизия вызывает лишний skip/ожидание, а не удаление используемого объекта. +Метаданные и связи сообщений алгоритм не удаляет вообще. Уникальный ключ не переиспользуется upload; PUT имеет If-None-Match: *. + +## Запуск + +```sh +# Dry-run по умолчанию: +docker compose run --rm --no-deps api python -m src.reconcile +# Применение, обычный grace 1 час: +docker compose run --rm --no-deps api python -m src.reconcile --apply +``` + +Сервис reconciler делает apply каждые 300 секунд, grace=3600 секунд; после ошибки пишет только класс ошибки и повторяет проход. +Полный цикл обнаружения старого orphan — grace + период запуска + длительность прохода; при недоступных stores SLA не гарантируется. +При benchmark сервис останавливают, затем восстанавливают, чтобы его чтение/хеширование не искажало измерения. +В тесте используются grace=5 секунд и искусственные synthetic objects; этот интервал не является эксплуатационной рекомендацией. +Минимально разрешено 5 секунд, default остаётся 3600. CPU/RAM/трафик сверки растут с количеством объектов и bytes; +RAM ограничена размером страницы и chunk, а не размером всего bucket. + +## Ограничения памяти/таймаутов API + +На реплику один upload внутри semaphore; очередь не более общего лимита 100 запросов, ожидание слота <=25 с. +Body <=10 MiB контролируется по объявленному размеру и фактически прочитанным chunks, приём <=20 с. +PNG/JPEG проверяются до декодирования по размеру <=40 млн px; Pillow verify и затем load обнаруживают повреждённые потоки. +Наихудший framebuffer порядка 160 MB на одну декодируемую картинку; API ограничена 512 MiB. Потоковый приём не означает нулевую RAM декодера. +Временный файл используется только до синхронного PUT и закрывается при ошибке; API не хранит durable оригинал на своём диске. +S3 connect=2 с, read=5 с, SDK без автоматических retry; LB client=60 с/server=45 с, без повторов POST. +Readiness требует PostgreSQL и доступного S3 LIST в рабочем prefix, Redis необязателен. После обнаружения S3-отказа LB исключает обе API; +это осознанная граница доступности всего стенда. Ошибка LB может не иметь API-заголовков/JSON. diff --git a/infra/s3-entrypoint.sh b/infra/s3-entrypoint.sh new file mode 100644 index 00000000..2134296e --- /dev/null +++ b/infra/s3-entrypoint.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +export MINIO_ROOT_USER="$(cat "$MINIO_ROOT_USER_FILE")" +export MINIO_ROOT_PASSWORD="$(cat "$MINIO_ROOT_PASSWORD_FILE")" +exec minio "$@" diff --git a/infra/s3-policy.json b/infra/s3-policy.json new file mode 100644 index 00000000..6b7d394e --- /dev/null +++ b/infra/s3-policy.json @@ -0,0 +1 @@ +{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:ListBucket"],"Resource":["arn:aws:s3:::attachments"],"Condition":{"StringLike":{"s3:prefix":["originals/*"]}}},{"Effect":"Allow","Action":["s3:GetObject","s3:PutObject","s3:DeleteObject"],"Resource":["arn:aws:s3:::attachments/originals/*"]}]} \ No newline at end of file diff --git a/lab4.env.example b/lab4.env.example new file mode 100644 index 00000000..9c0dd097 --- /dev/null +++ b/lab4.env.example @@ -0,0 +1,8 @@ +# Public settings only. Copy to .env; secrets are generated separately. +LAB4_PORT=8084 +API_REPLICAS=2 +API_CPUS=0.5 +API_MEMORY=512m +POOL_SIZE=10 +SESSION_TTL_SECONDS=3600 +OPTIMIZED_WRITES=1 diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..2ee14af7 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,33 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name varchar(100) NOT NULL CHECK (length(btrim(display_name)) > 0), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title varchar(100) NOT NULL CHECK (length(btrim(title)) > 0), + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +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_idx ON chat_members (user_id, chat_id); +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id), + sender_id uuid NOT NULL REFERENCES users(id), + text varchar(4000) NOT NULL CHECK (length(btrim(text)) > 0), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id) +); +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); +CREATE TABLE sessions ( + token_hash char(64) PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id), + expires_at timestamptz NOT NULL +); +CREATE INDEX sessions_expiry_idx ON sessions (expires_at); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..be707c47 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,10 @@ +CREATE TABLE message_requests ( + user_id uuid NOT NULL REFERENCES users(id), + chat_id uuid NOT NULL REFERENCES chats(id), + key varchar(128) NOT NULL, + body text NOT NULL, + message_id uuid NOT NULL REFERENCES messages(id), + expires_at timestamptz NOT NULL, + PRIMARY KEY (user_id, chat_id, key) +); +CREATE INDEX message_requests_expiry_idx ON message_requests(expires_at); diff --git a/migrations/003_attachments.sql b/migrations/003_attachments.sql new file mode 100644 index 00000000..9bdc747c --- /dev/null +++ b/migrations/003_attachments.sql @@ -0,0 +1,17 @@ +ALTER TABLE messages DROP CONSTRAINT messages_text_check; +ALTER TABLE messages ADD CONSTRAINT messages_text_limit CHECK (length(text)<=4000); +CREATE TABLE attachments ( + id uuid PRIMARY KEY, chat_id uuid NOT NULL REFERENCES chats(id), + owner_id uuid NOT NULL REFERENCES users(id), object_key text NOT NULL UNIQUE, + filename text NOT NULL, content_type text NOT NULL, size_bytes integer NOT NULL, + sha256 char(64) NOT NULL, state text NOT NULL CHECK(state IN ('ready','missing')), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + updated_at timestamptz NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY(chat_id,owner_id) REFERENCES chat_members(chat_id,user_id) +); +CREATE TABLE message_attachments ( + message_id uuid NOT NULL REFERENCES messages(id), attachment_id uuid NOT NULL REFERENCES attachments(id), + position integer NOT NULL, PRIMARY KEY(message_id,attachment_id), UNIQUE(message_id,position) +); +-- Старые сохранённые ключи теперь сравнивают полное нормализованное тело. +UPDATE message_requests SET body=json_build_object('text',body,'attachment_ids',json_build_array())::text; diff --git a/requirements-research.txt b/requirements-research.txt new file mode 100644 index 00000000..d8323040 --- /dev/null +++ b/requirements-research.txt @@ -0,0 +1,2 @@ +-r requirements-dev.txt +matplotlib==3.10.7 diff --git a/requirements.lock.txt b/requirements.lock.txt new file mode 100644 index 00000000..6fccf885 --- /dev/null +++ b/requirements.lock.txt @@ -0,0 +1,34 @@ +annotated-types==0.8.0 +anyio==4.15.1 +argon2-cffi==23.1.0 +argon2-cffi-bindings==26.1.0 +cffi==2.1.1 +click==8.5.0 +fastapi==0.115.0 +h11==0.16.0 +httptools==0.8.0 +idna==3.20 +psycopg==3.2.3 +psycopg-binary==3.2.3 +psycopg-pool==3.2.4 +pycparser==3.1 +pydantic==2.9.2 +pydantic_core==2.23.4 +python-dotenv==1.2.4 +PyYAML==6.0.3 +starlette==0.38.6 +typing_extensions==4.16.0 +uvicorn==0.32.0 +uvloop==0.23.0 +watchfiles==1.3.0 +websockets==17.2 +redis==5.2.0 + +boto3==1.40.61 +Pillow==12.0.0 +botocore==1.40.76 +s3transfer==0.14.0 +jmespath==1.1.0 +python-dateutil==2.9.0.post0 +six==1.17.0 +urllib3==2.8.0 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..7010e5f2 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,10 @@ +fastapi==0.115.0 +uvicorn[standard]==0.32.0 +pydantic==2.9.2 +psycopg[binary]==3.2.3 +psycopg-pool==3.2.4 +argon2-cffi==23.1.0 +redis==5.2.0 + +boto3==1.40.61 +Pillow==12.0.0 diff --git a/scripts/actions.py b/scripts/actions.py new file mode 100644 index 00000000..a8d51e27 --- /dev/null +++ b/scripts/actions.py @@ -0,0 +1,22 @@ +"""Restart/failover hooks scoped to lab4; never remove volumes.""" +import json +import os +from pathlib import Path +import subprocess +import sys +root=Path(__file__).resolve().parents[1] +base=['docker','compose','--project-directory',str(root),'-p','lyakhonov-lab4'] +def compose(*args): + return subprocess.check_output(base+list(args),text=True).strip() +mode=sys.argv[1] +if mode=='restart': + compose('restart','api','db','redis','s3','lb','reconciler') +elif mode=='stop-one': + target=os.environ['TARGET_INSTANCE_ID'] + for cid in compose('ps','-q','api').splitlines(): + info=json.loads(subprocess.check_output(['docker','inspect',cid],text=True))[0] + if target.startswith(info['Config']['Hostname']+'-'): + subprocess.check_call(['docker','stop','--time','1',cid],stdout=subprocess.DEVNULL) + break + else: raise SystemExit('No matching lab4 API instance') +else: raise SystemExit('unknown action') diff --git a/scripts/audit_solution.py b/scripts/audit_solution.py new file mode 100644 index 00000000..df26723a --- /dev/null +++ b/scripts/audit_solution.py @@ -0,0 +1,27 @@ +"""Read-only audit: original materials, authorship, secrets and previous project.""" +from pathlib import Path +import json +import subprocess +ROOT=Path(__file__).resolve().parents[1] +def git(*args): return subprocess.check_output(['git',*args],cwd=ROOT) +base='ec540a1' +protected=['README.md','COURSE.md','CONTRIBUTING.md','MAINTAINERS.md','contracts','tests'] +assert not git('diff',base,'--',*protected).strip(), 'mandatory materials changed' +identity='Sergey Lyakhonov ' +for line in git('log',base+'..HEAD','--format=%an <%ae>|%cn <%ce>').decode().splitlines(): + assert line==identity+'|'+identity, 'unexpected commit identity' +paths=git('ls-files','--cached','--others','--exclude-standard','-z').split(b'\0') +secret_dir=ROOT/'secrets' +values=[f.read_bytes().strip() for f in secret_dir.iterdir() if f.is_file()] if secret_dir.exists() else [] +for raw in paths: + if not raw: continue + name=raw.decode('utf-8');file=ROOT/name + assert not name.startswith('secrets/') and name!='.env','private file tracked' + if file.is_file(): + assert not any(value and value in file.read_bytes() for value in values), 'secret value in '+name +previous=ROOT.parent/'vysoko-nagr 3' +if previous.exists(): + args=['git','-c','safe.directory='+str(previous),'-C',str(previous)] + assert not subprocess.check_output(args+['status','--porcelain']).strip(),'previous project changed' + assert subprocess.check_output(args+['rev-parse','HEAD']).decode().strip().startswith('374c43e'),'previous HEAD changed' +print('PASS: original materials unchanged; specified author/committer; no generated secrets in tracked/nonignored files; lab3 unchanged') diff --git a/scripts/bootstrap.py b/scripts/bootstrap.py new file mode 100644 index 00000000..6362fc1b --- /dev/null +++ b/scripts/bootstrap.py @@ -0,0 +1,24 @@ +"""Создать локальные секреты, не перезаписывая существующие.""" +from pathlib import Path +import secrets + +root = Path(__file__).resolve().parents[1] +folder = root / 'secrets' +folder.mkdir(exist_ok=True) +password_file = folder / 'db_password' +if not password_file.exists(): + password_file.write_text(secrets.token_hex(24), encoding='utf-8') +url_file = folder / 'database_url' +if not url_file.exists(): + password = password_file.read_text(encoding='utf-8').strip() + url_file.write_text(f'postgresql://messenger:{password}@db:5432/messenger', encoding='utf-8') + +for name in ('s3_root_user', 's3_root_password', 's3_access_key', 's3_secret_key'): + target = folder / name + if not target.exists(): + target.write_text(secrets.token_hex(24), encoding='utf-8') + +env_file = root / '.env' +if not env_file.exists(): + env_file.write_bytes((root / 'lab4.env.example').read_bytes()) +print('Локальные настройки и секреты готовы; существующие файлы сохранены.') diff --git a/scripts/plot_results.py b/scripts/plot_results.py new file mode 100644 index 00000000..784d69e6 --- /dev/null +++ b/scripts/plot_results.py @@ -0,0 +1,68 @@ +"""Static research figures from recorded evidence only; no new measurements.""" +import csv +import json +from pathlib import Path +import re +import statistics +import matplotlib +matplotlib.use('Agg') +import matplotlib.pyplot as plt +ROOT=Path(__file__).resolve().parents[1] +OUT=ROOT/'evidence/figures';OUT.mkdir(exist_ok=True) +plt.rcParams.update({'font.family':'DejaVu Sans','font.size':10,'axes.spines.top':False,'axes.spines.right':False}) +def save(fig,name): + fig.tight_layout() + fig.savefig(OUT/(name+'.png'),dpi=170) + fig.savefig(OUT/(name+'.svg')) + plt.close(fig) +def bands(ax,x,groups,label,color): + med=[statistics.median(v) for v in groups] + ax.errorbar(x,med,yerr=[[m-min(v) for m,v in zip(med,groups)],[max(v)-m for m,v in zip(med,groups)]],fmt='o-',capsize=4,label=label,color=color) +r=json.loads((ROOT/'evidence/reconcile.json').read_text(encoding='utf-8-sig')) +points=sorted({v['extra_objects'] for v in r['cost']}) +groups=[[v for v in r['cost'] if v['extra_objects']==n] for n in points] +x=[v[0]['counts']['objects_scanned'] for v in groups] +fig,axes=plt.subplots(1,2,figsize=(10.5,4)) +bands(axes[0],x,[[v['elapsed_seconds'] for v in vs] for vs in groups],'Медиана и min–max (3 повтора)','#286D8C') +axes[0].set(xlabel='Объектов в bucket',ylabel='Время dry-run, с',title='Стоимость полной сверки') +axes[0].legend(fontsize=8) +for field,label in [('head_requests','HEAD'),('get_requests','GET'),('list_requests','LIST')]: + axes[1].plot(x,[v[0]['counts'][field] for v in groups],'o-',label=label) +axes[1].set(xlabel='Объектов в bucket',ylabel='Число S3-запросов',title='Цена обхода: запросы') +axes[1].legend();save(fig,'reconcile-cost') +u=json.loads((ROOT/'evidence/upload-load.json').read_text(encoding='utf-8-sig')) +sizes=sorted({v['size_bytes'] for v in u['runs']}); x=[s/1048576 for s in sizes] +groups=[[v for v in u['runs'] if v['size_bytes']==s] for s in sizes] +fig,axes=plt.subplots(1,2,figsize=(10.5,4)) +bands(axes[0],x,[[v['successful_rps'] for v in vs] for vs in groups],'3 партии × 10 клиентов','#286D8C') +axes[0].set(xlabel='PNG, MiB',ylabel='Успешных загрузок/с',title='Синхронный upload через API') +bands(axes[1],x,[[v['p95_seconds'] for v in vs] for vs in groups],'p95 успешных запросов','#B15E38') +axes[1].set(xlabel='PNG, MiB',ylabel='Задержка, с',title='p95 внутри партии (10 запросов)') +for ax in axes: ax.legend(fontsize=8) +save(fig,'upload-throughput') +def mib(value): + match=re.match(r'([0-9.]+)([A-Za-z]+)',value.strip()) + amount=float(match[1]);unit=match[2] + return amount*{'B':1/1048576,'KiB':1/1024,'MiB':1,'GiB':1024,'kB':1000/1048576,'MB':1000000/1048576,'GB':1000000000/1048576}[unit] +fig,ax=plt.subplots(figsize=(10.5,4)) +first=u['samples'][0]['time'] +for name in sorted({c['Name'] for s in u['samples'] for c in s['containers'] if '-api-' in c['Name']}): + pairs=[(s['time']-first,mib(c['MemUsage'].split('/')[0])) for s in u['samples'] for c in s['containers'] if c['Name']==name] + ax.plot([a for a,b in pairs],[b for a,b in pairs],'o-',label=name) +ax.axhline(512,color='#B15E38',linestyle='--',label='Лимит одной API: 512 MiB') +ax.set(xlabel='Время от первой выборки, с',ylabel='Docker working set, MiB',title='Память API: прогрев, загрузки и проверка оригиналов') +ax.legend(fontsize=8);save(fig,'upload-memory') +with (ROOT/'evidence/upload-summary.csv').open('w',newline='',encoding='utf-8') as f: + writer=csv.DictWriter(f,fieldnames=list(u['runs'][0]));writer.writeheader();writer.writerows(u['runs']) +summary={'uploads':[], 'cost':[],'sampled_memory_max_mib':{},'kernel_memory_peak_mib':{}} +for size,vs in zip(sizes,groups): + summary['uploads'].append({'size_bytes':size,'successful_rps_median':statistics.median(v['successful_rps'] for v in vs),'p50_seconds_median':statistics.median(v['p50_seconds'] for v in vs),'p95_seconds_median':statistics.median(v['p95_seconds'] for v in vs),'p99_seconds_median':statistics.median(v['p99_seconds'] for v in vs),'errors':sum(v['errors'] for v in vs),'attempts':sum(v['attempts'] for v in vs),'elapsed_seconds':sum(v['elapsed_seconds'] for v in vs)}) +for n in points: + vs=[v for v in r['cost'] if v['extra_objects']==n] + summary['cost'].append({'objects':vs[0]['counts']['objects_scanned'],'elapsed_median':statistics.median(v['elapsed_seconds'] for v in vs),'elapsed_min':min(v['elapsed_seconds'] for v in vs),'elapsed_max':max(v['elapsed_seconds'] for v in vs),'counts':vs[0]['counts']}) +for s in u['samples']: + for c in s['containers']: + name=c['Name'];summary['sampled_memory_max_mib'][name]=max(summary['sampled_memory_max_mib'].get(name,0),mib(c['MemUsage'].split('/')[0])) +for c in u.get('cgroup_after',[]):summary['kernel_memory_peak_mib'][c['id']]=int(c['memory.peak'])/1048576 +(ROOT/'evidence/summary.json').write_text(json.dumps(summary,indent=2),encoding='utf-8') +print(json.dumps(summary,indent=2)) diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..7bc66929 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,2 @@ +@echo off +python "%~dp0actions.py" restart diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..c22c1f7f --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,3 @@ +#!/bin/sh +set -eu +exec python3 "$(dirname "$0")/actions.py" restart diff --git a/scripts/run_upload_load.py b/scripts/run_upload_load.py new file mode 100644 index 00000000..78111518 --- /dev/null +++ b/scripts/run_upload_load.py @@ -0,0 +1,36 @@ +"""Host-side Docker CPU/RAM sampling during the real upload experiment.""" +import json +from pathlib import Path +import subprocess +import time +ROOT=Path(__file__).resolve().parents[1] +base=['docker','compose','--project-directory',str(ROOT),'-p','lyakhonov-lab4'] +def cgroups(): + ids=subprocess.check_output(base+['ps','-q','api'],text=True).split() + result=[] + for cid in ids: + code="from pathlib import Path; import json; print(json.dumps({name:Path('/sys/fs/cgroup/'+name).read_text().strip() for name in ('memory.peak','memory.current','cpu.stat')}))" + raw=subprocess.check_output(['docker','exec',cid,'python','-c',code],text=True) + result.append({'id':cid[:12],**json.loads(raw)}) + return result +subprocess.check_call(base+['stop','reconciler'],stdout=subprocess.DEVNULL) +try: + before=cgroups() + cmd=base+['run','--rm','--no-deps','-T','-v',str(ROOT)+':/suite:ro','-w','/suite','api','python','student-tests/upload_load.py'] + with (ROOT/'evidence/upload-load-output.txt').open('w',encoding='utf-8') as output: + proc=subprocess.Popen(cmd,stdout=output) + samples=[] + while proc.poll() is None: + ids=subprocess.check_output(base+['ps','-q','api','db','s3','lb'],text=True).split() + if ids: + raw=subprocess.check_output(['docker','stats','--no-stream','--format','{{json .}}']+ids,text=True) + samples.append({'time':time.time(),'containers':[json.loads(x) for x in raw.splitlines()]}) + time.sleep(.3) + if proc.returncode: raise SystemExit(proc.returncode) + text=(ROOT/'evidence/upload-load-output.txt').read_text(encoding='utf-8').strip() + result=json.loads(text.splitlines()[-1]); result['samples']=samples + result['cgroup_before']=before; result['cgroup_after']=cgroups() + (ROOT/'evidence/upload-load.json').write_text(json.dumps(result,indent=2),encoding='utf-8') +finally: + subprocess.check_call(base+['start','reconciler'],stdout=subprocess.DEVNULL) +print('PASS: upload experiment and Docker CPU/RAM samples saved; batches:',len(result['runs'])) diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..c757e172 --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,2 @@ +@echo off +python "%~dp0actions.py" stop-one diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..04aa2950 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,3 @@ +#!/bin/sh +set -eu +exec python3 "$(dirname "$0")/actions.py" stop-one diff --git a/scripts/verify_clean_export.py b/scripts/verify_clean_export.py new file mode 100644 index 00000000..d7c86724 --- /dev/null +++ b/scripts/verify_clean_export.py @@ -0,0 +1,54 @@ +"""Verify a committed Git export with fresh secrets, isolated images/project/volumes.""" +import json +import os +from pathlib import Path +import socket +import subprocess +import tarfile +import tempfile +import time +import uuid +ROOT=Path(__file__).resolve().parents[1] +project='lyakhonov-lab4-repro-'+uuid.uuid4().hex[:8] +with socket.socket() as sock: + sock.bind(('127.0.0.1',0)); port=sock.getsockname()[1] +env=dict(os.environ,LAB4_PORT=str(port),PYTHONUTF8='1') +commit=subprocess.check_output(['git','rev-parse','HEAD'],cwd=ROOT,text=True).strip() +with tempfile.TemporaryDirectory(prefix='lab4-repro-') as folder: + temporary=Path(folder).resolve() + assert temporary.parent==Path(tempfile.gettempdir()).resolve() and temporary.name.startswith('lab4-repro-') + archive=temporary/'source.tar' + subprocess.check_call(['git','archive','--format=tar','-o',str(archive),'HEAD'],cwd=ROOT) + source=temporary/'source';source.mkdir() + with tarfile.open(archive) as tar: + for member in tar.getmembers(): + assert (source/member.name).resolve().is_relative_to(source.resolve()) + tar.extractall(source,filter='data') + assert not (source/'secrets').exists() and not (source/'.env').exists() + override=source/'repro.override.yaml' + override.write_text('services:\n'+''.join(' '+name+':\n image: '+image+'\n' for name,image in [ + ('api',project+'-api'),('migrate',project+'-api'),('reconciler',project+'-api'),('s3',project+'-s3'),('bucket-init',project+'-s3')]),encoding='utf-8') + base=['docker','compose','--project-directory',str(source),'-f',str(source/'compose.yaml'),'-f',str(override),'-p',project] + def dc(*args,**kwargs): return subprocess.check_output(base+list(args),env=env,text=True,**kwargs) + existing=subprocess.check_output(['docker','ps','-aq','--filter','label=com.docker.compose.project='+project],text=True).strip() + assert not existing + subprocess.check_call(['python',str(source/'scripts/bootstrap.py')],env=env) + results={'commit':commit,'project':project,'port':port,'fresh_secrets':True,'isolated_images':True} + try: + with (ROOT/'evidence/repro-build.txt').open('w',encoding='utf-8') as buildlog: + subprocess.check_call(base+['build','api','s3'],env=env,stdout=buildlog,stderr=subprocess.STDOUT) + dc('up','-d') + ready=subprocess.check_output(['python',str(source/'scripts/wait_ready.py'),'--base-url','http://localhost:'+str(port),'--replicas','2'],env=env,text=True) + smoke=subprocess.check_output(['python',str(source/'tests/smoke.py'),'--base-url','http://localhost:'+str(port)],env=env,text=True) + results.update(result='PASS',readiness=ready.strip(),smoke=smoke.strip()) + # Remove only volumes belonging to this newly created unique scratch project. + volumes=subprocess.check_output(['docker','volume','ls','-q','--filter','label=com.docker.compose.project='+project],text=True).split() + for volume in volumes: + labels=json.loads(subprocess.check_output(['docker','volume','inspect',volume],text=True))[0]['Labels'] + assert labels['com.docker.compose.project']==project + results['scratch_volumes']=volumes + finally: + dc('down','--volumes') + results['scratch_cleaned']=True + (ROOT/'evidence/clean-export.json').write_text(json.dumps(results,indent=2),encoding='utf-8') +print('PASS: committed clean export built API/S3, fresh secrets, two API replicas and public smoke; scratch stack cleaned') diff --git a/scripts/wait_ready.py b/scripts/wait_ready.py new file mode 100644 index 00000000..b483a49b --- /dev/null +++ b/scripts/wait_ready.py @@ -0,0 +1,22 @@ +"""Дождаться HTTP readiness перед запуском проверок.""" +import argparse +import time +import urllib.request +parser=argparse.ArgumentParser() +parser.add_argument('--base-url',default='http://localhost:8080') +parser.add_argument('--replicas',type=int,default=1) +args=parser.parse_args() +observed=set() +for _ in range(120): + try: + with urllib.request.urlopen(args.base_url+'/health/ready',timeout=2) as response: + if response.status==200: + observed.add(response.headers.get('X-Instance-Id')) + if len(observed)>=args.replicas: + print('PASS: API ready, replicas:', len(observed)) + break + time.sleep(0.1) + except Exception: + time.sleep(0.5) +else: + raise SystemExit('API readiness timeout') diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app.py b/src/app.py new file mode 100644 index 00000000..131bc654 --- /dev/null +++ b/src/app.py @@ -0,0 +1,166 @@ +import uuid +import os +import socket +from contextlib import asynccontextmanager +import psycopg +from psycopg_pool import PoolTimeout, TooManyRequests +from starlette.concurrency import run_in_threadpool + +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from pydantic import ValidationError as PydanticValidationError +from starlette.exceptions import HTTPException as StarletteHTTPException + +from src.models import ErrorResponse +from src.routes import chats, health, messages, users, attachments +from botocore.exceptions import BotoCoreError, ClientError +from src.storage import storage + + +def create_app() -> FastAPI: + """Создать и настроить приложение FastAPI.""" + @asynccontextmanager + async def lifespan(app): + await run_in_threadpool(storage.pool.open, wait=True) + try: + yield + finally: + await run_in_threadpool(storage.pool.close) + + instance_id = os.getenv("INSTANCE_ID", socket.gethostname()) + "-" + uuid.uuid4().hex[:8] + app = FastAPI(title="MTUSI Messenger Lab4", version="1.4.0", lifespan=lifespan) + + @app.exception_handler(BotoCoreError) + @app.exception_handler(ClientError) + @app.exception_handler(psycopg.OperationalError) + @app.exception_handler(psycopg.errors.QueryCanceled) + @app.exception_handler(psycopg.errors.LockNotAvailable) + @app.exception_handler(PoolTimeout) + @app.exception_handler(TooManyRequests) + async def dependency_error(request, exc): + return JSONResponse(status_code=503, content=ErrorResponse(error={ + "code": "unavailable", "message": "хранилище временно недоступно", + "request_id": request.state.request_id}).model_dump(), + headers={"X-Request-Id": request.state.request_id}) + + @app.middleware("http") + async def add_request_id(request: Request, call_next): + """Добавляет идентификаторы запроса и процесса, ограничивает очередь.""" + request_id = request.headers.get("X-Request-Id", "") or str(uuid.uuid4()) + request.state.request_id = request_id + + # Ограничение числа обслуживаемых запросов в процессе. + if not storage.acquire_request_slot(): + return JSONResponse( + status_code=503, + content=ErrorResponse( + error={ + "code": "unavailable", + "message": "сервер перегружен, попробуйте позже", + "request_id": request_id, + } + ).model_dump(), + headers={"X-Request-Id": request_id, "X-Instance-Id": instance_id}, + ) + + try: + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = instance_id + return response + finally: + storage.release_request_slot() + + @app.exception_handler(StarletteHTTPException) + async def http_exception_handler(request: Request, exc: StarletteHTTPException): + """Обработчик HTTPException: возвращает ошибку в формате контракта {"error": ...}.""" + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + if isinstance(exc.detail, dict) and "error" in exc.detail: + return JSONResponse( + status_code=exc.status_code, + content=exc.detail, + headers={"X-Request-Id": request_id, **(exc.headers or {})}, + ) + return JSONResponse( + status_code=exc.status_code, + content=ErrorResponse( + error={ + "code": "internal_error", + "message": str(exc.detail), + "request_id": request_id, + } + ).model_dump(), + headers={"X-Request-Id": request_id, "X-Instance-Id": instance_id}, + ) + + @app.exception_handler(RequestValidationError) + async def request_validation_handler(request: Request, exc: RequestValidationError): + """Перехватываем ошибки валидации запроса (422 -> 400 по контракту).""" + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + errors = exc.errors() + messages = [] + for err in errors: + loc = ".".join(str(x) for x in err.get("loc", [])) + messages.append(f"{loc}: {err.get('msg', 'invalid')}") + return JSONResponse( + status_code=400, + content=ErrorResponse( + error={ + "code": "invalid_request", + "message": "; ".join(messages), + "request_id": request_id, + } + ).model_dump(), + headers={"X-Request-Id": request_id, "X-Instance-Id": instance_id}, + ) + + @app.exception_handler(PydanticValidationError) + async def validation_exception_handler(request: Request, exc: PydanticValidationError): + """Перехватываем ошибки Pydantic (422 -> 400 по контракту).""" + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + errors = exc.errors() + messages = [] + for err in errors: + loc = ".".join(str(x) for x in err.get("loc", [])) + messages.append(f"{loc}: {err.get('msg', 'invalid')}") + return JSONResponse( + status_code=400, + content=ErrorResponse( + error={ + "code": "invalid_request", + "message": "; ".join(messages), + "request_id": request_id, + } + ).model_dump(), + headers={"X-Request-Id": request_id, "X-Instance-Id": instance_id}, + ) + + @app.exception_handler(Exception) + async def generic_exception_handler(request: Request, exc: Exception): + """Обработчик непредвиденных исключений: скрываем детали, возвращаем 500.""" + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + return JSONResponse( + status_code=500, + content=ErrorResponse( + error={ + "code": "internal_error", + "message": "внутренняя ошибка сервера", + "request_id": request_id, + } + ).model_dump(), + headers={"X-Request-Id": request_id, "X-Instance-Id": instance_id}, + ) + + # Подключаем роуты + app.include_router(health.router) + app.include_router(users.router) + app.include_router(chats.router) + app.include_router(messages.router) + app.include_router(attachments.router) + + return app + + +# Экземпляр приложения для uvicorn +app = create_app() diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..edeb5357 --- /dev/null +++ b/src/cache.py @@ -0,0 +1,60 @@ +"""Необязательный кэш неизменяемого публичного профиля; ошибки обходятся через БД.""" +import logging +import os +from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeout +import threading +from redis import Redis, RedisError +from pydantic import ValidationError +from src.config import setting +from src.models import User + + +class ProfileCache: + def __init__(self): + url = setting('CACHE_URL') + self.client = Redis.from_url(url, decode_responses=True, socket_connect_timeout=0.2, + socket_timeout=0.2, max_connections=16) if url else None + self.ttl = int(os.getenv('PROFILE_CACHE_TTL_SECONDS','60')) + self.hits = self.misses = self.errors = 0 + # DNS может ждать дольше socket timeout; один фоновый вызов ограничивает и время, и очередь. + self._executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix='profile-cache') + self._pending = None + self._guard = threading.Lock() + + def _bounded(self, action, *args, **kwargs): + with self._guard: + if self._pending is not None and not self._pending.done(): + raise RedisError('кэш занят') + self._pending = self._executor.submit(action, *args, **kwargs) + future = self._pending + try: + return future.result(timeout=0.25) + except FutureTimeout: + raise RedisError('истекло время ожидания кэша') from None + + def get(self, user_id): + if not self.client: + return None + try: + value = self._bounded(self.client.get, 'profile:v1:'+user_id) + if value: + user=User.model_validate_json(value) + if user.id != user_id: + raise ValueError('неверный ключ кэша') + self.hits += 1 + return user + self.misses += 1 + except (RedisError, ValidationError, ValueError): + self.errors += 1 + logging.getLogger(__name__).warning('Кэш профиля недоступен; чтение из PostgreSQL') + return None + + def put(self, user): + if self.client: + try: + self._bounded(self.client.set, 'profile:v1:'+user.id,user.model_dump_json(),ex=self.ttl) + except RedisError: + self.errors += 1 + + +profile_cache = ProfileCache() diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..30d65e7a --- /dev/null +++ b/src/config.py @@ -0,0 +1,10 @@ +"""Настройки окружения и чтение секретов из файлов.""" +import os +from pathlib import Path + + +def setting(name, default=None): + path = os.getenv(name + '_FILE') + if path: + return Path(path).read_text(encoding='utf-8').strip() + return os.getenv(name, default) diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..38862ac0 --- /dev/null +++ b/src/main.py @@ -0,0 +1,9 @@ +import os + +import uvicorn + +if __name__ == "__main__": + """Точка входа: запуск Uvicorn с параметрами из переменных окружения.""" + host = os.getenv("APP_HOST", "0.0.0.0") + port = int(os.getenv("APP_PORT", "8080")) + uvicorn.run("src.app:app", host=host, port=port, log_level="info") diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..69dacbfe --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,19 @@ +"""Версионируемые миграции: одна транзакция, блокировка от параллельного запуска.""" +from pathlib import Path +import psycopg +from src.config import setting + + +def main(): + with psycopg.connect(setting('DATABASE_URL'), connect_timeout=5) as conn: + conn.execute('SELECT pg_advisory_xact_lock(2301002)') + conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY)') + for path in sorted(Path('/app/migrations' if Path('/app/migrations').exists() else 'migrations').glob('*.sql')): + if not conn.execute('SELECT 1 FROM schema_migrations WHERE version=%s', (path.name,)).fetchone(): + conn.execute(path.read_text(encoding='utf-8')) + conn.execute('INSERT INTO schema_migrations VALUES (%s)', (path.name,)) + print('Применена миграция:', path.name) + + +if __name__ == '__main__': + main() diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..dc507cce --- /dev/null +++ b/src/models.py @@ -0,0 +1,126 @@ +from datetime import datetime, timezone +from typing import Optional +import uuid + +from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator + + +def utc_now() -> str: + """Возвращает текущее время в формате RFC 3339 UTC с суффиксом Z.""" + return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + + +class ErrorDetail(BaseModel): + """Детали ошибки API.""" + code: str + message: str + request_id: str + + +class ErrorResponse(BaseModel): + """Стандартный ответ об ошибке.""" + error: ErrorDetail + + +class Health(BaseModel): + """Ответ проверки работоспособности.""" + status: str = "ok" + + +class User(BaseModel): + """Модель пользователя.""" + id: str + username: str + display_name: str + created_at: str + + +class CreateUser(BaseModel): + """Данные для создания пользователя.""" + model_config = ConfigDict(extra="forbid", strict=True) + + password: str = Field(..., min_length=12, max_length=128) + username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(..., min_length=1, max_length=100) + + @field_validator("display_name") + @classmethod + def display_name_not_whitespace_only(cls, v: str) -> str: + """Запрещаем display_name, состоящий только из пробельных символов.""" + if v.strip() == "": + raise ValueError("display_name не может состоять только из пробелов") + return v + + +class Chat(BaseModel): + """Модель чата.""" + id: str + title: str + member_ids: list[str] + created_at: str + + +class CreateChat(BaseModel): + """Данные для создания чата.""" + model_config = ConfigDict(extra="forbid", strict=True) + + 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 valid_members(cls, values): + """Проверить UUID и привести их к единому представлению.""" + return [str(uuid.UUID(value)) for value in values] + + @field_validator("title") + @classmethod + def title_not_whitespace_only(cls, v: str) -> str: + """Запрещаем title, состоящий только из пробельных символов.""" + if v.strip() == "": + raise ValueError("title не может состоять только из пробелов") + return v + + +class Message(BaseModel): + """Модель сообщения.""" + id: str + chat_id: str + sender_id: str + text: str + created_at: str + attachment_ids: list[str] = Field(default_factory=list) + + +class CreateMessage(BaseModel): + """Данные для отправки сообщения.""" + model_config = ConfigDict(extra="forbid", strict=True) + + text: str = Field(..., max_length=4000) + attachment_ids: list[str] = Field(default_factory=list, max_length=10) + + @field_validator('attachment_ids') + @classmethod + def valid_attachments(cls, values): + ids = [str(uuid.UUID(v)) for v in values] + if len(set(ids)) != len(ids): + raise ValueError('duplicate attachment_id') + return ids + + @model_validator(mode='after') + def valid_content(self): + if not self.text.strip() and not self.attachment_ids: + raise ValueError('empty message') + return self + + +class ChatPage(BaseModel): + """Страница списка чатов с курсорной пагинацией.""" + items: list[Chat] + next_cursor: Optional[str] = None + + +class MessagePage(BaseModel): + """Страница истории сообщений с курсорной пагинацией.""" + items: list[Message] + next_cursor: Optional[str] = None diff --git a/src/objects.py b/src/objects.py new file mode 100644 index 00000000..ef7f82ee --- /dev/null +++ b/src/objects.py @@ -0,0 +1,17 @@ +"""S3 operations with bounded timeouts and immutable server-generated keys.""" +import boto3 +from botocore.config import Config +from src.config import setting + +def client(): + return boto3.client('s3', endpoint_url=setting('S3_ENDPOINT','http://s3:9000'), + aws_access_key_id=setting('S3_ACCESS_KEY'), aws_secret_access_key=setting('S3_SECRET_KEY'), + region_name='us-east-1', config=Config(connect_timeout=2,read_timeout=5, + retries={'total_max_attempts':1},s3={'addressing_style':'path'})) + +BUCKET = setting('S3_BUCKET','attachments') + +def object_lock(conn, key, wait=True): + fn = 'pg_advisory_xact_lock' if wait else 'pg_try_advisory_xact_lock' + row = conn.execute('SELECT '+fn+'(hashtextextended(%s,42)) AS locked',(key,)).fetchone() + return wait or row['locked'] diff --git a/src/reconcile.py b/src/reconcile.py new file mode 100644 index 00000000..bb076103 --- /dev/null +++ b/src/reconcile.py @@ -0,0 +1,118 @@ +"""Repeatable bounded-memory reconciliation. Dry-run is the default.""" +import argparse +from collections import Counter +from datetime import datetime, timezone +import hashlib +import json +import time +from botocore.exceptions import ClientError +from src.objects import client, BUCKET, object_lock +from src.storage import storage + +def absent(exc): + return exc.response['Error']['Code'] in ('404','NoSuchKey','NotFound') + +def reconcile(apply=False,grace_seconds=3600,page_size=100,output=None): + if grace_seconds<5 or not 1<=page_size<=1000: + raise ValueError('grace must be >=5 seconds; page size 1..1000') + started=time.monotonic(); s3=client(); counts=Counter() + # Fixed cutoff at run start protects objects created during the traversal. + cutoff=datetime.now(timezone.utc).timestamp()-grace_seconds + # Streaming listing; no full bucket/object-body materialization. + paginator=s3.get_paginator('list_objects_v2') + for page in paginator.paginate(Bucket=BUCKET,Prefix='originals/',PaginationConfig={'PageSize':page_size}): + counts['list_requests']+=1 + for obj in page.get('Contents',[]): + counts['objects_scanned']+=1; key=obj['Key'] + with storage.pool.connection() as conn: + if not object_lock(conn,key,wait=False): + counts['locked_skipped']+=1; continue + row=conn.execute('SELECT id FROM attachments WHERE object_key=%s',(key,)).fetchone() + if row: + counts['referenced_kept']+=1; continue + counts['head_requests']+=1 + try: head=s3.head_object(Bucket=BUCKET,Key=key) + except ClientError as exc: + if absent(exc): continue + raise + if head['LastModified'].timestamp()>cutoff: + counts['fresh_kept']+=1; continue + counts['orphan_candidates']+=1 + if apply: + # Only application/reconciler may write this namespace; both hold this lock. + s3.delete_object(Bucket=BUCKET,Key=key) + counts['objects_deleted']+=1 + # Keyset pages keep RAM bounded even for a large metadata table. + last='00000000-0000-0000-0000-000000000000' + while True: + with storage.pool.connection() as conn: + rows=conn.execute('SELECT id,object_key FROM attachments WHERE id>%s ORDER BY id LIMIT %s',(last,page_size)).fetchall() + if not rows: break + counts['db_pages']+=1 + for item in rows: + last=str(item['id']); counts['metadata_scanned']+=1 + with storage.pool.connection() as conn: + if not object_lock(conn,item['object_key'],wait=False): + counts['locked_skipped']+=1; continue + row=conn.execute('SELECT * FROM attachments WHERE id=%s FOR UPDATE',(item['id'],)).fetchone() + if not row: continue + counts['head_requests']+=1 + try: + head=s3.head_object(Bucket=BUCKET,Key=row['object_key']) + except ClientError as exc: + if not absent(exc): raise + counts['missing_objects']+=1 + if row['state']=='ready': + counts['mark_missing_candidates']+=1 + if apply: + conn.execute("UPDATE attachments SET state='missing',updated_at=clock_timestamp() WHERE id=%s",(row['id'],)) + counts['metadata_marked_missing']+=1 + continue + # Verify actual bytes, never trust an ETag or user-provided hash metadata. + digest=hashlib.sha256(); size=0 + counts['get_requests']+=1 + obj=s3.get_object(Bucket=BUCKET,Key=row['object_key']) + try: + for chunk in obj['Body'].iter_chunks(64*1024): + size+=len(chunk); counts['bytes_verified']+=len(chunk) + if size>10*1024*1024: break + digest.update(chunk) + finally: obj['Body'].close() + valid=(size==row['size_bytes'] and digest.hexdigest()==row['sha256'] and head['ContentType']==row['content_type']) + desired='ready' if valid else 'missing' + counts['valid_objects' if valid else 'corrupt_objects']+=1 + if desired!=row['state']: + counts['restore_candidates' if valid else 'mark_missing_candidates']+=1 + if apply: + conn.execute('UPDATE attachments SET state=%s,updated_at=clock_timestamp() WHERE id=%s',(desired,row['id'])) + counts['metadata_restored' if valid else 'metadata_marked_missing']+=1 + result={'apply':apply,'grace_seconds':grace_seconds,'page_size':page_size, + 'elapsed_seconds':round(time.monotonic()-started,6),'counts':dict(counts)} + if output: + from pathlib import Path + Path(output).write_text(json.dumps(result,indent=2),encoding='utf-8') + return result + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--apply',action='store_true') + parser.add_argument('--grace-seconds',type=int,default=3600) + parser.add_argument('--page-size',type=int,default=100) + parser.add_argument('--interval',type=int,default=0,help='repeat every N seconds, 0 = one shot') + args=parser.parse_args() + if args.interval and args.interval<5: + parser.error('interval must be >=5 seconds') + storage.pool.open(wait=True) + try: + while True: + try: + print(json.dumps(reconcile(args.apply,args.grace_seconds,args.page_size)),flush=True) + except Exception as exc: + # Do not log endpoint URLs, DSNs, object keys or credentials. + print(json.dumps({'result':'failed','error_type':type(exc).__name__}),flush=True) + if not args.interval: raise SystemExit(1) from None + if not args.interval: break + time.sleep(args.interval) + finally: storage.pool.close() + +if __name__=='__main__': main() diff --git a/src/routes/__init__.py b/src/routes/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/routes/attachments.py b/src/routes/attachments.py new file mode 100644 index 00000000..e3ca1325 --- /dev/null +++ b/src/routes/attachments.py @@ -0,0 +1,139 @@ +"""Bounded synchronous image uploads; one decode per process.""" +import asyncio +import hashlib +import tempfile +import unicodedata +import uuid +import warnings +from PIL import Image, UnidentifiedImageError +from fastapi import APIRouter, Depends, HTTPException, Request +from starlette.concurrency import run_in_threadpool +from starlette.responses import StreamingResponse +from starlette.requests import ClientDisconnect +from src.routes.common import require_user, make_error, get_request_id +from src.storage import storage, timestamp +from src.objects import client, BUCKET, object_lock + +router = APIRouter() +slots = asyncio.Semaphore(1) +MAX_BYTES=10*1024*1024 +Image.MAX_IMAGE_PIXELS=40_000_000 + +class InvalidImage(Exception): + def __init__(self,status): + self.status=status + +def error(request, status, code, message): + return HTTPException(status, detail=make_error(code,message,get_request_id(request)).model_dump()) + +def inspect_image(stream, declared): + try: + with warnings.catch_warnings(): + warnings.simplefilter('error', Image.DecompressionBombWarning) + with Image.open(stream) as image: + if image.width*image.height>40_000_000: + raise InvalidImage(413) + actual={'PNG':'image/png','JPEG':'image/jpeg'}.get(image.format) + if not actual or actual != declared: + raise InvalidImage(415) + image.verify() + stream.seek(0) + with Image.open(stream) as image: + image.load() + except (Image.DecompressionBombError,Image.DecompressionBombWarning): + raise InvalidImage(413) from None + except (UnidentifiedImageError,OSError,SyntaxError,ValueError): + raise InvalidImage(415) from None + finally: + stream.seek(0) + +def metadata(row): + return {k: str(row[k]) for k in ('id','chat_id','owner_id')} | { + k:row[k] for k in ('filename','content_type','size_bytes','sha256')} | { + 'status':'ready','variants':[],'error_code':None, + 'created_at':timestamp(row['created_at']),'updated_at':timestamp(row['updated_at'])} + +def save(stream, chat_id, owner, filename, content_type, size, digest): + attachment_id=uuid.uuid4() + key='originals/'+str(attachment_id) + # Keep this lock through S3 PUT and DB COMMIT/ROLLBACK. Reconciler shares it. + with storage.pool.connection() as conn: + object_lock(conn,key) + client().put_object(Bucket=BUCKET,Key=key,Body=stream,ContentLength=size, + ContentType=content_type,Metadata={'sha256':digest},IfNoneMatch='*') + row=conn.execute("INSERT INTO attachments(id,chat_id,owner_id,object_key,filename,content_type,size_bytes,sha256,state) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,'ready') RETURNING *", + (attachment_id,chat_id,owner,key,filename,content_type,size,digest)).fetchone() + # Never blindly delete after ambiguous COMMIT: grace-period reconciliation handles it. + return metadata(row) + +@router.post('/api/v1/chats/{chat_id}/attachments',status_code=201) +async def upload(request:Request,chat_id:uuid.UUID,filename:str='',actor:str=Depends(require_user)): + if not await run_in_threadpool(storage.is_chat_member,str(chat_id),actor): + raise error(request,404,'not_found','chat not found') + if not 1<=len(filename)<=255 or any(c in '/\\' or unicodedata.category(c)=='Cc' for c in filename): + raise error(request,400,'invalid_request','invalid filename') + mime=request.headers.get('content-type','').lower() + if mime not in ('image/png','image/jpeg'): + raise error(request,415,'unsupported_media_type','PNG/JPEG required') + length=request.headers.get('content-length') + if length is not None: + if not length.isdecimal(): + raise error(request,400,'invalid_request','invalid length') + if int(length)>MAX_BYTES: + raise error(request,413,'payload_too_large','limit 10 MiB') + try: + await asyncio.wait_for(slots.acquire(),timeout=25) + except asyncio.TimeoutError: + raise error(request,503,'unavailable','upload queue busy') from None + try: + with tempfile.TemporaryFile() as stream: + size=0; digest=hashlib.sha256() + async def receive(): + nonlocal size + async for chunk in request.stream(): + size+=len(chunk) + if size>MAX_BYTES: + raise error(request,413,'payload_too_large','limit 10 MiB') + digest.update(chunk) + await run_in_threadpool(stream.write,chunk) + try: + await asyncio.wait_for(receive(),timeout=20) + await run_in_threadpool(stream.seek,0) + await run_in_threadpool(inspect_image,stream,mime) + except ClientDisconnect: + raise error(request,400,'invalid_request','upload disconnected') from None + except asyncio.TimeoutError: + raise error(request,400,'invalid_request','upload timed out') from None + except InvalidImage as exc: + raise error(request,exc.status,'payload_too_large' if exc.status==413 else 'unsupported_media_type','invalid image') from None + return await run_in_threadpool(save,stream,str(chat_id),actor,filename,mime,size,digest.hexdigest()) + finally: + slots.release() + +def accessible(request,attachment_id,actor): + with storage.pool.connection() as conn: + row=conn.execute('SELECT a.* FROM attachments a JOIN chat_members m ON a.chat_id=m.chat_id WHERE a.id=%s AND m.user_id=%s',(attachment_id,actor)).fetchone() + if not row: + raise error(request,404,'not_found','attachment not found') + if row['state']!='ready': + raise error(request,503,'unavailable','original temporarily unavailable') + return row + +@router.get('/api/v1/attachments/{attachment_id}') +def get_attachment(request:Request,attachment_id:uuid.UUID,actor:str=Depends(require_user)): + return metadata(accessible(request,attachment_id,actor)) + +@router.get('/api/v1/attachments/{attachment_id}/content') +def content(request:Request,attachment_id:uuid.UUID,variant:str='original',actor:str=Depends(require_user)): + row=accessible(request,attachment_id,actor) + if variant not in ('original','thumbnail','crop','optimized'): + raise error(request,400,'invalid_request','invalid variant') + if variant!='original': + raise error(request,404,'not_found','variant not found') + obj=client().get_object(Bucket=BUCKET,Key=row['object_key']) + def chunks(): + try: + yield from obj['Body'].iter_chunks(chunk_size=64*1024) + finally: + obj['Body'].close() + return StreamingResponse(chunks(),media_type=row['content_type'],headers={'Content-Length':str(row['size_bytes'])}) diff --git a/src/routes/chats.py b/src/routes/chats.py new file mode 100644 index 00000000..1324eca1 --- /dev/null +++ b/src/routes/chats.py @@ -0,0 +1,79 @@ +from uuid import UUID + +from fastapi import APIRouter, Depends, HTTPException, Request + +from src.models import Chat, ChatPage, CreateChat +from src.routes.common import get_request_id, make_error, require_user +from src.storage import LimitExceeded, ValidationError, storage + +router = APIRouter() + + +@router.post("/api/v1/chats", response_model=Chat, status_code=201) +def create_chat( + request: Request, + body: CreateChat, + x_user_id: str = Depends(require_user), +): + """Создать чат. Создатель обязательно должен входить в member_ids.""" + request_id = get_request_id(request) + + try: + chat = storage.create_chat(body.title, body.member_ids, x_user_id) + return chat + except ValidationError as e: + raise HTTPException( + status_code=400, + detail=make_error("invalid_request", str(e), request_id).model_dump(), + ) + except LimitExceeded as e: + raise HTTPException( + status_code=429, + detail=make_error("rate_limited", str(e), request_id).model_dump(), + ) + + +@router.get("/api/v1/chats", response_model=ChatPage) +def list_chats( + request: Request, + x_user_id: str = Depends(require_user), + limit: int = 50, + cursor: str | None = None, +): + """Список чатов текущего пользователя с курсорной пагинацией.""" + request_id = get_request_id(request) + + if limit < 1 or limit > 100: + raise HTTPException( + status_code=400, + detail=make_error("invalid_request", "limit должен быть от 1 до 100", request_id).model_dump(), + ) + + try: + items, next_cursor = storage.list_chats_for_user(x_user_id, cursor, limit) + return ChatPage(items=items, next_cursor=next_cursor) + except ValidationError as e: + raise HTTPException( + status_code=400, + detail=make_error("invalid_request", str(e), request_id).model_dump(), + ) + + +@router.get("/api/v1/chats/{chat_id}", response_model=Chat) +def get_chat( + request: Request, + chat_id: UUID, + x_user_id: str = Depends(require_user), +): + """Получить чат по id. Доступен только участникам чата (чужой — 404).""" + request_id = get_request_id(request) + + chat_id_str = str(chat_id) + chat = storage.get_chat(chat_id_str) + if not chat or x_user_id not in chat.member_ids: + raise HTTPException( + status_code=404, + detail=make_error("not_found", "чат не найден", request_id).model_dump(), + ) + + return chat diff --git a/src/routes/common.py b/src/routes/common.py new file mode 100644 index 00000000..628e51e6 --- /dev/null +++ b/src/routes/common.py @@ -0,0 +1,29 @@ +"""Общие ошибки и проверка Bearer-сессии; X-User-Id не используется.""" +from fastapi import HTTPException, Request +from src.models import ErrorResponse +from src.storage import storage + + +def make_error(code, message, request_id): + return ErrorResponse(error={'code': code, 'message': message, 'request_id': request_id}) + + +def get_request_id(request): + return request.state.request_id + + +def unauthorized(request, basic=False): + challenge = 'Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"' + raise HTTPException(401, detail=make_error('unauthorized', 'неверные учётные данные', get_request_id(request)).model_dump(), headers={'WWW-Authenticate': challenge}) + + +def require_user(request: Request): + authorization = request.headers.get('Authorization', '') + parts = authorization.split() + if len(parts) != 2 or parts[0].lower() != 'bearer': + unauthorized(request) + user_id = storage.session_user(parts[1]) + if not user_id: + unauthorized(request) + request.state.token = parts[1] + return user_id diff --git a/src/routes/health.py b/src/routes/health.py new file mode 100644 index 00000000..0e9b4b94 --- /dev/null +++ b/src/routes/health.py @@ -0,0 +1,23 @@ +"""Жизнь процесса и готовность критичного хранилища проверяются отдельно.""" +from fastapi import APIRouter +from src.models import Health +from src.storage import storage +router = APIRouter() + + +@router.get('/health/live') +def liveness(): + return Health() + + +@router.get('/health/ready') +def readiness(): + storage.ready() + from src.objects import client, BUCKET + client().list_objects_v2(Bucket=BUCKET,Prefix="originals/",MaxKeys=1) + return Health() + + +@router.get('/stats') +def stats(): + return storage.get_stats() diff --git a/src/routes/messages.py b/src/routes/messages.py new file mode 100644 index 00000000..1045e5dc --- /dev/null +++ b/src/routes/messages.py @@ -0,0 +1,85 @@ +from uuid import UUID +import re +import os + +from fastapi import APIRouter, Depends, HTTPException, Request + +from src.models import CreateMessage, Message, MessagePage +from src.routes.common import get_request_id, make_error, require_user +from src.storage import NotFoundError, ConflictError, LimitExceeded, ValidationError, storage + +router = APIRouter() + + +@router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201) +def create_message( + request: Request, + chat_id: UUID, + body: CreateMessage, + x_user_id: str = Depends(require_user), +): + """Отправить сообщение от владельца Bearer-сессии с общей защитой повторов.""" + request_id = get_request_id(request) + + chat_id_str = str(chat_id) + if os.getenv('OPTIMIZED_WRITES','1') == '1': + allowed = storage.is_chat_member(chat_id_str, x_user_id) + else: + chat = storage.get_chat(chat_id_str) + allowed = bool(chat and x_user_id in chat.member_ids) + if not allowed: + raise HTTPException( + status_code=404, + detail=make_error("not_found", "чат не найден", request_id).model_dump(), + ) + + try: + key = request.headers.get('Idempotency-Key', '') + if not re.fullmatch(r'[A-Za-z0-9._:-]{1,128}', key): + raise HTTPException(400, detail=make_error('invalid_request', 'неверный Idempotency-Key', request_id).model_dump()) + msg = storage.create_message(chat_id_str, x_user_id, body.text, key, body.attachment_ids) + return msg + except NotFoundError as e: + raise HTTPException(404, detail=make_error('not_found', str(e), request_id).model_dump()) + except ConflictError as e: + raise HTTPException(409, detail=make_error('conflict', str(e), request_id).model_dump()) + except LimitExceeded as e: + raise HTTPException( + status_code=429, + detail=make_error("rate_limited", str(e), request_id).model_dump(), + ) + + +@router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) +def list_messages( + request: Request, + chat_id: UUID, + x_user_id: str = Depends(require_user), + limit: int = 50, + cursor: str | None = None, +): + """История сообщений чата с курсорной пагинацией. Доступно только участникам.""" + request_id = get_request_id(request) + + chat_id_str = str(chat_id) + chat = storage.get_chat(chat_id_str) + if not chat or x_user_id not in chat.member_ids: + raise HTTPException( + status_code=404, + detail=make_error("not_found", "чат не найден", request_id).model_dump(), + ) + + if limit < 1 or limit > 100: + raise HTTPException( + status_code=400, + detail=make_error("invalid_request", "limit должен быть от 1 до 100", request_id).model_dump(), + ) + + try: + items, next_cursor = storage.list_messages(chat_id_str, cursor, limit) + return MessagePage(items=items, next_cursor=next_cursor) + except ValidationError as e: + raise HTTPException( + status_code=400, + detail=make_error("invalid_request", str(e), request_id).model_dump(), + ) diff --git a/src/routes/users.py b/src/routes/users.py new file mode 100644 index 00000000..4709e263 --- /dev/null +++ b/src/routes/users.py @@ -0,0 +1,49 @@ +"""Регистрация, вход, текущий пользователь и отзыв сессии.""" +import base64 +import binascii +from fastapi import APIRouter, Request, Response, HTTPException +from src.models import CreateUser, User +from src.routes.common import get_request_id, make_error, require_user, unauthorized +from src.storage import ConflictError, storage + +router = APIRouter() + + +@router.post('/api/v1/users', response_model=User, status_code=201) +def register_user(request: Request, body: CreateUser): + try: + return storage.create_user(body.username,body.display_name,body.password) + except ConflictError as exc: + raise HTTPException(409,detail=make_error('conflict',str(exc),get_request_id(request)).model_dump()) + + +@router.post('/api/v1/auth/sessions', status_code=201) +async def login(request: Request): + if await request.body(): + raise HTTPException(400, detail=make_error('invalid_request','тело запроса не допускается',get_request_id(request)).model_dump()) + parts = request.headers.get('Authorization','').split() + try: + if len(parts) != 2 or parts[0].lower() != 'basic': + unauthorized(request, basic=True) + username,password = base64.b64decode(parts[1],validate=True).decode('utf-8').split(':',1) + username.encode('ascii') + except (ValueError, UnicodeError, binascii.Error): + unauthorized(request,basic=True) + # Вычисление KDF и синхронные запросы выполняются вне цикла событий. + from starlette.concurrency import run_in_threadpool + result = await run_in_threadpool(storage.login,username,password) + if not result: + unauthorized(request,basic=True) + return result + + +@router.get('/api/v1/users/me',response_model=User) +def current_user(request: Request): + return storage.get_user(require_user(request)) + + +@router.delete('/api/v1/auth/sessions/current',status_code=204) +def logout(request: Request): + require_user(request) + storage.logout(request.state.token) + return Response(status_code=204) diff --git a/src/storage.py b/src/storage.py new file mode 100644 index 00000000..995a4cb1 --- /dev/null +++ b/src/storage.py @@ -0,0 +1,276 @@ +"""PostgreSQL — источник истины; каждый контекст подключения завершает транзакцию.""" +import base64 +import binascii +from datetime import datetime, timezone +import hashlib +import json +import os +import secrets +import threading +import uuid + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError +from psycopg.errors import UniqueViolation, ForeignKeyViolation +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool +from src.config import setting +from src.cache import profile_cache +from src.models import User, Chat, Message + +_CURSOR_FIELDS = {"scope", "resource_id", "created_at", "id"} +PASSWORDS = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) +DUMMY_HASH = PASSWORDS.hash('synthetic-dummy-password') + + +class ValidationError(Exception): + """Неверный запрос.""" + + +class ConflictError(Exception): + """Имя уже занято.""" + + +class LimitExceeded(Exception): + """Перегрузка сервера.""" + + +class NotFoundError(Exception): + """Объект отсутствует или недоступен.""" + + +def timestamp(value): + return value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z') + + +def public_row(row): + return {k: timestamp(v) if isinstance(v, datetime) else str(v) if isinstance(v, uuid.UUID) else v + for k, v in row.items() if k != 'password_hash'} + + +class PostgresStorage: + def __init__(self): + self.pool = ConnectionPool(setting('DATABASE_URL', ''), min_size=1, max_size=int(os.getenv("POOL_SIZE", "10")), + timeout=3, max_waiting=32, open=False, check=ConnectionPool.check_connection, + kwargs={'row_factory': dict_row, 'connect_timeout': 3, + 'options': '-c statement_timeout=3000 -c lock_timeout=2000'}) + self._lock = threading.Lock() + self._requests = 0 + + @staticmethod + def _encode_cursor(scope: str, resource_id: str, created_at: str, item_id: str) -> str: + """Собрать непрозрачный курсор, привязанный к конкретному ресурсу.""" + payload = { + "scope": scope, + "resource_id": resource_id, + "created_at": created_at, + "id": item_id, + } + raw = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii") + + @staticmethod + def _decode_cursor(cursor: str, expected_scope: str, expected_resource_id: str) -> tuple[str, str]: + """Разобрать и проверить курсор. + + Клиент видит курсор как непрозрачную строку, поэтому любые пустые, + повреждённые или относящиеся к другому ресурсу значения отклоняем. + """ + if cursor == "": + raise ValidationError("некорректный cursor") + + allowed_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=" + if any(char not in allowed_chars for char in cursor) or "=" in cursor.rstrip("="): + raise ValidationError("некорректный cursor") + + try: + raw = base64.b64decode(cursor.encode("ascii"), altchars=b"-_", validate=True) + payload = json.loads(raw.decode("utf-8")) + except (UnicodeEncodeError, UnicodeDecodeError, binascii.Error, json.JSONDecodeError): + raise ValidationError("некорректный cursor") + + if not isinstance(payload, dict) or set(payload) != _CURSOR_FIELDS: + raise ValidationError("некорректный cursor") + + if not all(isinstance(payload[field], str) for field in _CURSOR_FIELDS): + raise ValidationError("некорректный cursor") + + if payload["scope"] != expected_scope or payload["resource_id"] != expected_resource_id: + raise ValidationError("некорректный cursor") + + try: + uuid.UUID(payload["resource_id"]) + uuid.UUID(payload["id"]) + datetime.fromisoformat(payload["created_at"].replace("Z", "+00:00")) + except ValueError: + raise ValidationError("некорректный cursor") + + return payload["created_at"], payload["id"] + + + def create_user(self, username, display_name, password): + password_hash = PASSWORDS.hash(password) + try: + with self.pool.connection() as conn: + row = conn.execute('INSERT INTO users (id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING id,username,display_name,created_at', + (uuid.uuid4(), username, display_name, password_hash)).fetchone() + return User(**public_row(row)) + except UniqueViolation: + raise ConflictError('имя пользователя уже занято') from None + + def get_user(self, user_id): + cached = profile_cache.get(user_id) + if cached: + return cached + with self.pool.connection() as conn: + row = conn.execute('SELECT id,username,display_name,created_at FROM users WHERE id=%s', (user_id,)).fetchone() + user = User(**public_row(row)) if row else None + if user: + profile_cache.put(user) + return user + + def login(self, username, password): + with self.pool.connection() as conn: + row = conn.execute('SELECT * FROM users WHERE username=%s', (username,)).fetchone() + try: + PASSWORDS.verify(row['password_hash'] if row else DUMMY_HASH, password) + except (VerifyMismatchError, VerificationError, InvalidHashError): + return None + if not row: + return None + token = secrets.token_urlsafe(32) + with self.pool.connection() as conn: + session = conn.execute("INSERT INTO sessions VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at", + (self.token_hash(token), row['id'], int(os.getenv('SESSION_TTL_SECONDS', '3600')))).fetchone() + return {'token': token, 'token_type': 'Bearer', 'expires_at': timestamp(session['expires_at']), 'user': User(**public_row(row)).model_dump()} + + @staticmethod + def token_hash(token): + return hashlib.sha256(token.encode()).hexdigest() + + def session_user(self, token): + with self.pool.connection() as conn: + row = conn.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()', (self.token_hash(token),)).fetchone() + return str(row['user_id']) if row else None + + def logout(self, token): + with self.pool.connection() as conn: + conn.execute('DELETE FROM sessions WHERE token_hash=%s', (self.token_hash(token),)) + + def create_chat(self, title, member_ids, creator_id): + if len(set(member_ids)) != len(member_ids) or creator_id not in member_ids: + raise ValidationError('неверный список участников') + chat_id = uuid.uuid4() + try: + with self.pool.connection() as conn: + row = conn.execute('INSERT INTO chats (id,title) VALUES (%s,%s) RETURNING *', (chat_id,title)).fetchone() + for member in member_ids: + conn.execute('INSERT INTO chat_members VALUES (%s,%s)', (chat_id,member)) + return Chat(**public_row(row), member_ids=sorted(member_ids)) + except ForeignKeyViolation: + raise ValidationError('участник не существует') from None + + def get_chat(self, chat_id): + with self.pool.connection() as conn: + row = conn.execute('SELECT * FROM chats WHERE id=%s', (chat_id,)).fetchone() + if not row: + return None + members = conn.execute('SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id', (chat_id,)).fetchall() + return Chat(**public_row(row), member_ids=[str(x['user_id']) for x in members]) + + def is_chat_member(self, chat_id, user_id): + """Проверить доступ без загрузки всего чата и списка участников.""" + with self.pool.connection() as conn: + return conn.execute('SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s', (chat_id,user_id)).fetchone() is not None + + def list_chats_for_user(self, user_id, cursor, limit): + with self.pool.connection() as conn: + params = [user_id] + boundary = '' + if cursor is not None: + when, item = self._decode_cursor(cursor, 'chats', user_id) + marker = conn.execute('SELECT 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', (item,user_id)).fetchone() + if not marker or timestamp(marker['created_at']) != when: + raise ValidationError('некорректный cursor') + boundary = ' AND (c.created_at,c.id) > (%s,%s)' + params += [when,item] + rows = conn.execute('SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s' + boundary + ' ORDER BY c.created_at,c.id LIMIT %s', params+[limit+1]).fetchall() + page = [self.get_chat(str(row['id'])) for row in rows[:limit]] + next_cursor = self._encode_cursor('chats',user_id,page[-1].created_at,page[-1].id) if len(rows)>limit else None + return page,next_cursor + + def create_message(self, chat_id, sender_id, text, key, attachment_ids=None): + attachment_ids = attachment_ids or [] + normalized = {'text': text, 'attachment_ids': attachment_ids} + # Блокировка сериализует один ключ на всех репликах; результат и сообщение атомарны. + with self.pool.connection() as conn: + scope = json.dumps([sender_id, chat_id, key]) + conn.execute('SELECT pg_advisory_xact_lock(hashtextextended(%s, 0))', (scope,)) + old = conn.execute('SELECT * FROM message_requests WHERE user_id=%s AND chat_id=%s AND key=%s AND expires_at>clock_timestamp()', (sender_id,chat_id,key)).fetchone() + if old: + if json.loads(old['body']) != normalized: + raise ConflictError('ключ уже использован с другим сообщением') + row = conn.execute('SELECT * FROM messages WHERE id=%s', (old['message_id'],)).fetchone() + return self.message_model(conn, row) + for attachment_id in sorted(attachment_ids): + attachment = conn.execute('SELECT state FROM attachments WHERE id=%s AND chat_id=%s FOR SHARE', (attachment_id,chat_id)).fetchone() + if not attachment: + raise NotFoundError('вложение не найдено') + if attachment['state'] != 'ready': + raise ConflictError('вложение недоступно') + optimized = os.getenv('OPTIMIZED_WRITES','1') == '1' + if not optimized: + conn.execute('DELETE FROM message_requests WHERE user_id=%s AND chat_id=%s AND key=%s', (sender_id,chat_id,key)) + row = conn.execute('INSERT INTO messages (id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *', (uuid.uuid4(),chat_id,sender_id,text)).fetchone() + # Под той же блокировкой UPSERT заменяет просроченный результат без отдельного DELETE. + suffix = ' ON CONFLICT (user_id,chat_id,key) DO UPDATE SET body=EXCLUDED.body,message_id=EXCLUDED.message_id,expires_at=EXCLUDED.expires_at' if optimized else '' + conn.execute("INSERT INTO message_requests VALUES (%s,%s,%s,%s,%s,clock_timestamp()+interval '24 hours')"+suffix, (sender_id,chat_id,key,json.dumps(normalized,ensure_ascii=False),row['id'])) + for position, attachment_id in enumerate(attachment_ids): + conn.execute('INSERT INTO message_attachments VALUES (%s,%s,%s)', (row['id'],attachment_id,position)) + result = self.message_model(conn,row) + return result + + @staticmethod + def message_model(conn, row): + ids = conn.execute('SELECT attachment_id FROM message_attachments WHERE message_id=%s ORDER BY position', (row['id'],)).fetchall() + return Message(**public_row(row), attachment_ids=[str(x['attachment_id']) for x in ids]) + + def list_messages(self, chat_id, cursor, limit): + with self.pool.connection() as conn: + params = [chat_id] + boundary = '' + if cursor is not None: + when,item = self._decode_cursor(cursor,'messages',chat_id) + marker = conn.execute('SELECT created_at FROM messages WHERE id=%s AND chat_id=%s', (item,chat_id)).fetchone() + if not marker or timestamp(marker['created_at']) != when: + raise ValidationError('некорректный cursor') + boundary = ' AND (created_at,id) > (%s,%s)' + params += [when,item] + rows = conn.execute('SELECT * FROM messages WHERE chat_id=%s' + boundary + ' ORDER BY created_at,id LIMIT %s', params+[limit+1]).fetchall() + page = [self.message_model(conn,row) for row in rows[:limit]] + next_cursor = self._encode_cursor('messages',chat_id,page[-1].created_at,page[-1].id) if len(rows)>limit else None + return page,next_cursor + + def ready(self): + with self.pool.connection() as conn: + conn.execute('SELECT 1 FROM schema_migrations LIMIT 1') + + def acquire_request_slot(self): + with self._lock: + if self._requests >= 100: + return False + self._requests += 1 + return True + + def release_request_slot(self): + with self._lock: + self._requests -= 1 + + def get_stats(self): + with self.pool.connection() as conn: + result = {table: conn.execute('SELECT count(*) AS n FROM '+table).fetchone()['n'] for table in ('users','chats','messages')} + result['profile_cache'] = {'hits': profile_cache.hits, 'misses': profile_cache.misses, 'errors': profile_cache.errors, 'ttl_seconds': profile_cache.ttl} + return result + + +storage = PostgresStorage() diff --git a/student-tests/README.md b/student-tests/README.md new file mode 100644 index 00000000..bbd9e1f4 --- /dev/null +++ b/student-tests/README.md @@ -0,0 +1,56 @@ +# Собственные проверки лабораторной 4 + +Ляхонов Сергей, БВТ2301. Все данные синтетические, только отдельный Compose project `lyakhonov-lab4`. +Команды выполнять из корня лабораторной 4. На Windows установить `$env:PYTHONUTF8='1'`. + +## HTTP и отказы + +```powershell +python tests/smoke.py --base-url http://localhost:8084 +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:8084 +python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://localhost:8084 +docker compose start api +python student-tests/test_operations.py +``` + +Последний тест сам останавливает и восстанавливает обе именно загрузившие API-реплики, затем S3 и весь стенд. +Сохраняет реальные container IDs, StartedAt, SHA-256 и времена в evidence/operations.json. Тома не удаляет. +При отсутствии S3 readiness исключает обе API из LB: после обнаружения недоступен весь API. Прежняя сессия проверяется после восстановления. + +```powershell +docker compose run --rm --no-deps -T -v "${PWD}:/suite:ro" -w /suite api python student-tests/test_attachments.py +``` + +Проверяет PNG/JPEG, порчу, MIME, filename, размер/пиксели, ACL, чужой чат, семантику и конкурентность идемпотентности, +приватный bucket и отсутствие административных/вне-prefix прав у приложения. +Отправляет реальный оборванный HTTP body и временно ставит триггер только для нового тестового чата, +чтобы отказать в INSERT после S3 PUT. Триггер снимается в finally. Если процесс аварийно убит, +оператор должен снять lab4_test_failure перед продолжением; не запускать одновременно с другими тестами. +Созданный orphan предназначен для следующей проверки сверки. + +## Сверка и стоимость обхода + +```powershell +docker compose run --rm --no-deps -T -v "${PWD}:/suite:ro" -w /suite api python student-tests/test_reconcile.py +``` + +Dry-run не меняет объекты/метаданные. Apply удаляет только старые orphan, пропускает активную блокировку и свежий объект. +Missing/corrupt переводятся во внутреннее missing без удаления метаданных/ссылок сообщений. +Неверные bytes не восстанавливают ready; корректный размер/SHA-256/MIME восстанавливают. Проверены повторный и два конкурентных запуска. +В тесте grace=5 секунд, ожидание=6 секунд; обычный grace=3600 секунд, уменьшать на рабочем стенде не следует. +Стоимость: добавляются 0/50/200 объектов по 1 KiB, по три dry-run с page_size=50 при неизменном наборе метаданных; +сохраняются elapsed, LIST/HEAD/GET, проверенные bytes, число строк/страниц. Тестовые cost-объекты удаляются явно по своему уникальному prefix. + +## Нагрузка загрузки + +```powershell +python scripts/run_upload_load.py +``` + +Два PNG из фиксированного seed: 1024² и 1792² RGB, примерно 3 и 9.2 MiB. По одному прогреву на размер и по три партии +из десяти одновременных загрузок через LB. Повторов POST нет. После партии скачиваются все подтверждённые оригиналы. +Измерительное elapsed включает завершение запросов, но не последующее скачивание. p50/p95/p99 — только успешные запросы; +при 10 наблюдениях хвостовые перцентили грубые, не production SLA. Closed-loop, coordinated omission не исправлена. +Хост собирает Docker stats и kernel cgroup memory.peak до/после; peak включает всю жизнь этих контейнеров. +Для отделения опыта от прежней активности сначала пересоздать только API (`docker compose up -d --no-deps --force-recreate api`), дождаться двух реплик. +Генератор использует тот же образ/API resource limits, но отдельный одноразовый контейнер. Другие нагрузочные тесты одновременно не запускать. diff --git a/student-tests/test_attachments.py b/student-tests/test_attachments.py new file mode 100644 index 00000000..1ae780fc --- /dev/null +++ b/student-tests/test_attachments.py @@ -0,0 +1,105 @@ +"""Real HTTP negative/transaction tests against the isolated lab4 stack.""" +import base64 +from concurrent.futures import ThreadPoolExecutor +import hashlib +import http.client +import io +import json +from pathlib import Path +import socket +import sys +import time +from urllib.parse import quote +import uuid +sys.path.insert(0,str(Path(__file__).resolve().parents[1])) +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests')) +from client import Client, check +from PIL import Image +from botocore import UNSIGNED +from botocore.config import Config +from botocore.exceptions import ClientError +import boto3 +from src.storage import storage +from src.objects import client,BUCKET + +def main(): + c=Client('http://lb:8080',timeout=40) + alice,bob,eve,chat=c.bootstrap(); path='/api/v1/chats/'+chat['id'] + png=(Path('tests/fixtures/sample.png')).read_bytes() + def upload(data=png,mime='image/png',filename='sample.png',expected=201): + return c.call('POST',path+'/attachments?filename='+quote(filename,safe=''),expected, + actor=alice,raw=data,headers={'Content-Type':mime},schema='Attachment' if expected==201 else None) + att=upload()['json'] + for name in ('../x.png','a\\b.png','a/b.png','a\x00.png','a\n.png',''): + upload(filename=name,expected=400) + upload(data=b'not an image',expected=415) + upload(data=png[:100],expected=415) + upload(mime='image/jpeg',expected=415) + upload(mime='application/octet-stream',expected=415) + upload(data=b'x'*(10*1024*1024+1),expected=413) + # Chunked body exercises the streaming limit with no Content-Length. + connection=http.client.HTTPConnection('lb',8080,timeout=30) + connection.request('POST',path+'/attachments?filename=chunked.png',body=iter([b'x'*1048576]*11), + headers={'Authorization':'Bearer '+alice['token'],'Content-Type':'image/png'},encode_chunked=True) + response=connection.getresponse(); payload=json.loads(response.read()); connection.close() + check(response.status==413 and payload['error']['code']=='payload_too_large','chunked byte limit failed') + # Pixel limit checked before decompression. No huge fixture stored in Git. + image=Image.new('L',(8001,5000)); buff=io.BytesIO(); image.save(buff,format='PNG') + upload(data=buff.getvalue(),expected=413) + del image,buff + image=Image.new('RGB',(8000,5000),(1,2,3)); buff=io.BytesIO(); image.save(buff,format='PNG') + upload(data=buff.getvalue()); del image,buff + buff=io.BytesIO(); Image.new('RGB',(48,32),(90,20,10)).save(buff,format='JPEG') + jpeg=buff.getvalue(); j=upload(data=jpeg,mime='image/jpeg',filename='фото.jpg')['json'] + check(c.call('GET','/api/v1/attachments/'+j['id']+'/content',actor=bob)['bytes']==jpeg,'JPEG changed') + upload(data=jpeg[:-20],mime='image/jpeg',expected=415) + c.call('GET','/api/v1/attachments/'+att['id']+'/content?variant=thumbnail',404,actor=bob) + c.call('GET','/api/v1/attachments/'+att['id']+'/content?variant=unknown',400,actor=bob) + c.call('POST',path+'/messages',404,actor=alice,body={'text':'','attachment_ids':[str(uuid.uuid4())]},headers={'Idempotency-Key':uuid.uuid4().hex}) + other=c.call('POST','/api/v1/chats',201,actor=alice,body={'title':'other','member_ids':[alice['id'],bob['id']]},schema='Chat')['json'] + c.call('POST','/api/v1/chats/'+other['id']+'/messages',404,actor=alice,body={'text':'','attachment_ids':[att['id']]},headers={'Idempotency-Key':uuid.uuid4().hex}) + c.call('POST',path+'/messages',400,actor=alice,body={'text':'','attachment_ids':[att['id'],att['id']]},headers={'Idempotency-Key':uuid.uuid4().hex}) + key=uuid.uuid4().hex + with ThreadPoolExecutor(max_workers=16) as pool: + messages=list(pool.map(lambda _:Client('http://lb:8080',timeout=40).message(alice,chat,'',key=key,attachments=[att['id']])['json'],range(16))) + check(len({m['id'] for m in messages})==1,'concurrent attachment retry duplicated') + c.call('POST',path+'/messages',409,actor=alice,body={'text':'','attachment_ids':[j['id']]},headers={'Idempotency-Key':key}) + text_key=uuid.uuid4().hex + m=c.message(alice,chat,'semantic equality',key=text_key)['json'] + check(c.message(alice,chat,'semantic equality',key=text_key,attachments=[])['json']==m,'default [] differs') + # Direct unauthenticated bucket read must fail. No public S3 host port needed. + storage.pool.open(wait=True) + s3=client() + with storage.pool.connection() as conn: + row=conn.execute('SELECT object_key FROM attachments WHERE id=%s',(att['id'],)).fetchone() + unsigned=boto3.client('s3',endpoint_url='http://s3:9000',config=Config(signature_version=UNSIGNED)) + try: unsigned.get_object(Bucket=BUCKET,Key=row['object_key']) + except ClientError as exc: check(exc.response['ResponseMetadata']['HTTPStatusCode']==403,'unsigned wrong error') + else: raise AssertionError('public object') + for operation in (lambda:s3.list_buckets(),lambda:s3.put_object(Bucket=BUCKET,Key='outside-prefix',Body=b'x'),lambda:s3.delete_bucket(Bucket=BUCKET)): + try: operation() + except ClientError as exc: check(exc.response['ResponseMetadata']['HTTPStatusCode']==403,'policy wrong error') + else: raise AssertionError('excessive app S3 privileges') + # Real TCP disconnect before declared length: no S3 PUT or metadata commit. + before=sum(1 for page in s3.get_paginator('list_objects_v2').paginate(Bucket=BUCKET,Prefix='originals/') for _ in page.get('Contents',[])) + sock=socket.create_connection(('lb',8080)) + header=('POST '+path+'/attachments?filename=abort.png HTTP/1.1\r\nHost: lb\r\nAuthorization: Bearer '+alice['token']+'\r\nContent-Type: image/png\r\nContent-Length: 1000000\r\n\r\n').encode() + sock.sendall(header+png[:100]); sock.close(); time.sleep(1) + after=sum(1 for page in s3.get_paginator('list_objects_v2').paginate(Bucket=BUCKET,Prefix='originals/') for _ in page.get('Contents',[])) + check(before==after,'interrupted upload created object') + # Inject DB failure AFTER a real S3 PUT, restricted to this new synthetic chat. + with storage.pool.connection() as conn: + conn.execute("CREATE OR REPLACE FUNCTION lab4_test_failure() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.chat_id='"+chat['id']+"'::uuid THEN RAISE EXCEPTION 'synthetic failure'; END IF; RETURN NEW; END $$") + conn.execute('CREATE TRIGGER lab4_test_failure BEFORE INSERT ON attachments FOR EACH ROW EXECUTE FUNCTION lab4_test_failure()') + try: upload(expected=500) + finally: + with storage.pool.connection() as conn: + conn.execute('DROP TRIGGER IF EXISTS lab4_test_failure ON attachments') + conn.execute('DROP FUNCTION IF EXISTS lab4_test_failure()') + after_failure=sum(1 for page in s3.get_paginator('list_objects_v2').paginate(Bucket=BUCKET,Prefix='originals/') for _ in page.get('Contents',[])) + check(after_failure==after+1,'did not exercise S3/DB gap') + upload() + storage.pool.close() + print(json.dumps({'result':'PASS','concurrent_retries':16,'failure_after_s3_put':True,'interrupted_upload_no_object':True,'private_bucket':True,'restricted_credentials':True})) + +if __name__=='__main__': main() diff --git a/student-tests/test_operations.py b/student-tests/test_operations.py new file mode 100644 index 00000000..c0b03814 --- /dev/null +++ b/student-tests/test_operations.py @@ -0,0 +1,71 @@ +"""Actual Docker failures, scoped by Compose service labels.""" +import hashlib +import json +import os +from pathlib import Path +import subprocess +import sys +import time +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests')) +from client import Client, check, Failure +ROOT=Path(__file__).resolve().parents[1] +BASE=['docker','compose','--project-directory',str(ROOT),'-p','lyakhonov-lab4'] +def dc(*args): return subprocess.check_output(BASE+list(args),text=True).strip() +def info(cid): + x=json.loads(subprocess.check_output(['docker','inspect',cid],text=True))[0] + return {'id':x['Id'][:12],'hostname':x['Config']['Hostname'],'name':x['Name'].lstrip('/'),'running':x['State']['Running'],'started_at':x['State']['StartedAt'],'project':x['Config']['Labels']['com.docker.compose.project']} +def wait(c): + for _ in range(120): + try: c.call('GET','/health/ready'); return + except Failure: time.sleep(.5) + raise AssertionError('readiness did not recover') +def main(): + c=Client('http://localhost:8084',timeout=8) + alice,bob,eve,chat=c.bootstrap() + data=(ROOT/'tests/fixtures/sample.png').read_bytes() + records=[] + ids=dc('ps','-q','api').splitlines() + for cid in ids: + target=info(cid) + check(target['project']=='lyakhonov-lab4','wrong project') + for _ in range(20): + result=c.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=failover.png',201,actor=alice,raw=data,headers={'Content-Type':'image/png'},schema='Attachment') + if result['headers']['X-Instance-Id'].startswith(target['hostname']+'-'): break + else: raise AssertionError('target never uploaded') + started=time.monotonic() + try: + subprocess.check_call(['docker','stop','--time','1',cid],stdout=subprocess.DEVNULL) + check(not info(cid)['running'],'target still running') + for _ in range(40): + try: + downloaded=c.call('GET','/api/v1/attachments/'+result['json']['id']+'/content',actor=bob) + break + except Failure: time.sleep(.25) + else: raise AssertionError('download unavailable') + check(downloaded['bytes']==data,'original changed') + check(not downloaded['headers']['X-Instance-Id'].startswith(target['hostname']+'-'),'same replica') + records.append({'stopped':target,'after':info(cid),'download_instance':downloaded['headers']['X-Instance-Id'],'sha256':hashlib.sha256(downloaded['bytes']).hexdigest(),'recovery_seconds':round(time.monotonic()-started,3)}) + finally: + subprocess.check_call(['docker','start',cid],stdout=subprocess.DEVNULL) + wait(c); time.sleep(3) + attachment,_=c.attachment(alice,chat) + # S3 failure must bound the wait and preserve the existing DB/session. + try: + dc('stop','--timeout','1','s3') + started=time.monotonic() + c.call('GET','/api/v1/attachments/'+attachment['id']+'/content',503,actor=bob) + failure_seconds=time.monotonic()-started + finally: + dc('start','s3'); wait(c) + check(c.call('GET','/api/v1/attachments/'+attachment['id']+'/content',actor=bob)['bytes']==data,'S3 recovery lost original') + before={service:[info(x) for x in dc('ps','-q',service).splitlines()] for service in ('api','db','redis','s3','lb')} + dc('restart','api','db','redis','s3','lb'); wait(c) + after={service:[info(x) for x in dc('ps','-q',service).splitlines()] for service in before} + for service in before: + check(all(a['started_at']!=b['started_at'] for a,b in zip(before[service],after[service])),'service not restarted: '+service) + check(c.call('GET','/api/v1/attachments/'+attachment['id']+'/content',actor=bob)['bytes']==data,'restart lost original') + c.call('GET','/api/v1/users/me',actor=alice,schema='User') + out={'result':'PASS','each_uploading_replica_stopped':records,'s3_503_seconds':failure_seconds,'restart_before':before,'restart_after':after} + (ROOT/'evidence/operations.json').write_text(json.dumps(out,indent=2),encoding='utf-8') + print('PASS: both uploading API replicas stopped; S3 failure/recovery; all services really restarted; original and session preserved') +if __name__=='__main__': main() diff --git a/student-tests/test_reconcile.py b/student-tests/test_reconcile.py new file mode 100644 index 00000000..9d63ec57 --- /dev/null +++ b/student-tests/test_reconcile.py @@ -0,0 +1,82 @@ +"""Real two-store failures, dry-run, locking, grace period, retry and traversal cost.""" +from concurrent.futures import ThreadPoolExecutor +import hashlib +import json +from pathlib import Path +import sys +import time +import uuid +sys.path.insert(0,str(Path(__file__).resolve().parents[1])) +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests')) +from client import Client,check +from src.storage import storage +from src.objects import client,BUCKET,object_lock +from src.reconcile import reconcile + +def keys(s3): + return {o['Key'] for p in s3.get_paginator('list_objects_v2').paginate(Bucket=BUCKET,Prefix='originals/') for o in p.get('Contents',[])} + +def main(): + storage.pool.open(wait=True) + s3=client(); c=Client('http://lb:8080',timeout=30) + alice,bob,eve,chat=c.bootstrap() + att,data=c.attachment(alice,chat) + message=c.message(alice,chat,'used',attachments=[att['id']])['json'] + with storage.pool.connection() as conn: + key=conn.execute('SELECT object_key FROM attachments WHERE id=%s',(att['id'],)).fetchone()['object_key'] + prefix='originals/research-'+uuid.uuid4().hex+'/' + orphan=prefix+'old'; locked=prefix+'locked'; fresh=prefix+'fresh' + for name in (orphan,locked): s3.put_object(Bucket=BUCKET,Key=name,Body=b'orphan') + time.sleep(6) + s3.put_object(Bucket=BUCKET,Key=fresh,Body=b'fresh') + s3.delete_object(Bucket=BUCKET,Key=key) # metadata and used message survive missing bytes + with storage.pool.connection() as conn: + object_lock(conn,locked) + before=keys(s3) + with storage.pool.connection() as snapshot_conn: + metadata_before=snapshot_conn.execute('SELECT id,state,updated_at FROM attachments ORDER BY id').fetchall() + dry=reconcile(False,5,page_size=7) + check(keys(s3)==before,'dry-run deleted an object') + with storage.pool.connection() as snapshot_conn: + check(snapshot_conn.execute('SELECT id,state,updated_at FROM attachments ORDER BY id').fetchall()==metadata_before,'dry-run changed metadata snapshot') + with storage.pool.connection() as other: + check(other.execute('SELECT state FROM attachments WHERE id=%s',(att['id'],)).fetchone()['state']=='ready','dry-run changed metadata') + check(dry['counts'].get('locked_skipped',0)>=1,'in-flight lock ignored') + s3.put_object(Bucket=BUCKET,Key=fresh,Body=b'fresh') + applied=reconcile(True,5,page_size=7) + remaining=keys(s3) + check(orphan not in remaining,'old orphan not removed') + check(locked in remaining and fresh in remaining,'fresh or locked object deleted') + with storage.pool.connection() as conn: + check(conn.execute('SELECT state FROM attachments WHERE id=%s',(att['id'],)).fetchone()['state']=='missing','missing not marked') + check(conn.execute('SELECT count(*) AS n FROM message_attachments WHERE message_id=%s',(message['id'],)).fetchone()['n']==1,'used metadata removed') + c.call('GET','/api/v1/attachments/'+att['id'],503,actor=bob) + repeated=reconcile(True,5,page_size=7) + check(repeated['counts'].get('metadata_marked_missing',0)==0,'not idempotent') + s3.put_object(Bucket=BUCKET,Key=key,Body=b'corrupt',ContentType='image/png') + corrupt=reconcile(True,5,page_size=7) + check(corrupt['counts'].get('corrupt_objects',0)>=1,'corruption not found') + c.call('GET','/api/v1/attachments/'+att['id'],503,actor=bob) + s3.put_object(Bucket=BUCKET,Key=key,Body=data,ContentType='image/png') + restored=reconcile(True,5,page_size=7) + check(restored['counts'].get('metadata_restored',0)==1,'verified object not restored') + check(c.call('GET','/api/v1/attachments/'+att['id']+'/content',actor=bob)['bytes']==data,'restore changed bytes') + # Two repeated concurrent workers must not delete referenced rows/objects. + with ThreadPoolExecutor(max_workers=2) as pool: + concurrent=list(pool.map(lambda _:reconcile(True,5,page_size=11),range(2))) + check(key in keys(s3),'used object removed') + check(c.call('GET','/api/v1/attachments/'+att['id']+'/content',actor=bob)['bytes']==data,'concurrent reconciliation damaged data') + # Fixed-seed count sweep, 3 dry runs per point, same image/data and resources. + cost=[]; created=[] + for count in (0,50,200): + while len(created)