From 01a5023c6d6c78a5087eaf35d78d799376dc2b8f Mon Sep 17 00:00:00 2001 From: Queenfish Date: Thu, 12 Nov 2026 21:14:30 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D1=87=D0=B5=D1=80=D0=B5=D0=B4=D0=B8=20?= =?UTF-8?q?=D0=B8=20=D0=B0=D1=81=D0=B8=D0=BD=D1=85=D1=80=D0=BE=D0=BD=D0=BD?= =?UTF-8?q?=D0=B0=D1=8F=20=D0=BE=D0=B1=D1=80=D0=B0=D0=B1=D0=BE=D1=82=D0=BA?= =?UTF-8?q?=D0=B0=20=D0=B8=D0=B7=D0=BE=D0=B1=D1=80=D0=B0=D0=B6=D0=B5=D0=BD?= =?UTF-8?q?=D0=B8=D0=B9,=20=D1=82=D1=80=D0=B5=D0=BA=201?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .dockerignore | 1 + .env | 14 + .env.example | 25 -- .gitignore | 4 +- Dockerfile | 32 ++ REPORT.md | 173 +++++++- app/__init__.py | 0 app/api/__init__.py | 0 app/api/attachments.py | 242 ++++++++++ app/api/auth.py | 104 +++++ app/api/chats.py | 174 ++++++++ app/api/health.py | 53 +++ app/api/users.py | 58 +++ app/broker.py | 69 +++ app/cache.py | 60 +++ app/config.py | 29 ++ app/db.py | 30 ++ app/lease_checker.py | 37 ++ app/main.py | 113 +++++ app/migrate.py | 19 + app/migrations.py | 31 ++ app/models.py | 111 +++++ app/outbox_relay.py | 31 ++ app/s3.py | 53 +++ app/security.py | 83 ++++ app/session_store.py | 108 +++++ app/storage.py | 511 ++++++++++++++++++++++ app/worker.py | 151 +++++++ compose.yaml | 228 ++++++++++ evidence/demo-ids.txt | 9 + evidence/evidence/README.md | 5 + evidence/orig-demo.png | Bin 0 -> 111817 bytes evidence/queue-prefetch1-large.json | 20 + evidence/queue-prefetch1-medium.json | 20 + evidence/queue-prefetch1-small.json | 20 + evidence/queue-prefetch20-large.json | 20 + evidence/queue-prefetch20-medium.json | 20 + evidence/queue-prefetch20-small.json | 20 + evidence/queue-prefetch5-large.json | 20 + evidence/queue-prefetch5-medium.json | 20 + evidence/queue-prefetch5-small.json | 20 + evidence/queue-recovery.json | 6 + evidence/replay.txt | 6 + evidence/smoke.txt | Bin 0 -> 174 bytes evidence/thumb-demo.jpg | Bin 0 -> 5813 bytes evidence/worker-crash.txt | 11 + migrations/001_users.sql | 7 + migrations/002_chats.sql | 5 + migrations/003_chat_members.sql | 5 + migrations/004_messages.sql | 7 + migrations/005_sessions.sql | 6 + migrations/006_messages_index.sql | 2 + migrations/007_idempotency.sql | 11 + migrations/008_idempotency_index.sql | 2 + migrations/009_chat_version.sql | 1 + migrations/010_attachments.sql | 15 + migrations/011_message_attachments.sql | 5 + migrations/012_attachment_status.sql | 4 + migrations/013_jobs.sql | 17 + migrations/014_attachment_variants.sql | 1 + migrations/015_variant_keys.sql | 1 + migrations/016_outbox.sql | 8 + migrations/017_lease_dlq.sql | 2 + nginx.conf | 31 ++ requirements.txt | 12 + scripts/benchmark_queue.py | 122 ++++++ scripts/replay.py | 31 ++ scripts/scripts/check-balance.py | 38 ++ scripts/scripts/check-chat-validation.py | 45 ++ scripts/scripts/check-models.py | 63 +++ scripts/scripts/check_contract.py | 54 +++ scripts/scripts/fair-scaling-benchmark.py | 230 ++++++++++ scripts/scripts/measure-detection.py | 201 +++++++++ scripts/scripts/plot-scaling.py | 75 ++++ scripts/scripts/presign_compare.py | 144 ++++++ scripts/scripts/ram_experiment.py | 137 ++++++ scripts/scripts/reconcile.py | 75 ++++ scripts/scripts/restart.cmd | 2 + scripts/scripts/restart.example.sh | 10 + scripts/scripts/restart.py | 50 +++ scripts/scripts/restart.sh | 22 + scripts/scripts/rolling-update.py | 111 +++++ scripts/scripts/scaling-benchmark.py | 194 ++++++++ scripts/scripts/stop-one.cmd | 2 + scripts/scripts/stop-one.example.sh | 10 + scripts/scripts/stop-one.py | 34 ++ scripts/scripts/stop-one.sh | 15 + scripts/scripts/test-idempotency.py | 105 +++++ scripts/scripts/validate_openapi.py | 23 + student-tests/__init__.py | 0 student-tests/benchmark.py | 117 +++++ student-tests/cache_experiment.py | 176 ++++++++ student-tests/explain.py | 90 ++++ student-tests/queue_benchmark.py | 186 ++++++++ student-tests/queue_recovery.py | 101 +++++ student-tests/test_attachments.py | 191 ++++++++ student-tests/test_cache.py | 129 ++++++ student-tests/test_presigned.py | 134 ++++++ student-tests/test_race.py | 84 ++++ student-tests/test_resilience.py | 153 +++++++ student-tests/test_validation.py | 264 +++++++++++ student-tests/test_worker_crash.py | 100 +++++ 102 files changed, 6374 insertions(+), 47 deletions(-) create mode 100644 .env delete mode 100644 .env.example create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/api/__init__.py create mode 100644 app/api/attachments.py create mode 100644 app/api/auth.py create mode 100644 app/api/chats.py create mode 100644 app/api/health.py create mode 100644 app/api/users.py create mode 100644 app/broker.py create mode 100644 app/cache.py create mode 100644 app/config.py create mode 100644 app/db.py create mode 100644 app/lease_checker.py create mode 100644 app/main.py create mode 100644 app/migrate.py create mode 100644 app/migrations.py create mode 100644 app/models.py create mode 100644 app/outbox_relay.py create mode 100644 app/s3.py create mode 100644 app/security.py create mode 100644 app/session_store.py create mode 100644 app/storage.py create mode 100644 app/worker.py create mode 100644 compose.yaml create mode 100644 evidence/demo-ids.txt create mode 100644 evidence/evidence/README.md create mode 100644 evidence/orig-demo.png create mode 100644 evidence/queue-prefetch1-large.json create mode 100644 evidence/queue-prefetch1-medium.json create mode 100644 evidence/queue-prefetch1-small.json create mode 100644 evidence/queue-prefetch20-large.json create mode 100644 evidence/queue-prefetch20-medium.json create mode 100644 evidence/queue-prefetch20-small.json create mode 100644 evidence/queue-prefetch5-large.json create mode 100644 evidence/queue-prefetch5-medium.json create mode 100644 evidence/queue-prefetch5-small.json create mode 100644 evidence/queue-recovery.json create mode 100644 evidence/replay.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/thumb-demo.jpg create mode 100644 evidence/worker-crash.txt create mode 100644 migrations/001_users.sql create mode 100644 migrations/002_chats.sql create mode 100644 migrations/003_chat_members.sql create mode 100644 migrations/004_messages.sql create mode 100644 migrations/005_sessions.sql create mode 100644 migrations/006_messages_index.sql create mode 100644 migrations/007_idempotency.sql create mode 100644 migrations/008_idempotency_index.sql create mode 100644 migrations/009_chat_version.sql create mode 100644 migrations/010_attachments.sql create mode 100644 migrations/011_message_attachments.sql create mode 100644 migrations/012_attachment_status.sql create mode 100644 migrations/013_jobs.sql create mode 100644 migrations/014_attachment_variants.sql create mode 100644 migrations/015_variant_keys.sql create mode 100644 migrations/016_outbox.sql create mode 100644 migrations/017_lease_dlq.sql create mode 100644 nginx.conf create mode 100644 requirements.txt create mode 100644 scripts/benchmark_queue.py create mode 100644 scripts/replay.py create mode 100644 scripts/scripts/check-balance.py create mode 100644 scripts/scripts/check-chat-validation.py create mode 100644 scripts/scripts/check-models.py create mode 100644 scripts/scripts/check_contract.py create mode 100644 scripts/scripts/fair-scaling-benchmark.py create mode 100644 scripts/scripts/measure-detection.py create mode 100644 scripts/scripts/plot-scaling.py create mode 100644 scripts/scripts/presign_compare.py create mode 100644 scripts/scripts/ram_experiment.py create mode 100644 scripts/scripts/reconcile.py create mode 100644 scripts/scripts/restart.cmd create mode 100644 scripts/scripts/restart.example.sh create mode 100644 scripts/scripts/restart.py create mode 100644 scripts/scripts/restart.sh create mode 100644 scripts/scripts/rolling-update.py create mode 100644 scripts/scripts/scaling-benchmark.py create mode 100644 scripts/scripts/stop-one.cmd create mode 100644 scripts/scripts/stop-one.example.sh create mode 100644 scripts/scripts/stop-one.py create mode 100644 scripts/scripts/stop-one.sh create mode 100644 scripts/scripts/test-idempotency.py create mode 100644 scripts/scripts/validate_openapi.py create mode 100644 student-tests/__init__.py create mode 100644 student-tests/benchmark.py create mode 100644 student-tests/cache_experiment.py create mode 100644 student-tests/explain.py create mode 100644 student-tests/queue_benchmark.py create mode 100644 student-tests/queue_recovery.py create mode 100644 student-tests/test_attachments.py create mode 100644 student-tests/test_cache.py create mode 100644 student-tests/test_presigned.py create mode 100644 student-tests/test_race.py create mode 100644 student-tests/test_resilience.py create mode 100644 student-tests/test_validation.py create mode 100644 student-tests/test_worker_crash.py diff --git a/.dockerignore b/.dockerignore index bc16e55..447644c 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,4 @@ __pycache__ node_modules evidence .DS_Store +nginx.conf diff --git a/.env b/.env new file mode 100644 index 0000000..9aeacf1 --- /dev/null +++ b/.env @@ -0,0 +1,14 @@ +APP_HOST=0.0.0.0 +APP_PORT=8080 +APP_ENV=lab +SESSION_TTL_SECONDS=3600 +DATABASE_URL=postgresql://messenger:messenger@postgres:5432/messenger +CACHE_URL=redis://valkey:6379/0 +SESSION_STORE=redis + +MINIO_ROOT_USER=minioadmin +MINIO_ROOT_PASSWORD=minioadmin + +RABBITMQ_URL=amqp://messenger:messenger@rabbitmq:5672/ +RABBITMQ_QUEUE=attachment.process.v1 +MAX_ATTEMPTS=5 \ No newline at end of file diff --git a/.env.example b/.env.example deleted file mode 100644 index 119384b..0000000 --- a/.env.example +++ /dev/null @@ -1,25 +0,0 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 -APP_PORT=8080 -APP_ENV=lab -SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url -API_REPLICAS=2 -IDEMPOTENCY_TTL_SECONDS=86400 -S3_ENDPOINT=http://s3:9000 -S3_REGION=us-east-1 -S3_BUCKET=messenger-attachments -S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id -S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key -MAX_UPLOAD_BYTES=10485760 -MAX_IMAGE_PIXELS=40000000 -BROKER_URL_FILE=/run/secrets/broker_url -WORKER_CONCURRENCY=2 -JOB_MAX_ATTEMPTS=5 -JOB_TIMEOUT_SECONDS=60 -STAGING_RETENTION_SECONDS=86400 diff --git a/.gitignore b/.gitignore index b5a7189..5dce9b6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,7 @@ # Local/private state .env -.env.* -!.env.example +.env +!.env secrets/ certs/private/ *.key diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..9f10bcc --- /dev/null +++ b/Dockerfile @@ -0,0 +1,32 @@ +FROM python:3.12-slim AS builder + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir --user -r requirements.txt + +FROM python:3.12-slim + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PATH=/home/appuser/.local/bin:$PATH + +RUN useradd -m -u 1000 appuser + +WORKDIR /app + +COPY --from=builder /root/.local /home/appuser/.local + +COPY ./app ./app +COPY ./migrations ./migrations + +RUN chown -R appuser:appuser /app + +USER appuser + +EXPOSE 8080 + +CMD ["sh", "-c", "export INSTANCE_ID=$(python -c 'import secrets; print(secrets.token_hex(6))') && echo \"[startup] INSTANCE_ID=$INSTANCE_ID\" && exec python -m uvicorn app.main:app --host 0.0.0.0 --port 8080"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e98f75e..da06c70 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,170 @@ # Отчёт — лабораторная 5 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Кузнецова Марина, БВТ2304 +- Целевая оценка: 5, Трек 1 — очередь под перегрузкой +- Commit/PR: пока пусто +- Использованные источники и помощь ИИ: официальная документация FastAPI, asyncpg, aio-pika, MinIO, Pillow, RabbitMQ reliability/confirms, Docker Compose. ИИ применялся для пояснения требований, обсуждения архитектурных решений и проверки корректности реализации. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требования: Python 3.13.15, Docker 26.1.1, git. + + cp .env.example .env + docker compose --env-file .env up -d --build + +Готовность: `{"status":"ok"}` на `http://localhost:8080/health/ready`. В логах `migrate` — `migrations applied`, `Exited (0)`. В логах `minio-init` — `bucket ready`, `Exited (0)`. Реплики `api-1`, `api-2` — `healthy`. `rabbitmq`, `worker`, `outbox`, `lease_checker` — `running`. + +Проверки: + + python -X utf8 tests/smoke.py --base-url http://localhost:8080 + python -X utf8 -m pytest student-tests/test_worker_crash.py -v + +Сценарий защиты уровня 3: + + docker compose --env-file .env stop worker + # upload sample.png → 202 queued + # message с attachment_ids → 201 + # GET /content → 409; обычное сообщение → 201 + docker compose --env-file .env restart api outbox rabbitmq + docker compose --env-file .env start worker + # GET /attachments/{id} → status=ready + docker compose --env-file .env restart rabbitmq + # GET /attachments/{id} → status=ready (задача не потеряна) + +Трек 1: + + python student-tests/queue_benchmark.py --prefetch 1 --size small --files 50 --output evidence/queue-prefetch1-small.json + python student-tests/queue_benchmark.py --prefetch 5 --size small --files 50 --output evidence/queue-prefetch5-small.json + python student-tests/queue_benchmark.py --prefetch 20 --size small --files 50 --output evidence/queue-prefetch20-small.json + python student-tests/queue_benchmark.py --prefetch 1 --size medium --files 30 --output evidence/queue-prefetch1-medium.json + python student-tests/queue_benchmark.py --prefetch 5 --size medium --files 30 --output evidence/queue-prefetch5-medium.json + python student-tests/queue_benchmark.py --prefetch 20 --size medium --files 30 --output evidence/queue-prefetch20-medium.json + python student-tests/queue_benchmark.py --prefetch 1 --size large --files 15 --output evidence/queue-prefetch1-large.json + python student-tests/queue_benchmark.py --prefetch 5 --size large --files 15 --output evidence/queue-prefetch5-large.json + python student-tests/queue_benchmark.py --prefetch 20 --size large --files 15 --output evidence/queue-prefetch20-large.json + python student-tests/queue_recovery.py --files 100 --output evidence/queue-recovery.json + +Остановка: + +- `docker compose down` — без потери данных. +- `docker compose down -v` — удаление volumes. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. + Client → HTTP (Nginx :8080) → api-1, api-2 (FastAPI/Uvicorn) + ↓ + PostgreSQL (users/chats/messages/idempotency_keys/attachments/jobs/outbox) + Valkey (sessions + cache) + MinIO (bucket attachments, приватный; staging/ + originals/ + варианты) + RabbitMQ (durable queue attachment.process.v1, dlq) + worker, outbox_relay, lease_checker (отдельные процессы) -## Доказательства критериев +Минимум lab4 сохранён: две реплики API за Nginx, PostgreSQL и Valkey, идемпотентность, failover, persistence, приватный S3, вложения. В lab5 добавлены RabbitMQ, worker, outbox, lease_checker, состояния вложений, асинхронная обработка изображений. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Приём файла. `POST /chats/{chat_id}/attachments?filename=` принимает сырые bytes, проверяет членство, filename, лимиты (10 MiB, 40 Мпикс), MIME по содержимому, пишет staging в MinIO. В одной транзакции создаёт `attachments` (status=queued), `jobs`, `outbox`, затем возвращает `202 queued`. Остановка API после ответа работу не теряет. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Публикация и обработка. `outbox_relay` публикует job в durable очередь RabbitMQ, помечает `published_at`. `worker` берёт job (prefetch из env), переводит `queued → processing`, ставит `lease_until`, пишет оригинал и варианты, обновляет `attachments.variants`/`variant_keys`, ставит `ready`, удаляет staging. Ack — только после устойчивого эффекта. `lease_checker` возвращает зависшие `processing` в `queued`. -## Эксперименты и отказы +Варианты. `thumbnail` JPEG q85, fit 256×256, EXIF transpose, alpha→белый; `crop` JPEG q85, центр 128×128; `optimized` WebP q80, вписан 1280×1280 без увеличения. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Ошибки. Единый формат `{"error": {"code", "message", "request_id"}}`. Недоступность PostgreSQL, Valkey, MinIO, RabbitMQ → 503. Пользовательские ошибки (400/413/415/404/409) не превращаются в 500. Постоянные ошибки worker (`UnidentifiedImageError`, битые/truncated) → `failed invalid_image` + DLQ без retry. Временные → backoff с jitter до `MAX_ATTEMPTS=5`, затем `failed retry_exhausted` + DLQ. + +Replay. `POST /attachments/{id}/replay` — только для `failed`; `ready` → 409 `already_ready`, `queued/processing` → 409 `not_failed`. Внутри `FOR UPDATE`, новый job+outbox, `attempt=1`. + +## Доказательства критериев «3» + +| Критерий | Команда | Результат | +|---|---|---| +| Возможности lab4 сохранены | `docker compose ps` | api-1, api-2 healthy; postgres, valkey, minio, rabbitmq healthy; worker, outbox, lease_checker Up; lb Up | +| Upload → 202 queued | сценарий защиты, шаг 4 | `upload=202`, `status=queued` | +| 202 только после durable staging + job | код `app/api/attachments.py` | staging в S3 → `create_attachment_with_job_and_outbox` (одна транзакция) → 202 | +| broker и worker отдельно, durable, at-least-once | `compose.yaml`, `app/broker.py` | сервисы `rabbitmq`, `worker`; `durable=True`, `DeliveryMode.PERSISTENT`, `ack` после handler | +| queued/processing/ready/failed | `013_jobs.sql`, `app/worker.py`, `app/api/attachments.py` | `att_status=queued` в сценарии, `final_status=ready` | +| thumbnail 256×160, оригинал неизменен | сценарий защиты, шаги 9–11 | `thumbnail 256×160 image/jpeg`; SHA-256 оригинала = SHA-256 fixture `99EA…BD75` | +| Ограниченный retry, финальный failed с error_code | `MAX_ATTEMPTS=5`, `app/worker.py` | `fail_attachment(...,"retry_exhausted")` + DLQ | +| Повтор не создаёт второй набор вариантов | `app/worker.py` | ключи `thumbnails/{chat}/{id}.jpg` детерминированы; `if att["status"]=="ready": return` | +| Остановка worker → content 409, остальное работает | сценарий защиты, шаги 4–7 | `content_status=409`, `other_message_id` получен | +| Рестарт broker с volume сохраняет работу | `docker compose restart rabbitmq` + GET | `status=ready` после рестарта | +| Публичный smoke | `python -X utf8 tests/smoke.py --base-url http://localhost:8080` | `PASS: lab5 public API scenario` | + + +## Доказательства критериев «4» + +| Критерий | Команда | Результат | +|---|---|---| +| crop 128×128 и optimized WebP | сценарий защиты | `crop 128×128 image/jpeg`, `optimized 320×200 image/webp` | +| Параметры качества/удаления EXIF описаны | `app/worker.py` | thumbnail JPEG q85, fit 256×256, EXIF transpose, alpha→белый; crop JPEG q85, центр 128×128; optimized WebP q80, вписан 1280×1280 без увеличения | +| Невалидные/огромные изображения ограничены | `app/api/attachments.py` | `MAX_BYTES=10 MiB`, `MAX_PIXELS=40M`; worker обрабатывает только провалидированные | +| Транзакция attachment + job + outbox | `storage.create_attachment_with_job_and_outbox` | одна транзакция; разрыв COMMIT↔publish закрыт | +| Различение постоянных/временных ошибок | `app/worker.py`, `is_permanent` | битые → `failed invalid_image` без retry; временные → backoff+jitter до `MAX_ATTEMPTS`, затем `retry_exhausted` + DLQ | +| Replay failed | `POST /attachments/{id}/replay` | ready → 409; failed → 202 и ready; `evidence/replay.txt` | +| Worker crash до ack | `python -m pytest student-tests/test_worker_crash.py -v` | `1 passed`; variants совпадают; `evidence/worker-crash.txt` | +| Timeout/lease для зависшего processing | `app/lease_checker.py` | `get_expired_jobs`, `reset_job_status` | +| Ограниченная конкуренция/prefetch | `app/broker.py` | `PREFETCH_COUNT` из env | +| Очистка staging после безопасной фиксации | `app/worker.py` | `s3.remove(staging_key)` после `complete_attachment_ready` | +| DLQ/реестр failed | `app/worker.py` | `publish_job(job, is_dlq=True)` + `attachments.status='failed'` | + +Replay: `att_id=559d9cab-90a0-4baf-b36f-355ad93ffae2`, `chat_id=ce16016a-c647-4d87-8697-1061f25ff47c`, `POST /replay` на ready → 409, после `failed/simulated_failure` → 202 → ready. + +Worker crash: файл готов → удалили thumbnail из S3 → `attachments.status='failed'`, `error_code='ack_lost'` → `POST /replay` → 202 → ready; `variants` совпадают. + +## Трек 1: очередь под перегрузкой + +Гипотеза. Увеличение `PREFETCH_COUNT` повышает throughput на малых изображениях, но на больших (4000×3000) выигрыш ограничен CPU и памятью worker; при перегрузке queue lag растёт, потому что API не делает backpressure. + +Методика. Docker Desktop (Compose v2) на Windows. Лимиты: worker 1 CPU / 512 MiB, API 0.5 CPU / 256 MiB, RabbitMQ 0.5 CPU / 256 MiB. Размеры: small 320×200, medium 1280×800, large 4000×3000 PNG. Prefetch: 1, 5, 20. Файлов на прогон: small 50, medium 30, large 15. Метрики: throughput, queue lag (`t_processing - t_upload`, p50/p95/p99), time-to-ready (`t_ready - t_upload`, p50/p95/p99), RSS worker. Скрипт: `student-tests/queue_benchmark.py`, вывод в `evidence/queue-prefetch{P}-{size}.json`. Recovery: `student-tests/queue_recovery.py`, 100 medium при остановленном worker, вывод в `evidence/queue-recovery.json`. + +Результаты: + +| prefetch | size | files ok | throughput files/s | queue lag p95, s | time-to-ready p95, s | worker RSS, MiB | +|---|---|---|---|---|---|---| +| 1 | small | 50/50 | 5.56 | 5.79 | 5.82 | 37.9 | +| 5 | small | 50/50 | 5.98 | 5.04 | 5.21 | 43.8 | +| 20 | small | 50/50 | 5.84 | 5.35 | 5.39 | 42.5 | +| 1 | medium | 30/30 | 5.02 | 3.04 | 3.08 | 50.6 | +| 5 | medium | 30/30 | 4.76 | 3.30 | 3.52 | 114.0 | +| 20 | medium | 30/30 | 4.89 | 2.95 | 3.43 | 112.6 | +| 1 | large | 15/15 | 1.36 | 7.28 | 7.93 | 97.5 | +| 5 | large | 15/15 | 0.83 | 11.22 | 14.84 | 511.7 | +| 20 | large | 0/15 (таймаут скрипта) | — | — | — | — | + +Наблюдения. На small оптимум prefetch=5: throughput 5.98 против 5.56 (prefetch=1) и 5.84 (prefetch=20), queue lag и time-to-ready минимальны (5.04 / 5.21 с). На medium prefetch=1 даёт лучший throughput (5.02) и минимальный RSS (50.6 MiB); prefetch=5 и 20 дают RSS 112–114 MiB без выигрыша. На large prefetch=1 даёт throughput 1.36 files/s и RSS 97.5 MiB; prefetch=5 — throughput 0.83 и RSS 511.7 MiB (почти лимит 512 MiB); prefetch=20 не завершил 15 файлов за 600 с — скрипт зафиксировал `files_ok=0`, по логам worker доработал после таймаута, `OOMKilled: false`. Компромисс: prefetch=1 — минимальный RSS; prefetch=5 — лучший throughput на small; prefetch=20 не даёт выигрыша ни на одном размере. Для этого стенда оптимум — prefetch 1–5 в зависимости от размера. + +Backpressure. Не реализован: API возвращает 202 независимо от глубины очереди. Цена — queue lag растёт при накоплении; ограничение — только `PREFETCH_COUNT` и память worker. + +Восстановление после перегрузки. 100 medium загружены при остановленном worker, очередь копилась, затем worker запущен: 100/100 обработаны за 22.749 с. См. `evidence/queue-recovery.json`. + +Ограничения Трека 1. Closed-loop клиент, один Docker-host, шум от Docker Desktop, prefetch меняется через пересоздание worker (не на лету), large-прогоны короткие (15 файлов), для prefetch=20 large — таймаут скрипта. Числа — сравнение конфигураций на одном стенде, не production SLA. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Что выдерживается: + +- Перезапуск API, broker и worker с сохранением volumes: принятая работа не теряется, задача доходит до ready. +- Остановка worker: accepted-задачи остаются в `queued`, content отдаёт 409, остальные сообщения работают. +- Рестарт RabbitMQ с volume: `status=ready` сохраняется. +- Повторная доставка: набор вариантов не размножается, ключи объектов детерминированы. +- Постоянные ошибки worker: `failed invalid_image` + DLQ, без бесконечного retry. +- Replay failed: `failed → queued → ready`, ready не перезаписывается. +- Недоступность PostgreSQL, Valkey, MinIO или RabbitMQ: `/health/ready` → 503. +- Пользовательские ошибки вложений (400/413/415/404/409) не превращаются в 500. + +Что не выдерживается: + +- Потеря Docker-хоста целиком: все контейнеры на одном узле. +- Потеря узла PostgreSQL: без репликации БД не выживет. +- Потеря узла Nginx: LB — SPOF. +- Потеря узла MinIO: без репликации S3 не выживет. +- Потеря узла RabbitMQ: durable очередь на одном узле, без кластера. +- `outbox_relay` и `lease_checker` в одном экземпляре — SPOF для публикации и восстановления зависших задач. +- Backpressure не реализован: API принимает upload всегда, очередь может расти. + +Учебные упрощения: + +- Все контейнеры на одном Docker-хосте. +- Nginx без активных healthcheck (только пассивные по max_fails). +- HTTP без TLS +- Миграции не поддерживают rollback. +- Ключ эффекта `(attachment_id, pipeline_version, variant)` обеспечен детерминированными ключами объектов, а не отдельной таблицей; повторная доставка перезаписывает те же объекты. +- Worker crash-тест имитирует потерю ack через удаление объекта в S3 и `UPDATE status='failed'`, а не через `SIGKILL` в момент `ack`. \ No newline at end of file diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/api/__init__.py b/app/api/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/api/attachments.py b/app/api/attachments.py new file mode 100644 index 0000000..4992286 --- /dev/null +++ b/app/api/attachments.py @@ -0,0 +1,242 @@ +import hashlib +import re +import uuid +from datetime import datetime, timezone +from io import BytesIO + +from fastapi import APIRouter, Header, Request +from fastapi.responses import JSONResponse, StreamingResponse +from PIL import Image, UnidentifiedImageError + +from app.security import get_current_user + +router = APIRouter(tags=["attachments"]) + +MAX_BYTES = 10 * 1024 * 1024 +MAX_PIXELS = 40_000_000 +ALLOWED = {"PNG": "image/png", "JPEG": "image/jpeg"} +BAD_FILENAME = re.compile(r'[/\\\x00-\x1f]') +BEARER_CHALLENGE = 'Bearer realm="messenger"' +CHUNK = 64 * 1024 + + +def error_response(status, code, message, request_id, headers=None): + return JSONResponse( + status_code=status, + content={"error": {"code": code, "message": message, "request_id": request_id}}, + headers=headers or {}, + ) + + +def validate_image(data: bytes): + if len(data) == 0: + raise ValueError("unsupported_media_type") + if len(data) > MAX_BYTES: + raise ValueError("payload_too_large") + try: + img = Image.open(BytesIO(data)) + img.verify() + img = Image.open(BytesIO(data)) + fmt = img.format + w, h = img.size + except (UnidentifiedImageError, OSError, ValueError): + raise ValueError("unsupported_media_type") + if fmt not in ALLOWED: + raise ValueError("unsupported_media_type") + if w * h > MAX_PIXELS: + raise ValueError("payload_too_large") + return ALLOWED[fmt], w, h, hashlib.sha256(data).hexdigest() + + +def safe_filename(name: str) -> str: + if not name or len(name) > 255: + raise ValueError("invalid_request") + if BAD_FILENAME.search(name): + raise ValueError("invalid_request") + return name + + +async def _auth(request, authorization): + try: + user, _ = await get_current_user(request, authorization) + return user, None + except Exception: + return None, error_response( + 401, "unauthorized", "unauthorized", request.state.request_id, + headers={"WWW-Authenticate": BEARER_CHALLENGE}, + ) + + +async def _read_limited(request, limit): + buf = bytearray() + async for chunk in request.stream(): + buf.extend(chunk) + if len(buf) > limit: + raise ValueError("payload_too_large") + return bytes(buf) + + +@router.post("/chats/{chat_id}/attachments", status_code=202) +async def upload_attachment(chat_id: str, filename: str, request: Request, + authorization: str | None = Header(default=None)): + rid = request.state.request_id + try: + uuid.UUID(chat_id) + except (ValueError, TypeError): + return error_response(400, "invalid_request", "invalid uuid", rid) + + user, err = await _auth(request, authorization) + if err is not None: + return err + + if not await request.app.state.storage.is_chat_member(chat_id, user["id"]): + return error_response(404, "not_found", "chat not found", rid) + + try: + safe_filename(filename) + except ValueError: + return error_response(400, "invalid_request", "invalid filename", rid) + + try: + data = await _read_limited(request, MAX_BYTES) + except ValueError: + return error_response(413, "payload_too_large", "payload_too_large", rid) + + try: + content_type, w, h, sha = validate_image(data) + except ValueError as e: + code = str(e) + status = 413 if code == "payload_too_large" else 415 + return error_response(status, code, code, rid) + + att_id = str(uuid.uuid4()) + staging_key = f"staging/{chat_id}/{att_id}" + + try: + request.app.state.s3.put(staging_key, data, content_type) + except Exception: + return error_response(503, "unavailable", "storage unavailable", rid) + + job = { + "schema_version": 1, + "job_id": str(uuid.uuid4()), + "type": "attachment.process.v1", + "attachment_id": att_id, + "pipeline_version": 1, + "attempt": 1, + "created_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"), + } + try: + att = await request.app.state.storage.create_attachment_with_job_and_outbox( + att_id, chat_id, user["id"], staging_key, + filename, content_type, len(data), sha, job, + ) + except Exception: + try: + request.app.state.s3.remove(staging_key) + except Exception: + pass + return error_response(503, "unavailable", "queue unavailable", rid) + + return att + + +@router.get("/attachments/{attachment_id}") +async def get_attachment(attachment_id: str, request: Request, + authorization: str | None = Header(default=None)): + rid = request.state.request_id + try: + uuid.UUID(attachment_id) + except (ValueError, TypeError): + return error_response(400, "invalid_request", "invalid uuid", rid) + user, err = await _auth(request, authorization) + if err is not None: + return err + att = await request.app.state.storage.get_attachment(attachment_id) + if att is None: + return error_response(404, "not_found", "attachment not found", rid) + if not await request.app.state.storage.is_chat_member(att["chat_id"], user["id"]): + return error_response(404, "not_found", "attachment not found", rid) + att.pop("_object_key", None) + att.pop("_variant_keys", None) + return att + + +@router.post("/attachments/{attachment_id}/replay", status_code=202) +async def replay_attachment(attachment_id: str, request: Request, + authorization: str | None = Header(default=None)): + rid = request.state.request_id + try: + uuid.UUID(attachment_id) + except (ValueError, TypeError): + return error_response(400, "invalid_request", "invalid uuid", rid) + user, err = await _auth(request, authorization) + if err is not None: + return err + att = await request.app.state.storage.get_attachment(attachment_id) + if att is None: + return error_response(404, "not_found", "attachment not found", rid) + if not await request.app.state.storage.is_chat_member(att["chat_id"], user["id"]): + return error_response(404, "not_found", "attachment not found", rid) + result = await request.app.state.storage.replay_failed_attachment(attachment_id) + if result == "not_found": + return error_response(404, "not_found", "attachment not found", rid) + if result == "already_ready": + return error_response(409, "conflict", "attachment already ready", rid) + if result == "not_failed": + return error_response(409, "conflict", "attachment is not failed", rid) + att = await request.app.state.storage.get_attachment(attachment_id) + att.pop("_object_key", None) + att.pop("_variant_keys", None) + return att + + +@router.get("/attachments/{attachment_id}/content") +async def download_attachment(attachment_id: str, request: Request, + variant: str = "original", + authorization: str | None = Header(default=None)): + rid = request.state.request_id + try: + uuid.UUID(attachment_id) + except (ValueError, TypeError): + return error_response(400, "invalid_request", "invalid uuid", rid) + user, err = await _auth(request, authorization) + if err is not None: + return err + att = await request.app.state.storage.get_attachment(attachment_id) + if att is None: + return error_response(404, "not_found", "attachment not found", rid) + if not await request.app.state.storage.is_chat_member(att["chat_id"], user["id"]): + return error_response(404, "not_found", "attachment not found", rid) + + if att["status"] in ("queued", "processing"): + return error_response(409, "conflict", "attachment not ready", rid) + if att["status"] == "failed": + return error_response(409, "conflict", "attachment failed", rid) + + if variant == "original": + obj_key = att["_object_key"] + content_type = att["content_type"] + size_bytes = att["size_bytes"] + else: + found = next((v for v in att["variants"] if v["name"] == variant), None) + if not found: + return error_response(404, "not_found", "variant not found", rid) + + obj_key = att["_variant_keys"].get(variant) + if not obj_key: + return error_response(404, "not_found", "variant key not found", rid) + + content_type = found["content_type"] + size_bytes = found["size_bytes"] + + try: + obj = request.app.state.s3.get(obj_key) + except Exception: + return error_response(503, "unavailable", "storage unavailable", rid) + + return StreamingResponse( + obj.stream(CHUNK), + media_type=content_type, + headers={"Content-Length": str(size_bytes)}, + ) \ No newline at end of file diff --git a/app/api/auth.py b/app/api/auth.py new file mode 100644 index 0000000..de9261a --- /dev/null +++ b/app/api/auth.py @@ -0,0 +1,104 @@ +from fastapi import APIRouter, Header, HTTPException, Request, Response +from fastapi.responses import JSONResponse + +from app.security import ( + parse_basic, + verify_password, + new_token, + session_expires_at, + get_current_user, +) +from app.config import config +from app.models import Session + +router = APIRouter(tags=["auth"]) + +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' + + +def error_response( + status: int, code: str, message: str, request_id: str, headers=None, +) -> JSONResponse: + return JSONResponse( + status_code=status, + content={ + "error": { + "code": code, + "message": message, + "request_id": request_id, + } + }, + headers=headers or {}, + ) + + +@router.post("/auth/sessions", response_model=Session, status_code=201) +async def create_session( + request: Request, + authorization: str | None = Header(default=None), +): + storage = request.app.state.storage + session_store = request.app.state.session_store + rid = request.state.request_id + try: + username, password = parse_basic(authorization) + except HTTPException: + return error_response( + 401, + "unauthorized", + "invalid credentials", + rid, + headers={"WWW-Authenticate": BASIC_CHALLENGE}, + ) + + user_row = await storage.get_user_by_username(username) + if user_row is None or not verify_password(password, user_row["password_hash"]): + return error_response( + 401, + "unauthorized", + "invalid credentials", + rid, + headers={"WWW-Authenticate": BASIC_CHALLENGE}, + ) + + token = new_token() + expires_at = session_expires_at(config.SESSION_TTL_SECONDS) + await session_store.create(token, str(user_row["id"]), expires_at) + + user = { + "id": str(user_row["id"]), + "username": user_row["username"], + "display_name": user_row["display_name"], + "created_at": ( + user_row["created_at"] + .isoformat() + .replace("+00:00", "Z") + ), + } + return { + "token": token, + "token_type": "Bearer", + "expires_at": expires_at.isoformat().replace("+00:00", "Z"), + "user": user, + } + + +@router.delete("/auth/sessions/current", status_code=204) +async def revoke_session( + request: Request, + authorization: str | None = Header(default=None), +): + rid = request.state.request_id + try: + _, token = await get_current_user(request, authorization) + except HTTPException: + return error_response( + 401, + "unauthorized", + "unauthorized", + rid, + headers={"WWW-Authenticate": BEARER_CHALLENGE}, + ) + await request.app.state.session_store.delete(token) + return Response(status_code=204) \ No newline at end of file diff --git a/app/api/chats.py b/app/api/chats.py new file mode 100644 index 0000000..59d097a --- /dev/null +++ b/app/api/chats.py @@ -0,0 +1,174 @@ +import re +import uuid + +from fastapi import APIRouter, Header, HTTPException, Query, Request +from fastapi.responses import JSONResponse + +from app.models import ( + Chat, CreateChat, Message, CreateMessage, ChatPage, MessagePage, +) +from app.security import get_current_user + +router = APIRouter(tags=["chats"]) + +BEARER_CHALLENGE = 'Bearer realm="messenger"' +IDEMPOTENCY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") + + +def error_response(status, code, message, request_id, headers=None): + return JSONResponse( + status_code=status, + content={"error": {"code": code, "message": message, "request_id": request_id}}, + headers=headers or {}, + ) + + +def validate_uuid(value: str) -> None: + try: + uuid.UUID(value) + except (ValueError, TypeError): + raise HTTPException(status_code=400, detail="invalid uuid") + + +def validate_idempotency_key(value: str | None) -> str: + if value is None or not IDEMPOTENCY_RE.match(value): + raise HTTPException(status_code=400, detail="invalid idempotency key") + return value + + +async def resolve_actor(request: Request, authorization: str | None): + rid = request.state.request_id + try: + user, _ = await get_current_user(request, authorization) + except HTTPException as exc: + if exc.status_code == 503: + return None, error_response(503, "unavailable", "auth store unavailable", rid) + return None, error_response( + 401, "unauthorized", "unauthorized", rid, + headers={"WWW-Authenticate": BEARER_CHALLENGE}, + ) + return user, None + + +@router.post("/chats", response_model=Chat, status_code=201) +async def create_chat( + data: CreateChat, + request: Request, + authorization: str | None = Header(default=None), +): + rid = request.state.request_id + actor, err = await resolve_actor(request, authorization) + if err is not None: + return err + + if len(data.member_ids) != len(set(data.member_ids)): + return error_response(400, "invalid_request", "duplicate member_ids", rid) + for mid in data.member_ids: + try: + uuid.UUID(mid) + except (ValueError, TypeError): + return error_response(400, "invalid_request", "invalid member uuid", rid) + + try: + return await request.app.state.storage.create_chat( + data.title, data.member_ids, actor["id"], + ) + except ValueError as e: + msg = str(e) + if msg == "invalid_member": + return error_response(400, "invalid_request", "unknown member", rid) + if msg == "creator_not_member": + return error_response(400, "invalid_request", "creator must be a member", rid) + return error_response(400, "invalid_request", "bad request", rid) + + +@router.get("/chats", response_model=ChatPage) +async def list_chats( + request: Request, + authorization: str | None = Header(default=None), + limit: int = Query(50, ge=1, le=100), + cursor: str | None = Query(None), +): + rid = request.state.request_id + actor, err = await resolve_actor(request, authorization) + if err is not None: + return err + try: + items, next_cursor = await request.app.state.storage.list_chats( + actor["id"], limit, cursor, + ) + except ValueError: + return error_response(400, "invalid_request", "bad cursor", rid) + return {"items": items, "next_cursor": next_cursor} + + +@router.get("/chats/{chat_id}", response_model=Chat) +async def get_chat( + chat_id: str, + request: Request, + authorization: str | None = Header(default=None), +): + rid = request.state.request_id + validate_uuid(chat_id) + actor, err = await resolve_actor(request, authorization) + if err is not None: + return err + chat = await request.app.state.storage.get_chat(chat_id, actor["id"]) + if chat is None: + return error_response(404, "not_found", "chat not found", rid) + return chat + + +@router.post("/chats/{chat_id}/messages", response_model=Message, status_code=201) +async def create_message( + chat_id: str, + data: CreateMessage, + request: Request, + authorization: str | None = Header(default=None), + idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"), +): + rid = request.state.request_id + validate_uuid(chat_id) + validate_idempotency_key(idempotency_key) + actor, err = await resolve_actor(request, authorization) + if err is not None: + return err + + if not data.text.strip() and not data.attachment_ids: + return error_response(400, "invalid_request", "text or attachment_ids required", rid) + + try: + return await request.app.state.storage.add_message( + chat_id, actor["id"], data.text, + data.attachment_ids, idempotency_key, + ) + except ValueError as e: + if str(e) == "idempotency_conflict": + return error_response(409, "conflict", "idempotency key conflict", rid) + if str(e) == "attachment_failed": + return error_response(409, "conflict", "attachment failed", rid) + return error_response(404, "not_found", "chat not found", rid) + + +@router.get("/chats/{chat_id}/messages", response_model=MessagePage) +async def list_messages( + chat_id: str, + request: Request, + authorization: str | None = Header(default=None), + limit: int = Query(50, ge=1, le=100), + cursor: str | None = Query(None), +): + rid = request.state.request_id + validate_uuid(chat_id) + actor, err = await resolve_actor(request, authorization) + if err is not None: + return err + try: + items, next_cursor = await request.app.state.storage.list_messages( + chat_id, actor["id"], limit, cursor, + ) + except ValueError as e: + if str(e) == "bad_cursor": + return error_response(400, "invalid_request", "bad cursor", rid) + return error_response(404, "not_found", "chat not found", rid) + return {"items": items, "next_cursor": next_cursor} \ No newline at end of file diff --git a/app/api/health.py b/app/api/health.py new file mode 100644 index 0000000..537c05f --- /dev/null +++ b/app/api/health.py @@ -0,0 +1,53 @@ +import asyncio +from fastapi import APIRouter, Request +from fastapi.responses import JSONResponse + +router = APIRouter(tags=["health"]) + + +@router.get("/health/live") +async def liveness(): + return {"status": "ok"} + + +async def _check_postgres(request: Request) -> None: + async with request.app.state.storage._pool.acquire() as conn: + await conn.fetchval("SELECT 1") + + +async def _check_redis(request: Request) -> None: + store = request.app.state.session_store + if hasattr(store, "_client"): + await store._client.ping() + + +@router.get("/health/ready") +async def readiness(request: Request): + rid = getattr(request.state, "request_id", "") + try: + await asyncio.wait_for(_check_postgres(request), timeout=2.0) + except Exception: + return JSONResponse( + status_code=503, + content={ + "error": { + "code": "unavailable", + "message": "db unavailable", + "request_id": rid, + } + }, + ) + try: + await asyncio.wait_for(_check_redis(request), timeout=2.0) + except Exception: + return JSONResponse( + status_code=503, + content={ + "error": { + "code": "unavailable", + "message": "cache unavailable", + "request_id": rid, + } + }, + ) + return {"status": "ok"} \ No newline at end of file diff --git a/app/api/users.py b/app/api/users.py new file mode 100644 index 0000000..eabcf2e --- /dev/null +++ b/app/api/users.py @@ -0,0 +1,58 @@ +from fastapi import APIRouter, Header, HTTPException, Request +from fastapi.responses import JSONResponse + +from app.models import User, CreateUser +from app.security import hash_password, get_current_user + +router = APIRouter(tags=["users"]) + + +def error_response( + status: int, code: str, message: str, request_id: str, headers=None, +) -> JSONResponse: + return JSONResponse( + status_code=status, + content={ + "error": { + "code": code, + "message": message, + "request_id": request_id, + } + }, + headers=headers or {}, + ) + + +@router.post("/users", response_model=User, status_code=201) +async def register_user(data: CreateUser, request: Request): + storage = request.app.state.storage + rid = request.state.request_id + password_hash = hash_password(data.password) + try: + user = await storage.create_user( + data.username, data.display_name, password_hash, + ) + return user + except ValueError: + return error_response(409, "conflict", "username already taken", rid) + + +@router.get("/users/me", response_model=User) +async def current_user( + request: Request, + authorization: str | None = Header(default=None), +): + rid = request.state.request_id + try: + user, _ = await get_current_user(request, authorization) + except HTTPException as exc: + if exc.status_code == 503: + return error_response(503, "unavailable", "auth store unavailable", rid) + return error_response( + 401, + "unauthorized", + "unauthorized", + rid, + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + return user \ No newline at end of file diff --git a/app/broker.py b/app/broker.py new file mode 100644 index 0000000..60a2ca8 --- /dev/null +++ b/app/broker.py @@ -0,0 +1,69 @@ +import asyncio +import json +import os + +import aio_pika +from aio_pika.abc import AbstractRobustConnection + +from app.config import config + +_connection: AbstractRobustConnection | None = None +_lock = asyncio.Lock() + +PREFETCH_COUNT = int(os.getenv("PREFETCH_COUNT", "1")) + + +async def get_connection() -> AbstractRobustConnection: + global _connection + async with _lock: + if _connection is None or _connection.is_closed: + _connection = await aio_pika.connect_robust(config.RABBITMQ_URL) + return _connection + + +async def publish_job(job: dict, is_dlq: bool = False) -> None: + connection = await get_connection() + channel = await connection.channel() + queue_name = config.RABBITMQ_QUEUE + (".dlq" if is_dlq else "") + + await channel.declare_queue(queue_name, durable=True) + await channel.default_exchange.publish( + aio_pika.Message( + body=json.dumps(job).encode(), + delivery_mode=aio_pika.DeliveryMode.PERSISTENT, + content_type="application/json", + ), + routing_key=queue_name, + ) + await channel.close() + + +async def consume_jobs(handler) -> None: + while True: + try: + connection = await get_connection() + channel = await connection.channel() + await channel.set_qos(prefetch_count=PREFETCH_COUNT) + queue = await channel.declare_queue(config.RABBITMQ_QUEUE, durable=True) + + # Запускаем обработчик в фоне, чтобы не блокировать цикл + async def process_message(message: aio_pika.IncomingMessage): + try: + job = json.loads(message.body) + print(f"[broker] got job: {job.get('attachment_id')}", flush=True) + await handler(job) + await message.ack() + except Exception as e: + print(f"[broker] handler error: {e}", flush=True) + await message.reject(requeue=False) + + async def on_message(message: aio_pika.IncomingMessage): + # Запускаем в фоне, не ждем завершения, чтобы сразу взять следующее + asyncio.create_task(process_message(message)) + + await queue.consume(on_message) + print(f"[broker] listening for jobs (prefetch={PREFETCH_COUNT})...", flush=True) + await asyncio.Future() + except Exception as e: + print(f"[broker] connection error: {e}. Reconnecting in 3 seconds...", flush=True) + await asyncio.sleep(3) \ No newline at end of file diff --git a/app/cache.py b/app/cache.py new file mode 100644 index 0000000..86058f3 --- /dev/null +++ b/app/cache.py @@ -0,0 +1,60 @@ +import json +from typing import Optional + +import redis.asyncio as redis + +from app.config import config + +CACHE_TTL_SECONDS = 30 + + +class Cache: + def __init__(self, client: redis.Redis) -> None: + self._client = client + + async def get_json(self, key: str) -> Optional[dict]: + raw = await self._client.get(key) + if raw is None: + return None + try: + return json.loads(raw) + except json.JSONDecodeError: + return None + + async def set_json(self, key: str, value: dict, ttl: int = CACHE_TTL_SECONDS) -> None: + await self._client.set(key, json.dumps(value), ex=ttl) + + async def delete(self, key: str) -> None: + await self._client.delete(key) + + async def invalidate_chat(self, chat_id: str) -> None: + """Удалить все ключи, связанные с чатом (история).""" + pattern = f"messages:{chat_id}:*" + cursor = 0 + while True: + cursor, keys = await self._client.scan(cursor=cursor, match=pattern, count=100) + if keys: + await self._client.delete(*keys) + if cursor == 0: + break + + async def try_lock(self, key: str, ttl: int = 5) -> bool: + """Атомарно установить ключ. True — если установили мы.""" + result = await self._client.set(key, "1", nx=True, ex=ttl) + return bool(result) + + async def unlock(self, key: str) -> None: + await self._client.delete(key) + + async def close(self) -> None: + await self._client.aclose() + + +def make_cache() -> Cache: + client = redis.from_url( + config.CACHE_URL, + decode_responses=True, + socket_connect_timeout=10, + socket_timeout=10, + ) + return Cache(client) \ No newline at end of file diff --git a/app/config.py b/app/config.py new file mode 100644 index 0000000..ff52ad3 --- /dev/null +++ b/app/config.py @@ -0,0 +1,29 @@ +import os +import secrets + + +class Config: + DATABASE_URL: str = os.getenv( + "DATABASE_URL", + "postgresql://messenger:messenger@localhost:5432/messenger", + ) + SESSION_TTL_SECONDS: int = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + APP_HOST: str = os.getenv("APP_HOST", "0.0.0.0") + APP_PORT: int = int(os.getenv("APP_PORT", "8080")) + SESSION_STORE: str = os.getenv("SESSION_STORE", "postgres") + CACHE_URL: str = os.getenv("CACHE_URL", "redis://valkey:6379/0") + INSTANCE_ID: str = os.getenv("INSTANCE_ID") or secrets.token_hex(6) + + S3_ENDPOINT: str = os.getenv("S3_ENDPOINT", "minio:9000") + S3_PUBLIC_ENDPOINT: str = os.getenv("S3_PUBLIC_ENDPOINT", "localhost:9000") + S3_ACCESS_KEY: str = os.getenv("S3_ACCESS_KEY", "minioadmin") + S3_SECRET_KEY: str = os.getenv("S3_SECRET_KEY", "minioadmin") + S3_BUCKET: str = os.getenv("S3_BUCKET", "attachments") + S3_SECURE: bool = os.getenv("S3_SECURE", "false").lower() == "true" + + RABBITMQ_URL: str = os.getenv("RABBITMQ_URL", "amqp://messenger:messenger@rabbitmq:5672/") + RABBITMQ_QUEUE: str = os.getenv("RABBITMQ_QUEUE", "attachment.process.v1") + MAX_ATTEMPTS: int = int(os.getenv("MAX_ATTEMPTS", "5")) + + +config = Config() \ No newline at end of file diff --git a/app/db.py b/app/db.py new file mode 100644 index 0000000..f49a598 --- /dev/null +++ b/app/db.py @@ -0,0 +1,30 @@ +import asyncpg +from app.config import config + + +class Database: + def __init__(self) -> None: + self._pool: asyncpg.Pool | None = None + + async def connect(self) -> None: + self._pool = await asyncpg.create_pool( + config.DATABASE_URL, + min_size=2, + max_size=10, + command_timeout=5, + timeout=5, + ) + + async def close(self) -> None: + if self._pool is not None: + await self._pool.close() + self._pool = None + + @property + def pool(self) -> asyncpg.Pool: + if self._pool is None: + raise RuntimeError("database is not connected") + return self._pool + + +db = Database() \ No newline at end of file diff --git a/app/lease_checker.py b/app/lease_checker.py new file mode 100644 index 0000000..aefd7a9 --- /dev/null +++ b/app/lease_checker.py @@ -0,0 +1,37 @@ +import asyncio +import sys + +from app.cache import make_cache +from app.db import db +from app.storage import Storage + + +async def main(): + await db.connect() + cache = make_cache() + storage = Storage(db.pool, cache) + + print("[lease_checker] started", flush=True) + while True: + try: + expired_jobs = await storage.get_expired_jobs() + for job in expired_jobs: + print(f"[lease_checker] requeueing expired job {job['job_id']}", flush=True) + await storage.reset_job_status(str(job["job_id"])) + job_payload = { + "schema_version": 1, + "job_id": str(job["job_id"]), + "type": "attachment.process.v1", + "attachment_id": str(job["attachment_id"]), + "pipeline_version": job["pipeline_version"], + "attempt": job["attempt"], + "created_at": "2026-01-01T00:00:00Z", + } + await storage.create_outbox(job_payload) + except Exception as e: + print(f"[lease_checker] error: {e}", flush=True) + await asyncio.sleep(10) + + +if __name__ == "__main__": + sys.exit(asyncio.run(main())) \ No newline at end of file diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..41a1315 --- /dev/null +++ b/app/main.py @@ -0,0 +1,113 @@ +import uuid +from contextlib import asynccontextmanager + +from fastapi import FastAPI, Request, HTTPException +from fastapi.responses import JSONResponse +from fastapi.exceptions import RequestValidationError + +from app.db import db +from app.storage import Storage +from app.session_store import make_session_store +from app.cache import make_cache +from app.config import config +from app.s3 import s3 +from app.api import health, users, auth, chats, attachments + + +@asynccontextmanager +async def lifespan(app: FastAPI): + await db.connect() + app.state.cache = make_cache() + app.state.storage = Storage(db.pool, app.state.cache) + app.state.session_store = make_session_store(db.pool) + await app.state.session_store.delete_expired() + s3.ensure_bucket() + app.state.s3 = s3 + yield + await app.state.cache.close() + await app.state.session_store.close() + await db.close() + + +app = FastAPI(title="MTUSI Messenger", version="1.5.0", lifespan=lifespan) + + +@app.middleware("http") +async def request_context(request: Request, call_next): + rid = request.headers.get("X-Request-Id") or uuid.uuid4().hex + request.state.request_id = rid + response = await call_next(request) + response.headers["X-Request-Id"] = rid + response.headers["X-Instance-Id"] = config.INSTANCE_ID + return response + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + rid = getattr(request.state, "request_id", uuid.uuid4().hex) + return JSONResponse(status_code=400, + content={"error": {"code": "invalid_request", "message": "validation error", "request_id": rid}}, + headers={"X-Request-Id": rid}) + + +@app.exception_handler(HTTPException) +async def http_exception_handler(request: Request, exc: HTTPException): + rid = getattr(request.state, "request_id", uuid.uuid4().hex) + headers = {"X-Request-Id": rid} + if exc.headers: + headers.update(exc.headers) + code_map = {400:"invalid_request",401:"unauthorized",404:"not_found",409:"conflict", + 413:"payload_too_large",415:"unsupported_media_type",429:"rate_limited",503:"unavailable"} + code = code_map.get(exc.status_code, "internal_error") + message = exc.detail if isinstance(exc.detail, str) else "error" + return JSONResponse(status_code=exc.status_code, + content={"error": {"code": code, "message": message, "request_id": rid}}, + headers=headers) + + +try: + from asyncpg.exceptions import ( + PostgresConnectionError, TooManyConnectionsError, + CannotConnectNowError, ConnectionDoesNotExistError, + ) + + @app.exception_handler(PostgresConnectionError) + @app.exception_handler(TooManyConnectionsError) + @app.exception_handler(CannotConnectNowError) + @app.exception_handler(ConnectionDoesNotExistError) + async def postgres_unavailable_handler(request: Request, exc: Exception): + rid = getattr(request.state, "request_id", uuid.uuid4().hex) + return JSONResponse(status_code=503, + content={"error": {"code": "unavailable", "message": "database unavailable", "request_id": rid}}, + headers={"X-Request-Id": rid}) +except ImportError: + pass + + +try: + import redis.exceptions as redis_exceptions + + @app.exception_handler(redis_exceptions.ConnectionError) + @app.exception_handler(redis_exceptions.TimeoutError) + async def redis_unavailable_handler(request: Request, exc: Exception): + rid = getattr(request.state, "request_id", uuid.uuid4().hex) + return JSONResponse(status_code=503, + content={"error": {"code": "unavailable", "message": "cache unavailable", "request_id": rid}}, + headers={"X-Request-Id": rid}) +except ImportError: + pass + + +@app.exception_handler(Exception) +async def generic_exception_handler(request: Request, exc: Exception): + rid = getattr(request.state, "request_id", uuid.uuid4().hex) + return JSONResponse(status_code=500, + content={"error": {"code": "internal_error", "message": "internal error", "request_id": rid}}, + headers={"X-Request-Id": rid}) + + +app.include_router(health.router) +app.include_router(users.router, prefix="/api/v1") +app.include_router(auth.router, prefix="/api/v1") +app.include_router(chats.router, prefix="/api/v1") +app.include_router(attachments.router, prefix="/api/v1") \ No newline at end of file diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 0000000..d368468 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,19 @@ +import asyncio +import sys + +from app.db import db +from app.migrations import apply_migrations + + +async def main() -> int: + await db.connect() + try: + await apply_migrations(db.pool) + finally: + await db.close() + print("migrations applied", flush=True) + return 0 + + +if __name__ == "__main__": + sys.exit(asyncio.run(main())) \ No newline at end of file diff --git a/app/migrations.py b/app/migrations.py new file mode 100644 index 0000000..fea0eaf --- /dev/null +++ b/app/migrations.py @@ -0,0 +1,31 @@ +from pathlib import Path +import asyncpg + +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" + + +async def apply_migrations(pool: asyncpg.Pool) -> None: + async with pool.acquire() as conn: + await conn.execute( + """ + CREATE TABLE IF NOT EXISTS applied_migrations ( + name TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT now() + ) + """ + ) + applied = { + row["name"] + for row in await conn.fetch("SELECT name FROM applied_migrations") + } + for path in sorted(MIGRATIONS_DIR.glob("*.sql")): + if path.name in applied: + continue + sql = path.read_text(encoding="utf-8") + async with conn.transaction(): + await conn.execute(sql) + await conn.execute( + "INSERT INTO applied_migrations (name) VALUES ($1)", + path.name, + ) + print(f"applied migration: {path.name}", flush=True) \ No newline at end of file diff --git a/app/models.py b/app/models.py new file mode 100644 index 0000000..36f20f7 --- /dev/null +++ b/app/models.py @@ -0,0 +1,111 @@ +from pydantic import BaseModel, Field, ConfigDict, field_validator +from typing import List, Optional + + +def _not_blank(value: str) -> str: + if not value.strip(): + raise ValueError("must contain non-whitespace characters") + return value + + +def _not_blank_or_empty(value: str) -> str: + if value and not value.strip(): + raise ValueError("must contain non-whitespace characters") + return value + + +class User(BaseModel): + id: str + username: str + display_name: str + created_at: str + + +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + + username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(..., min_length=1, max_length=100) + password: str = Field(..., min_length=12, max_length=128) + + _check_display_name = field_validator("display_name")(_not_blank) + + +class Chat(BaseModel): + id: str + title: str + member_ids: List[str] + created_at: str + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field(..., min_length=1, max_length=100) + member_ids: List[str] = Field(..., min_length=1, max_length=100) + + _check_title = field_validator("title")(_not_blank) + + +class Message(BaseModel): + id: str + chat_id: str + sender_id: str + text: str + created_at: str + attachment_ids: List[str] + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + + text: str = Field("", max_length=4000) + attachment_ids: List[str] = Field(default_factory=list, max_length=10) + + _check_text = field_validator("text")(_not_blank_or_empty) + + +class Attachment(BaseModel): + id: str + chat_id: str + owner_id: str + filename: str + content_type: str + size_bytes: int + sha256: str + status: str + variants: List[dict] + error_code: Optional[str] + created_at: str + updated_at: str + + +class ChatPage(BaseModel): + items: List[Chat] + next_cursor: Optional[str] = None + + +class MessagePage(BaseModel): + items: List[Message] + next_cursor: Optional[str] = None + + +class Health(BaseModel): + status: str = "ok" + + +class Session(BaseModel): + token: str + token_type: str = "Bearer" + expires_at: str + user: User + + +class ErrorBody(BaseModel): + code: str + message: str + request_id: str + + +class ErrorResponse(BaseModel): + error: ErrorBody \ No newline at end of file diff --git a/app/outbox_relay.py b/app/outbox_relay.py new file mode 100644 index 0000000..97c7785 --- /dev/null +++ b/app/outbox_relay.py @@ -0,0 +1,31 @@ +import asyncio +import json +import sys + +from app.broker import publish_job +from app.cache import make_cache +from app.db import db +from app.storage import Storage + + +async def main(): + await db.connect() + cache = make_cache() + storage = Storage(db.pool, cache) + + print("[outbox] started", flush=True) + while True: + try: + jobs = await storage.get_unpublished_outbox() + for job in jobs: + payload = json.loads(job["payload"]) if isinstance(job["payload"], str) else job["payload"] + await publish_job(payload) + await storage.mark_outbox_published(str(job["id"])) + print(f"[outbox] published {job['job_id']}", flush=True) + except Exception as e: + print(f"[outbox] error: {e}", flush=True) + await asyncio.sleep(1) + + +if __name__ == "__main__": + sys.exit(asyncio.run(main())) \ No newline at end of file diff --git a/app/s3.py b/app/s3.py new file mode 100644 index 0000000..789cd88 --- /dev/null +++ b/app/s3.py @@ -0,0 +1,53 @@ +from datetime import timedelta +from io import BytesIO + +from minio import Minio + +from app.config import config + + +class S3Storage: + def __init__(self) -> None: + common = dict( + access_key=config.S3_ACCESS_KEY, + secret_key=config.S3_SECRET_KEY, + secure=config.S3_SECURE, + region="us-east-1", + ) + self._client = Minio(config.S3_ENDPOINT, **common) + self._presign_client = Minio(config.S3_PUBLIC_ENDPOINT, **common) + self._bucket = config.S3_BUCKET + + @property + def client(self) -> Minio: + return self._client + + @property + def bucket(self) -> str: + return self._bucket + + def ensure_bucket(self) -> None: + if not self._client.bucket_exists(self._bucket): + self._client.make_bucket(self._bucket) + + def put(self, key: str, data: bytes, content_type: str) -> None: + self._client.put_object( + self._bucket, key, BytesIO(data), len(data), content_type=content_type + ) + + def get(self, key: str): + return self._client.get_object(self._bucket, key) + + def stat(self, key: str): + return self._client.stat_object(self._bucket, key) + + def remove(self, key: str) -> None: + self._client.remove_object(self._bucket, key) + + def presigned_put(self, key: str, expires_seconds: int = 300) -> str: + return self._presign_client.presigned_put_object( + self._bucket, key, expires=timedelta(seconds=expires_seconds) + ) + + +s3 = S3Storage() \ No newline at end of file diff --git a/app/security.py b/app/security.py new file mode 100644 index 0000000..827ace2 --- /dev/null +++ b/app/security.py @@ -0,0 +1,83 @@ +import base64 +import secrets +from datetime import datetime, timedelta, timezone + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHash +from fastapi import Header, HTTPException, Request + +_hasher = PasswordHasher() + + +def hash_password(password: str) -> str: + return _hasher.hash(password) + + +def verify_password(password: str, password_hash: str) -> bool: + try: + _hasher.verify(password_hash, password) + return True + except (VerifyMismatchError, VerificationError, InvalidHash): + return False + + +def new_token() -> str: + return secrets.token_urlsafe(48) + + +def parse_basic(header: str | None) -> tuple[str, str]: + if not header or not header.lower().startswith("basic "): + raise HTTPException(status_code=401, detail="unauthorized") + encoded = header.split(" ", 1)[1].strip() + try: + decoded = base64.b64decode(encoded).decode("utf-8") + except Exception: + raise HTTPException(status_code=401, detail="unauthorized") + if ":" not in decoded: + raise HTTPException(status_code=401, detail="unauthorized") + username, password = decoded.split(":", 1) + return username, password + + +def parse_bearer(header: str | None) -> str: + if not header or not header.lower().startswith("bearer "): + raise HTTPException(status_code=401, detail="unauthorized") + return header.split(" ", 1)[1].strip() + + +async def get_current_user( + request: Request, + authorization: str | None = Header(default=None), +): + token = parse_bearer(authorization) + session_store = request.app.state.session_store + storage = request.app.state.storage + + try: + session = await session_store.get(token) + except Exception: + raise HTTPException(status_code=503, detail="unavailable") + + if session is None: + raise HTTPException(status_code=401, detail="unauthorized") + + expires_at = datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00")) + if expires_at <= datetime.now(timezone.utc): + try: + await session_store.delete(token) + except Exception: + pass + raise HTTPException(status_code=401, detail="unauthorized") + + try: + user = await storage.get_user(session["user_id"]) + except Exception: + raise HTTPException(status_code=503, detail="unavailable") + + if user is None: + raise HTTPException(status_code=401, detail="unauthorized") + return user, token + + +def session_expires_at(ttl_seconds: int) -> datetime: + return datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds) \ No newline at end of file diff --git a/app/session_store.py b/app/session_store.py new file mode 100644 index 0000000..6fa68cf --- /dev/null +++ b/app/session_store.py @@ -0,0 +1,108 @@ +import json +from datetime import datetime, timezone +from typing import Optional + +import asyncpg +import redis.asyncio as redis + +from app.config import config + + +def _now_iso(value: datetime) -> str: + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z") + + +class PostgresSessionStore: + def __init__(self, pool: asyncpg.Pool) -> None: + self._pool = pool + + async def create(self, token: str, user_id: str, expires_at: datetime) -> dict: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + """ + INSERT INTO sessions (token, user_id, expires_at) + VALUES ($1, $2, $3) + RETURNING token, user_id, created_at, expires_at + """, + token, user_id, expires_at, + ) + return { + "token": row["token"], + "user_id": str(row["user_id"]), + "created_at": _now_iso(row["created_at"]), + "expires_at": _now_iso(row["expires_at"]), + } + + async def get(self, token: str) -> Optional[dict]: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + """ + SELECT token, user_id, created_at, expires_at + FROM sessions WHERE token = $1 + """, + token, + ) + if row is None: + return None + return { + "token": row["token"], + "user_id": str(row["user_id"]), + "created_at": _now_iso(row["created_at"]), + "expires_at": _now_iso(row["expires_at"]), + } + + async def delete(self, token: str) -> None: + async with self._pool.acquire() as conn: + await conn.execute("DELETE FROM sessions WHERE token = $1", token) + + async def delete_expired(self) -> None: + async with self._pool.acquire() as conn: + await conn.execute("DELETE FROM sessions WHERE expires_at <= now()") + + async def close(self) -> None: + pass + +class RedisSessionStore: + def __init__(self, client: redis.Redis) -> None: + self._client = client + + async def create(self, token: str, user_id: str, expires_at: datetime) -> dict: + now = datetime.now(timezone.utc) + ttl = max(1, int((expires_at - now).total_seconds())) + payload = { + "token": token, + "user_id": user_id, + "created_at": _now_iso(now), + "expires_at": _now_iso(expires_at), + } + await self._client.set(f"session:{token}", json.dumps(payload), ex=ttl) + return payload + + async def get(self, token: str) -> Optional[dict]: + raw = await self._client.get(f"session:{token}") + if raw is None: + return None + return json.loads(raw) + + async def delete(self, token: str) -> None: + await self._client.delete(f"session:{token}") + + async def delete_expired(self) -> None: + pass + + async def close(self) -> None: + await self._client.aclose() + + +def make_session_store(pool: asyncpg.Pool) -> PostgresSessionStore | RedisSessionStore: + if config.SESSION_STORE == "redis": + client = redis.from_url( + config.CACHE_URL, + decode_responses=True, + socket_connect_timeout=10, + socket_timeout=10, + ) + return RedisSessionStore(client) + return PostgresSessionStore(pool) \ No newline at end of file diff --git a/app/storage.py b/app/storage.py new file mode 100644 index 0000000..87b70ac --- /dev/null +++ b/app/storage.py @@ -0,0 +1,511 @@ +import asyncio +import hashlib +import json +import uuid +from datetime import datetime, timezone, timedelta +from typing import Optional + +import asyncpg + +from app.cache import Cache + + +def _now_iso(value: datetime) -> str: + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z") + + +def _canonical_hash(payload: dict) -> str: + canonical = json.dumps(payload, sort_keys=True, separators=(",", ":")) + return hashlib.sha256(canonical.encode("utf-8")).hexdigest() + + +class Storage: + def __init__(self, pool: asyncpg.Pool, cache: Cache) -> None: + self._pool = pool + self._cache = cache + + async def create_user(self, username, display_name, password_hash) -> dict: + user_id = str(uuid.uuid4()) + try: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + """INSERT INTO users (id, username, display_name, password_hash) + VALUES ($1,$2,$3,$4) + RETURNING id, username, display_name, created_at""", + user_id, username, display_name, password_hash, + ) + except asyncpg.UniqueViolationError: + raise ValueError("conflict") + return self._user_row(row) + + async def get_user(self, user_id: str) -> Optional[dict]: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + "SELECT id, username, display_name, created_at FROM users WHERE id=$1", + user_id, + ) + return self._user_row(row) if row else None + + async def get_user_by_username(self, username: str) -> Optional[dict]: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + "SELECT id, username, display_name, password_hash, created_at FROM users WHERE username=$1", + username, + ) + return dict(row) if row else None + + async def create_chat(self, title, member_ids, creator_id) -> dict: + if creator_id not in member_ids: + raise ValueError("creator_not_member") + chat_id = str(uuid.uuid4()) + async with self._pool.acquire() as conn: + async with conn.transaction(): + existing = await conn.fetchval( + "SELECT count(*) FROM users WHERE id = ANY($1::uuid[])", member_ids, + ) + if existing != len(member_ids): + raise ValueError("invalid_member") + await conn.execute("INSERT INTO chats (id, title) VALUES ($1,$2)", chat_id, title) + await conn.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES ($1,$2)", + [(chat_id, uid) for uid in member_ids], + ) + created = await conn.fetchval("SELECT created_at FROM chats WHERE id=$1", chat_id) + return {"id": chat_id, "title": title, "member_ids": member_ids, + "created_at": _now_iso(created)} + + async def get_chat(self, chat_id: str, actor_id: str) -> Optional[dict]: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + "SELECT id, title, created_at FROM chats WHERE id=$1", chat_id, + ) + if row is None: + return None + members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", chat_id) + member_ids = [str(m["user_id"]) for m in members] + if actor_id not in member_ids: + return None + return {"id": str(row["id"]), "title": row["title"], + "member_ids": member_ids, "created_at": _now_iso(row["created_at"])} + + async def list_chats(self, actor_id, limit, cursor): + async with self._pool.acquire() as conn: + params = [actor_id] + where = "" + if cursor: + try: + cur_actor, cur_created, cur_id = cursor.split("|", 2) + except ValueError: + raise ValueError("bad_cursor") + if cur_actor != actor_id: + raise ValueError("bad_cursor") + where = "AND (c.created_at, c.id) > ($2,$3)" + params += [datetime.fromisoformat(cur_created.replace("Z", "+00:00")), cur_id] + rows = await conn.fetch( + f"""SELECT c.id, c.title, c.created_at + FROM chats c JOIN chat_members m ON m.chat_id=c.id + WHERE m.user_id=$1 {where} + ORDER BY c.created_at, c.id LIMIT ${len(params)+1}""", + *params, limit + 1, + ) + items = [] + for row in rows[:limit]: + members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", row["id"]) + items.append({"id": str(row["id"]), "title": row["title"], + "member_ids": [str(m["user_id"]) for m in members], + "created_at": _now_iso(row["created_at"])}) + next_cursor = None + if len(rows) > limit: + last = rows[limit - 1] + next_cursor = f"{actor_id}|{_now_iso(last['created_at'])}|{last['id']}" + return items, next_cursor + + async def is_chat_member(self, chat_id: str, user_id: str) -> bool: + async with self._pool.acquire() as conn: + return await conn.fetchval( + "SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2", + chat_id, user_id, + ) is not None + + async def create_pending_attachment(self, att_id, chat_id, owner_id, object_key, + filename, content_type, size_bytes, sha256): + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + """INSERT INTO attachments + (id, chat_id, owner_id, object_key, filename, content_type, + size_bytes, sha256, status) + VALUES ($1,$2,$3,$4,$5,$6,$7,$8,'queued') + RETURNING id, chat_id, owner_id, object_key, filename, + content_type, size_bytes, sha256, status, + variants, variant_keys, error_code, created_at, updated_at""", + att_id, chat_id, owner_id, object_key, + filename, content_type, size_bytes, sha256, + ) + return self._attachment_row(row, public=True) + + async def create_attachment_with_job_and_outbox( + self, att_id, chat_id, owner_id, object_key, filename, content_type, + size_bytes, sha256, job: dict, + ): + async with self._pool.acquire() as conn: + async with conn.transaction(): + row = await conn.fetchrow( + """INSERT INTO attachments + (id, chat_id, owner_id, object_key, filename, content_type, + size_bytes, sha256, status) + VALUES ($1,$2,$3,$4,$5,$6,$7,$8,'queued') + RETURNING id, chat_id, owner_id, object_key, filename, + content_type, size_bytes, sha256, status, + variants, variant_keys, error_code, created_at, updated_at""", + att_id, chat_id, owner_id, object_key, + filename, content_type, size_bytes, sha256, + ) + await conn.execute( + """INSERT INTO jobs (id, attachment_id, pipeline_version, attempt, status) + VALUES ($1,$2,$3,$4,'queued')""", + job["job_id"], job["attachment_id"], job["pipeline_version"], job["attempt"], + ) + await conn.execute( + "INSERT INTO outbox (id, job_id, payload) VALUES ($1, $2, $3)", + str(uuid.uuid4()), job["job_id"], json.dumps(job), + ) + return self._attachment_row(row, public=True) + + async def get_attachment(self, att_id: str) -> Optional[dict]: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + """SELECT id, chat_id, owner_id, object_key, filename, + content_type, size_bytes, sha256, status, + variants, variant_keys, error_code, created_at, updated_at + FROM attachments WHERE id=$1""", + att_id, + ) + if row is None: + return None + return self._attachment_row(row, public=False) + + async def update_attachment_status(self, att_id: str, status: str) -> None: + async with self._pool.acquire() as conn: + await conn.execute( + "UPDATE attachments SET status=$2, updated_at=now() WHERE id=$1", + att_id, status, + ) + + async def complete_attachment_ready(self, att_id, original_key, variants: list, variant_keys: dict): + async with self._pool.acquire() as conn: + await conn.execute( + """UPDATE attachments SET status='ready', object_key=$2, + variants=$3::jsonb, variant_keys=$4::jsonb, updated_at=now() WHERE id=$1""", + att_id, original_key, json.dumps(variants), json.dumps(variant_keys), + ) + + async def fail_attachment(self, att_id: str, error_code: str) -> None: + async with self._pool.acquire() as conn: + await conn.execute( + "UPDATE attachments SET status='failed', error_code=$2, updated_at=now() WHERE id=$1", + att_id, error_code, + ) + + async def replay_failed_attachment(self, att_id: str) -> str: + async with self._pool.acquire() as conn: + async with conn.transaction(): + row = await conn.fetchrow( + "SELECT id, status FROM attachments WHERE id=$1 FOR UPDATE", + att_id, + ) + if row is None: + return "not_found" + if row["status"] == "ready": + return "already_ready" + if row["status"] != "failed": + return "not_failed" + job_id = str(uuid.uuid4()) + job = { + "schema_version": 1, + "job_id": job_id, + "type": "attachment.process.v1", + "attachment_id": att_id, + "pipeline_version": 1, + "attempt": 1, + "created_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"), + } + await conn.execute( + "UPDATE attachments SET status='queued', error_code=NULL, updated_at=now() WHERE id=$1", + att_id, + ) + await conn.execute( + """INSERT INTO jobs (id, attachment_id, pipeline_version, attempt, status) + VALUES ($1,$2,$3,$4,'queued')""", + job_id, att_id, 1, 1, + ) + await conn.execute( + "INSERT INTO outbox (id, job_id, payload) VALUES ($1, $2, $3)", + str(uuid.uuid4()), job_id, json.dumps(job), + ) + return "queued" + + async def create_job(self, job: dict) -> None: + async with self._pool.acquire() as conn: + await conn.execute( + """INSERT INTO jobs (id, attachment_id, pipeline_version, attempt, status) + VALUES ($1,$2,$3,$4,'queued')""", + job["job_id"], job["attachment_id"], job["pipeline_version"], job["attempt"], + ) + + async def increment_job_attempt(self, job_id: str) -> int: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + "UPDATE jobs SET attempt=attempt+1, updated_at=now() WHERE id=$1 RETURNING attempt", + job_id, + ) + return int(row["attempt"]) if row is not None else 0 + + async def set_job_lease(self, job_id: str, seconds: int = 60) -> None: + async with self._pool.acquire() as conn: + await conn.execute( + "UPDATE jobs SET lease_until = now() + interval '1 second' * $2 WHERE id = $1", + job_id, seconds, + ) + + async def get_expired_jobs(self) -> list[dict]: + async with self._pool.acquire() as conn: + rows = await conn.fetch( + """SELECT j.id as job_id, j.attachment_id, j.pipeline_version, j.attempt, j.status, a.chat_id + FROM jobs j + JOIN attachments a ON a.id = j.attachment_id + WHERE j.status = 'processing' AND j.lease_until < now()""" + ) + return [dict(r) for r in rows] + + async def reset_job_status(self, job_id: str) -> None: + async with self._pool.acquire() as conn: + await conn.execute( + "UPDATE jobs SET status='queued', lease_until=NULL WHERE id=$1", + job_id, + ) + + async def create_outbox(self, job: dict) -> None: + async with self._pool.acquire() as conn: + await conn.execute( + """INSERT INTO outbox (id, job_id, payload) VALUES ($1, $2, $3)""", + str(uuid.uuid4()), job["job_id"], json.dumps(job), + ) + + async def get_unpublished_outbox(self, limit: int = 10) -> list[dict]: + async with self._pool.acquire() as conn: + rows = await conn.fetch( + "SELECT id, job_id, payload FROM outbox WHERE published_at IS NULL ORDER BY created_at LIMIT $1", + limit, + ) + return [dict(r) for r in rows] + + async def mark_outbox_published(self, outbox_id: str) -> None: + async with self._pool.acquire() as conn: + await conn.execute( + "UPDATE outbox SET published_at = now() WHERE id = $1", + outbox_id, + ) + + async def _list_attachment_ids_conn(self, conn, message_id: str) -> list[str]: + rows = await conn.fetch( + "SELECT attachment_id FROM message_attachments WHERE message_id=$1", message_id, + ) + return [str(r["attachment_id"]) for r in rows] + + async def add_message(self, chat_id, sender_id, text, attachment_ids=None, + idempotency_key=None): + attachment_ids = attachment_ids or [] + request_hash = _canonical_hash({"text": text, "attachment_ids": sorted(attachment_ids)}) + path = f"/api/v1/chats/{chat_id}/messages" + method = "POST" + + if idempotency_key is not None: + cached = await self._get_idempotent(sender_id, method, path, idempotency_key, request_hash) + if cached is not None: + return cached + + try: + async with self._pool.acquire() as conn: + async with conn.transaction(): + if attachment_ids: + valid = await conn.fetchval( + """SELECT count(*) FROM attachments + WHERE id = ANY($1::uuid[]) AND chat_id=$2""", + attachment_ids, chat_id, + ) + if valid != len(attachment_ids): + raise ValueError("not_found") + failed = await conn.fetchval( + """SELECT count(*) FROM attachments + WHERE id = ANY($1::uuid[]) AND chat_id=$2 AND status='failed'""", + attachment_ids, chat_id, + ) + if failed: + raise ValueError("attachment_failed") + + message_id = str(uuid.uuid4()) + row = await conn.fetchrow( + """INSERT INTO messages (id, chat_id, sender_id, text) + SELECT $1,$2,$3,$4 WHERE EXISTS ( + SELECT 1 FROM chat_members WHERE chat_id=$2 AND user_id=$3) + RETURNING id, chat_id, sender_id, text, created_at""", + message_id, chat_id, sender_id, text, + ) + if row is None: + raise ValueError("not_found") + if attachment_ids: + await conn.executemany( + "INSERT INTO message_attachments (message_id, attachment_id) VALUES ($1,$2)", + [(message_id, aid) for aid in attachment_ids], + ) + message = self._message_row(row, list(attachment_ids)) + await conn.execute("UPDATE chats SET version=version+1 WHERE id=$1", chat_id) + if idempotency_key is not None: + await conn.execute( + """INSERT INTO idempotency_keys + (user_id, method, path, key, request_hash, response_status, response_body) + VALUES ($1,$2,$3,$4,$5,$6,$7)""", + sender_id, method, path, idempotency_key, + request_hash, 201, json.dumps(message, ensure_ascii=False), + ) + except asyncpg.UniqueViolationError: + cached = await self._get_idempotent(sender_id, method, path, idempotency_key, request_hash) + if cached is not None: + return cached + raise + + await self._cache.invalidate_chat(chat_id) + return message + + async def _get_idempotent(self, user_id, method, path, key, request_hash): + if key is None: + return None + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + """SELECT request_hash, response_body FROM idempotency_keys + WHERE user_id=$1 AND method=$2 AND path=$3 AND key=$4""", + user_id, method, path, key, + ) + if row is None: + return None + if row["request_hash"] != request_hash: + raise ValueError("idempotency_conflict") + return json.loads(row["response_body"]) + + async def list_messages(self, chat_id, actor_id, limit, cursor): + async with self._pool.acquire() as conn: + is_member = await conn.fetchval( + "SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2", + chat_id, actor_id, + ) + if is_member is None: + raise ValueError("not_found") + + cache_key = f"messages:{chat_id}:{limit}:{cursor or ''}" + cached = await self._cache.get_json(cache_key) + if cached is not None: + version_now = await self._get_chat_version(chat_id) + if cached.get("version") == version_now: + return cached["items"], cached["next_cursor"] + await self._cache.delete(cache_key) + + lock_key = f"lock:{cache_key}" + got_lock = await self._cache.try_lock(lock_key, ttl=10) + if not got_lock: + for _ in range(50): + await asyncio.sleep(0.1) + cached = await self._cache.get_json(cache_key) + if cached is not None: + version_now = await self._get_chat_version(chat_id) + if cached.get("version") == version_now: + return cached["items"], cached["next_cursor"] + + try: + version_before = await self._get_chat_version(chat_id) + async with self._pool.acquire() as conn: + params = [chat_id] + where = "" + if cursor: + try: + cur_chat, cur_created, cur_id = cursor.split("|", 2) + except ValueError: + raise ValueError("bad_cursor") + if cur_chat != chat_id: + raise ValueError("bad_cursor") + where = "AND (created_at, id) > ($2,$3)" + params += [datetime.fromisoformat(cur_created.replace("Z", "+00:00")), cur_id] + rows = await conn.fetch( + f"""SELECT id, chat_id, sender_id, text, created_at + FROM messages WHERE chat_id=$1 {where} + ORDER BY created_at, id LIMIT ${len(params)+1}""", + *params, limit + 1, + ) + items = [] + for row in rows[:limit]: + att_ids = await self._list_attachment_ids_conn(conn, row["id"]) + items.append(self._message_row(row, att_ids)) + next_cursor = None + if len(rows) > limit: + last = rows[limit - 1] + next_cursor = f"{chat_id}|{_now_iso(last['created_at'])}|{last['id']}" + version_after = await self._get_chat_version(chat_id) + if got_lock and version_before == version_after: + await self._cache.set_json(cache_key, { + "items": items, "next_cursor": next_cursor, "version": version_after, + }) + return items, next_cursor + finally: + if got_lock: + await self._cache.unlock(lock_key) + + async def _get_chat_version(self, chat_id: str) -> int: + async with self._pool.acquire() as conn: + row = await conn.fetchval("SELECT version FROM chats WHERE id=$1", chat_id) + return int(row) if row is not None else 0 + + @staticmethod + def _user_row(row) -> dict: + return {"id": str(row["id"]), "username": row["username"], + "display_name": row["display_name"], "created_at": _now_iso(row["created_at"])} + + @staticmethod + def _message_row(row, attachment_ids=None) -> dict: + return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), "text": row["text"], + "created_at": _now_iso(row["created_at"]), + "attachment_ids": attachment_ids or []} + + @staticmethod + def _attachment_row(row, public: bool) -> dict: + variants_raw = row["variants"] + if isinstance(variants_raw, str): + try: + variants = json.loads(variants_raw) + except json.JSONDecodeError: + variants = [] + else: + variants = variants_raw or [] + + result = { + "id": str(row["id"]), "chat_id": str(row["chat_id"]), + "owner_id": str(row["owner_id"]), "filename": row["filename"], + "content_type": row["content_type"], "size_bytes": row["size_bytes"], + "sha256": row["sha256"], "status": row["status"], + "variants": variants, + "error_code": row["error_code"], + "created_at": _now_iso(row["created_at"]), + "updated_at": _now_iso(row["updated_at"]), + } + if not public: + result["_object_key"] = row["object_key"] + variant_keys_raw = row["variant_keys"] + if isinstance(variant_keys_raw, str): + try: + result["_variant_keys"] = json.loads(variant_keys_raw) + except json.JSONDecodeError: + result["_variant_keys"] = {} + else: + result["_variant_keys"] = variant_keys_raw or {} + return result \ No newline at end of file diff --git a/app/worker.py b/app/worker.py new file mode 100644 index 0000000..01542d7 --- /dev/null +++ b/app/worker.py @@ -0,0 +1,151 @@ +import asyncio +import hashlib +import io +import random +import sys +from concurrent.futures import ThreadPoolExecutor + +from PIL import Image, ImageOps, UnidentifiedImageError + +from app.broker import consume_jobs, publish_job +from app.cache import make_cache +from app.config import config +from app.db import db +from app.s3 import s3 +from app.storage import Storage + +THUMB_SIZE = 256 +CROP_SIZE = 128 +OPTIMIZED_SIZE = 1280 + +_executor = ThreadPoolExecutor(max_workers=10) + +PERMANENT_ERRORS = (UnidentifiedImageError,) +PERMANENT_OSERROR_MARKERS = ( + "cannot identify image", + "image file is truncated", + "broken data stream", +) + + +def is_permanent(exc: Exception) -> bool: + if isinstance(exc, PERMANENT_ERRORS): + return True + if isinstance(exc, OSError): + text = str(exc).lower() + if any(m in text for m in PERMANENT_OSERROR_MARKERS): + return True + return False + + +def process_images(data: bytes): + img = Image.open(io.BytesIO(data)) + img = ImageOps.exif_transpose(img) + + if img.mode in ("RGBA", "LA", "P"): + img = img.convert("RGB", background=(255, 255, 255)) + else: + img = img.convert("RGB") + + results = {} + + thumb = img.copy() + thumb.thumbnail((THUMB_SIZE, THUMB_SIZE), Image.LANCZOS) + buf = io.BytesIO() + thumb.save(buf, format="JPEG", quality=85) + results["thumbnail"] = (buf.getvalue(), thumb.size[0], thumb.size[1], "image/jpeg") + + crop = ImageOps.fit(img, (CROP_SIZE, CROP_SIZE), Image.LANCZOS, centering=(0.5, 0.5)) + buf = io.BytesIO() + crop.save(buf, format="JPEG", quality=85) + results["crop"] = (buf.getvalue(), crop.size[0], crop.size[1], "image/jpeg") + + opt = img.copy() + if opt.size[0] > OPTIMIZED_SIZE or opt.size[1] > OPTIMIZED_SIZE: + opt.thumbnail((OPTIMIZED_SIZE, OPTIMIZED_SIZE), Image.LANCZOS) + buf = io.BytesIO() + opt.save(buf, format="WEBP", quality=80) + results["optimized"] = (buf.getvalue(), opt.size[0], opt.size[1], "image/webp") + + return results + + +async def handle_job(job: dict, storage: Storage) -> None: + att_id = job.get("attachment_id") + attempt = job.get("attempt", 1) + job_id = job.get("job_id") + + att = await storage.get_attachment(att_id) + if att is None: + return + if att["status"] == "ready": + return + + await storage.update_attachment_status(att_id, "processing") + await storage.set_job_lease(job_id, 60) + + try: + staging_key = att["_object_key"] + original = s3.get(staging_key).read() + + final_key = f"originals/{att['chat_id']}/{att_id}" + s3.put(final_key, original, att["content_type"]) + + loop = asyncio.get_running_loop() + images = await loop.run_in_executor(_executor, process_images, original) + + variants = [] + variant_keys = {} + + for name, (data, w, h, ctype) in images.items(): + ext = "webp" if name == "optimized" else "jpg" + key = f"{name}s/{att['chat_id']}/{att_id}.{ext}" + s3.put(key, data, ctype) + variants.append({ + "name": name, + "content_type": ctype, + "size_bytes": len(data), + "width": w, + "height": h, + "sha256": hashlib.sha256(data).hexdigest() + }) + variant_keys[name] = key + + await storage.complete_attachment_ready(att_id, final_key, variants, variant_keys) + + try: + s3.remove(staging_key) + except Exception: + pass + + print(f"[worker] SUCCESS {att_id}", flush=True) + except Exception as e: + print(f"[worker] ERROR {att_id}: {type(e).__name__} - {e}", flush=True) + if is_permanent(e): + await storage.fail_attachment(att_id, "invalid_image") + await publish_job(job, is_dlq=True) + return + if attempt >= config.MAX_ATTEMPTS: + await storage.fail_attachment(att_id, "retry_exhausted") + await publish_job(job, is_dlq=True) + return + new_attempt = await storage.increment_job_attempt(job_id) + job["attempt"] = new_attempt + delay = (2 ** new_attempt) + random.uniform(0, 1) + print(f"[worker] retrying in {delay:.2f} seconds...", flush=True) + await asyncio.sleep(delay) + await publish_job(job) + + +async def main() -> int: + await db.connect() + cache = make_cache() + storage = Storage(db.pool, cache) + s3.ensure_bucket() + print(f"[worker] started, queue={config.RABBITMQ_QUEUE}", flush=True) + await consume_jobs(lambda job: handle_job(job, storage)) + return 0 + + +if __name__ == "__main__": + sys.exit(asyncio.run(main())) \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..dc81602 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,228 @@ +services: + postgres: + image: postgres:16.4-alpine + command: ["postgres", "-c", "shared_preload_libraries=pg_stat_statements"] + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD: messenger + POSTGRES_DB: messenger + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 20 + networks: [messenger] + deploy: + resources: + limits: {cpus: "1.0", memory: 512M} + + valkey: + image: valkey/valkey:8.0-alpine + command: ["valkey-server", "--appendonly", "yes", "--save", ""] + volumes: + - valkey_data:/data + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 5s + timeout: 3s + retries: 20 + networks: [messenger] + deploy: + resources: + limits: {cpus: "0.5", memory: 256M} + + minio: + image: bitnamilegacy/minio:2025.4.22-debian-12-r1 + user: "0:0" + command: server /data --console-address ":9001" + environment: + MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin} + MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin} + volumes: + - minio_data:/data + ports: + - "127.0.0.1:9000:9000" + healthcheck: + test: ["CMD", "mc", "ready", "local"] + interval: 5s + timeout: 3s + retries: 20 + networks: [messenger] + deploy: + resources: + limits: {cpus: "0.5", memory: 256M} + + minio-init: + image: bitnamilegacy/minio:2025.4.22-debian-12-r1 + user: "0:0" + depends_on: + minio: {condition: service_healthy} + entrypoint: > + /bin/sh -c " + mc alias set local http://minio:9000 $$MINIO_ROOT_USER $$MINIO_ROOT_PASSWORD && + mc mb --ignore-existing local/attachments && + mc anonymous set none local/attachments && + (mc admin user add local api-user api-user-secret-123 || true) && + (mc admin policy attach local readwrite --user api-user || true) && + echo 'bucket ready' + " + environment: + MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin} + MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin} + networks: [messenger] + + rabbitmq: + image: rabbitmq:3.13-management-alpine + environment: + RABBITMQ_DEFAULT_USER: messenger + RABBITMQ_DEFAULT_PASS: messenger + volumes: + - rabbitmq_data:/var/lib/rabbitmq + healthcheck: + test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"] + interval: 10s + timeout: 5s + retries: 10 + networks: [messenger] + deploy: + resources: + limits: {cpus: "0.5", memory: 256M} + + migrate: + build: {context: ., dockerfile: Dockerfile} + environment: + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + CACHE_URL: redis://valkey:6379/0 + SESSION_STORE: redis + command: ["python", "-m", "app.migrate"] + depends_on: + postgres: {condition: service_healthy} + valkey: {condition: service_healthy} + networks: [messenger] + deploy: + resources: + limits: {cpus: "0.5", memory: 256M} + + outbox: + build: {context: ., dockerfile: Dockerfile} + command: ["python", "-m", "app.outbox_relay"] + environment: + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + CACHE_URL: redis://valkey:6379/0 + SESSION_STORE: redis + RABBITMQ_URL: "amqp://messenger:messenger@rabbitmq:5672/" + RABBITMQ_QUEUE: "attachment.process.v1" + depends_on: + postgres: {condition: service_healthy} + valkey: {condition: service_healthy} + rabbitmq: {condition: service_healthy} + migrate: {condition: service_completed_successfully} + networks: [messenger] + deploy: + resources: + limits: {cpus: "0.2", memory: 128M} + + lease_checker: + build: {context: ., dockerfile: Dockerfile} + command: ["python", "-m", "app.lease_checker"] + environment: + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + CACHE_URL: redis://valkey:6379/0 + RABBITMQ_URL: "amqp://messenger:messenger@rabbitmq:5672/" + RABBITMQ_QUEUE: "attachment.process.v1" + depends_on: + postgres: {condition: service_healthy} + rabbitmq: {condition: service_healthy} + migrate: {condition: service_completed_successfully} + networks: [messenger] + deploy: + resources: + limits: {cpus: "0.2", memory: 128M} + + api: + build: {context: ., dockerfile: Dockerfile} + environment: + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + CACHE_URL: redis://valkey:6379/0 + SESSION_STORE: redis + SESSION_TTL_SECONDS: "3600" + APP_HOST: "0.0.0.0" + APP_PORT: "8080" + S3_ENDPOINT: "minio:9000" + S3_PUBLIC_ENDPOINT: "localhost:9000" + S3_ACCESS_KEY: "api-user" + S3_SECRET_KEY: "api-user-secret-123" + S3_BUCKET: "attachments" + S3_SECURE: "false" + RABBITMQ_URL: "amqp://messenger:messenger@rabbitmq:5672/" + RABBITMQ_QUEUE: "attachment.process.v1" + MAX_ATTEMPTS: "5" + depends_on: + postgres: {condition: service_healthy} + valkey: {condition: service_healthy} + migrate: {condition: service_completed_successfully} + minio-init: {condition: service_completed_successfully} + rabbitmq: {condition: service_healthy} + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2).status==200 else 1)"] + interval: 5s + timeout: 3s + retries: 3 + start_period: 10s + networks: [messenger] + deploy: + replicas: 2 + resources: + limits: {cpus: "0.5", memory: 256M} + + worker: + build: {context: ., dockerfile: Dockerfile} + command: ["python", "-m", "app.worker"] + environment: + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + CACHE_URL: redis://valkey:6379/0 + SESSION_STORE: redis + S3_ENDPOINT: "minio:9000" + S3_ACCESS_KEY: "api-user" + S3_SECRET_KEY: "api-user-secret-123" + S3_BUCKET: "attachments" + S3_SECURE: "false" + RABBITMQ_URL: "amqp://messenger:messenger@rabbitmq:5672/" + RABBITMQ_QUEUE: "attachment.process.v1" + MAX_ATTEMPTS: "5" + PREFETCH_COUNT: "${PREFETCH_COUNT:-1}" + depends_on: + postgres: {condition: service_healthy} + valkey: {condition: service_healthy} + migrate: {condition: service_completed_successfully} + minio-init: {condition: service_completed_successfully} + rabbitmq: {condition: service_healthy} + networks: [messenger] + deploy: + resources: + limits: {cpus: "1.0", memory: 512M} + + lb: + image: nginx:1.27-alpine + volumes: + - ./nginx.conf:/etc/nginx/nginx.conf:ro + ports: + - "127.0.0.1:8080:8080" + depends_on: + - api + networks: [messenger] + deploy: + resources: + limits: {cpus: "0.5", memory: 128M} + +volumes: + postgres_data: + valkey_data: + minio_data: + rabbitmq_data: + +networks: + messenger: + driver: bridge \ No newline at end of file diff --git a/evidence/demo-ids.txt b/evidence/demo-ids.txt new file mode 100644 index 0000000..4956042 --- /dev/null +++ b/evidence/demo-ids.txt @@ -0,0 +1,9 @@ +alice_id=6d5c6bbb-5a2b-4dab-8fc2-fa8b9e27b008 +bob_id=b3cfb9d5-4dfa-4292-8c7d-c26859ddbfd1 +chat_id=6ac76405-530d-4380-963a-a3f9e5e41038 +att_id=60a44fbb-ecd3-40ba-89c3-890d03d51ddb +message_id=1dfa07c6-ce12-446f-bd32-161b555eb4d1 +other_message_id=6da484cc-c0fb-403c-b144-29e64d1c95d1 +upload_status=202 +content_status=409 +final_status=ready diff --git a/evidence/evidence/README.md b/evidence/evidence/README.md new file mode 100644 index 0000000..8df7001 --- /dev/null +++ b/evidence/evidence/README.md @@ -0,0 +1,5 @@ +# Доказательства + +Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. + +Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. diff --git a/evidence/orig-demo.png b/evidence/orig-demo.png new file mode 100644 index 0000000000000000000000000000000000000000..e7c920789e90d16586ecff5029a87d1fc247b086 GIT binary patch literal 111817 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ðy=(TIZ6WiN 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 literal 0 HcmV?d00001 diff --git a/evidence/queue-prefetch1-large.json b/evidence/queue-prefetch1-large.json new file mode 100644 index 0000000..50be482 --- /dev/null +++ b/evidence/queue-prefetch1-large.json @@ -0,0 +1,20 @@ +{ + "prefetch": 1, + "size": "large", + "files_requested": 15, + "files_ok": 15, + "files_failed": 0, + "duration_s": 11.002, + "throughput_files_per_s": 1.363, + "queue_lag_s": { + "p50": 4.142, + "p95": 7.278, + "p99": 7.278 + }, + "time_to_ready_s": { + "p50": 4.542, + "p95": 7.93, + "p99": 7.93 + }, + "worker_rss_mib": 97.5 +} \ No newline at end of file diff --git a/evidence/queue-prefetch1-medium.json b/evidence/queue-prefetch1-medium.json new file mode 100644 index 0000000..5df9128 --- /dev/null +++ b/evidence/queue-prefetch1-medium.json @@ -0,0 +1,20 @@ +{ + "prefetch": 1, + "size": "medium", + "files_requested": 30, + "files_ok": 30, + "files_failed": 0, + "duration_s": 5.979, + "throughput_files_per_s": 5.018, + "queue_lag_s": { + "p50": 2.714, + "p95": 3.044, + "p99": 3.074 + }, + "time_to_ready_s": { + "p50": 2.751, + "p95": 3.083, + "p99": 3.263 + }, + "worker_rss_mib": 50.6 +} \ No newline at end of file diff --git a/evidence/queue-prefetch1-small.json b/evidence/queue-prefetch1-small.json new file mode 100644 index 0000000..8a54f35 --- /dev/null +++ b/evidence/queue-prefetch1-small.json @@ -0,0 +1,20 @@ +{ + "prefetch": 1, + "size": "small", + "files_requested": 50, + "files_ok": 50, + "files_failed": 0, + "duration_s": 8.998, + "throughput_files_per_s": 5.557, + "queue_lag_s": { + "p50": 3.264, + "p95": 5.788, + "p99": 5.819 + }, + "time_to_ready_s": { + "p50": 3.264, + "p95": 5.819, + "p99": 5.856 + }, + "worker_rss_mib": 37.9 +} \ No newline at end of file diff --git a/evidence/queue-prefetch20-large.json b/evidence/queue-prefetch20-large.json new file mode 100644 index 0000000..bfe2049 --- /dev/null +++ b/evidence/queue-prefetch20-large.json @@ -0,0 +1,20 @@ +{ + "prefetch": 20, + "size": "large", + "files_requested": 15, + "files_ok": 0, + "files_failed": 15, + "duration_s": 602.704, + "throughput_files_per_s": 0.0, + "queue_lag_s": { + "p50": 2.365, + "p95": 2.506, + "p99": 2.506 + }, + "time_to_ready_s": { + "p50": null, + "p95": null, + "p99": null + }, + "worker_rss_mib": 0.0 +} \ No newline at end of file diff --git a/evidence/queue-prefetch20-medium.json b/evidence/queue-prefetch20-medium.json new file mode 100644 index 0000000..257ea36 --- /dev/null +++ b/evidence/queue-prefetch20-medium.json @@ -0,0 +1,20 @@ +{ + "prefetch": 20, + "size": "medium", + "files_requested": 30, + "files_ok": 30, + "files_failed": 0, + "duration_s": 6.129, + "throughput_files_per_s": 4.894, + "queue_lag_s": { + "p50": 2.677, + "p95": 2.949, + "p99": 2.966 + }, + "time_to_ready_s": { + "p50": 2.738, + "p95": 3.431, + "p99": 3.435 + }, + "worker_rss_mib": 112.6 +} \ No newline at end of file diff --git a/evidence/queue-prefetch20-small.json b/evidence/queue-prefetch20-small.json new file mode 100644 index 0000000..5cdab35 --- /dev/null +++ b/evidence/queue-prefetch20-small.json @@ -0,0 +1,20 @@ +{ + "prefetch": 20, + "size": "small", + "files_requested": 50, + "files_ok": 50, + "files_failed": 0, + "duration_s": 8.563, + "throughput_files_per_s": 5.839, + "queue_lag_s": { + "p50": 3.35, + "p95": 5.352, + "p99": 5.383 + }, + "time_to_ready_s": { + "p50": 3.369, + "p95": 5.392, + "p99": 5.464 + }, + "worker_rss_mib": 42.5 +} \ No newline at end of file diff --git a/evidence/queue-prefetch5-large.json b/evidence/queue-prefetch5-large.json new file mode 100644 index 0000000..e84c9e3 --- /dev/null +++ b/evidence/queue-prefetch5-large.json @@ -0,0 +1,20 @@ +{ + "prefetch": 5, + "size": "large", + "files_requested": 15, + "files_ok": 15, + "files_failed": 0, + "duration_s": 18.041, + "throughput_files_per_s": 0.831, + "queue_lag_s": { + "p50": 5.991, + "p95": 11.221, + "p99": 11.221 + }, + "time_to_ready_s": { + "p50": 10.316, + "p95": 14.838, + "p99": 14.838 + }, + "worker_rss_mib": 511.7 +} \ No newline at end of file diff --git a/evidence/queue-prefetch5-medium.json b/evidence/queue-prefetch5-medium.json new file mode 100644 index 0000000..d5bb3e9 --- /dev/null +++ b/evidence/queue-prefetch5-medium.json @@ -0,0 +1,20 @@ +{ + "prefetch": 5, + "size": "medium", + "files_requested": 30, + "files_ok": 30, + "files_failed": 0, + "duration_s": 6.309, + "throughput_files_per_s": 4.755, + "queue_lag_s": { + "p50": 2.789, + "p95": 3.297, + "p99": 3.306 + }, + "time_to_ready_s": { + "p50": 2.789, + "p95": 3.524, + "p99": 3.533 + }, + "worker_rss_mib": 114.0 +} \ No newline at end of file diff --git a/evidence/queue-prefetch5-small.json b/evidence/queue-prefetch5-small.json new file mode 100644 index 0000000..024685c --- /dev/null +++ b/evidence/queue-prefetch5-small.json @@ -0,0 +1,20 @@ +{ + "prefetch": 5, + "size": "small", + "files_requested": 50, + "files_ok": 50, + "files_failed": 0, + "duration_s": 8.361, + "throughput_files_per_s": 5.98, + "queue_lag_s": { + "p50": 3.408, + "p95": 5.04, + "p99": 5.06 + }, + "time_to_ready_s": { + "p50": 3.408, + "p95": 5.213, + "p99": 5.237 + }, + "worker_rss_mib": 43.8 +} \ No newline at end of file diff --git a/evidence/queue-recovery.json b/evidence/queue-recovery.json new file mode 100644 index 0000000..742b06d --- /dev/null +++ b/evidence/queue-recovery.json @@ -0,0 +1,6 @@ +{ + "files": 100, + "finished": 100, + "pending_after_timeout": 0, + "recovery_time_s": 22.749 +} \ No newline at end of file diff --git a/evidence/replay.txt b/evidence/replay.txt new file mode 100644 index 0000000..f7b69f2 --- /dev/null +++ b/evidence/replay.txt @@ -0,0 +1,6 @@ +att_id=559d9cab-90a0-4baf-b36f-355ad93ffae2 +chat_id=ce16016a-c647-4d87-8697-1061f25ff47c +replay_ready_status=409 +status_after_simulated_failure=failed/simulated_failure +replay_status=202 +final_status=ready diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000000000000000000000000000000000000..6f19bcb406ba7f57e68674f48086cb88d815f037 GIT binary patch literal 174 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 X3Z)vp@dCPSVzCylizNXJeaF865{Ph3 literal 0 HcmV?d00001 diff --git a/evidence/worker-crash.txt b/evidence/worker-crash.txt new file mode 100644 index 0000000..56771c4 --- /dev/null +++ b/evidence/worker-crash.txt @@ -0,0 +1,11 @@ +============================= test session starts ============================= +platform win32 -- Python 3.13.15, pytest-8.3.5, pluggy-1.6.0 -- C:\Users\maris\PythonProjects\mtusi2026lab1-fork\venv\Scripts\python.exe +cachedir: .pytest_cache +rootdir: C:\Users\maris\PythonProjects\mtusi2026lab5 +plugins: anyio-4.15.1, asyncio-0.25.3 +asyncio: mode=Mode.STRICT, asyncio_default_fixture_loop_scope=None +collecting ... collected 1 item + +student-tests/test_worker_crash.py::test_worker_recovers_after_ack_lost PASSED [100%] + +============================== 1 passed in 6.54s ============================== diff --git a/migrations/001_users.sql b/migrations/001_users.sql new file mode 100644 index 0000000..4e60309 --- /dev/null +++ b/migrations/001_users.sql @@ -0,0 +1,7 @@ +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); \ No newline at end of file diff --git a/migrations/002_chats.sql b/migrations/002_chats.sql new file mode 100644 index 0000000..e46d22e --- /dev/null +++ b/migrations/002_chats.sql @@ -0,0 +1,5 @@ +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); \ No newline at end of file diff --git a/migrations/003_chat_members.sql b/migrations/003_chat_members.sql new file mode 100644 index 0000000..cbed26e --- /dev/null +++ b/migrations/003_chat_members.sql @@ -0,0 +1,5 @@ +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); \ No newline at end of file diff --git a/migrations/004_messages.sql b/migrations/004_messages.sql new file mode 100644 index 0000000..31b695d --- /dev/null +++ b/migrations/004_messages.sql @@ -0,0 +1,7 @@ +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); \ No newline at end of file diff --git a/migrations/005_sessions.sql b/migrations/005_sessions.sql new file mode 100644 index 0000000..ab1b4b1 --- /dev/null +++ b/migrations/005_sessions.sql @@ -0,0 +1,6 @@ +CREATE TABLE IF NOT EXISTS sessions ( + token TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + expires_at TIMESTAMPTZ NOT NULL +); \ No newline at end of file diff --git a/migrations/006_messages_index.sql b/migrations/006_messages_index.sql new file mode 100644 index 0000000..780d470 --- /dev/null +++ b/migrations/006_messages_index.sql @@ -0,0 +1,2 @@ +CREATE INDEX IF NOT EXISTS idx_messages_chat_created + ON messages(chat_id, created_at, id); \ No newline at end of file diff --git a/migrations/007_idempotency.sql b/migrations/007_idempotency.sql new file mode 100644 index 0000000..95e6cad --- /dev/null +++ b/migrations/007_idempotency.sql @@ -0,0 +1,11 @@ +CREATE TABLE IF NOT EXISTS idempotency_keys ( + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + method TEXT NOT NULL, + path TEXT NOT NULL, + key TEXT NOT NULL, + request_hash TEXT NOT NULL, + response_status INTEGER NOT NULL, + response_body TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, method, path, key) +); \ No newline at end of file diff --git a/migrations/008_idempotency_index.sql b/migrations/008_idempotency_index.sql new file mode 100644 index 0000000..bb80795 --- /dev/null +++ b/migrations/008_idempotency_index.sql @@ -0,0 +1,2 @@ +CREATE INDEX IF NOT EXISTS idx_idempotency_created + ON idempotency_keys(created_at); \ No newline at end of file diff --git a/migrations/009_chat_version.sql b/migrations/009_chat_version.sql new file mode 100644 index 0000000..d46308b --- /dev/null +++ b/migrations/009_chat_version.sql @@ -0,0 +1 @@ +ALTER TABLE chats ADD COLUMN IF NOT EXISTS version BIGINT NOT NULL DEFAULT 0; \ No newline at end of file diff --git a/migrations/010_attachments.sql b/migrations/010_attachments.sql new file mode 100644 index 0000000..b708137 --- /dev/null +++ b/migrations/010_attachments.sql @@ -0,0 +1,15 @@ +CREATE TABLE IF NOT EXISTS attachments ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + 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 BIGINT NOT NULL, + sha256 TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'ready', + error_code TEXT, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +CREATE INDEX IF NOT EXISTS idx_attachments_chat ON attachments(chat_id); \ No newline at end of file diff --git a/migrations/011_message_attachments.sql b/migrations/011_message_attachments.sql new file mode 100644 index 0000000..cbf805e --- /dev/null +++ b/migrations/011_message_attachments.sql @@ -0,0 +1,5 @@ +CREATE TABLE IF NOT EXISTS message_attachments ( + message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE, + attachment_id UUID NOT NULL REFERENCES attachments(id), + PRIMARY KEY (message_id, attachment_id) +); \ No newline at end of file diff --git a/migrations/012_attachment_status.sql b/migrations/012_attachment_status.sql new file mode 100644 index 0000000..ae8627d --- /dev/null +++ b/migrations/012_attachment_status.sql @@ -0,0 +1,4 @@ +ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_status_check; +ALTER TABLE attachments + ADD CONSTRAINT attachments_status_check + CHECK (status IN ('pending', 'ready')); \ No newline at end of file diff --git a/migrations/013_jobs.sql b/migrations/013_jobs.sql new file mode 100644 index 0000000..fbfca49 --- /dev/null +++ b/migrations/013_jobs.sql @@ -0,0 +1,17 @@ +ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_status_check; +ALTER TABLE attachments + ADD CONSTRAINT attachments_status_check + CHECK (status IN ('queued', 'processing', 'ready', 'failed')); + +CREATE TABLE IF NOT EXISTS jobs ( + id UUID PRIMARY KEY, + attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE, + pipeline_version INTEGER NOT NULL DEFAULT 1, + attempt INTEGER NOT NULL DEFAULT 1, + status TEXT NOT NULL DEFAULT 'queued', + error_code TEXT, + lease_until TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status); \ No newline at end of file diff --git a/migrations/014_attachment_variants.sql b/migrations/014_attachment_variants.sql new file mode 100644 index 0000000..6b26a96 --- /dev/null +++ b/migrations/014_attachment_variants.sql @@ -0,0 +1 @@ +ALTER TABLE attachments ADD COLUMN IF NOT EXISTS variants JSONB NOT NULL DEFAULT '[]'::jsonb; \ No newline at end of file diff --git a/migrations/015_variant_keys.sql b/migrations/015_variant_keys.sql new file mode 100644 index 0000000..f267a84 --- /dev/null +++ b/migrations/015_variant_keys.sql @@ -0,0 +1 @@ +ALTER TABLE attachments ADD COLUMN IF NOT EXISTS variant_keys JSONB NOT NULL DEFAULT '{}'::jsonb; \ No newline at end of file diff --git a/migrations/016_outbox.sql b/migrations/016_outbox.sql new file mode 100644 index 0000000..ebd5cc2 --- /dev/null +++ b/migrations/016_outbox.sql @@ -0,0 +1,8 @@ +CREATE TABLE IF NOT EXISTS outbox ( + id UUID PRIMARY KEY, + job_id UUID NOT NULL, + payload JSONB NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + published_at TIMESTAMPTZ +); +CREATE INDEX IF NOT EXISTS idx_outbox_unpublished ON outbox(published_at) WHERE published_at IS NULL; \ No newline at end of file diff --git a/migrations/017_lease_dlq.sql b/migrations/017_lease_dlq.sql new file mode 100644 index 0000000..db8c8e1 --- /dev/null +++ b/migrations/017_lease_dlq.sql @@ -0,0 +1,2 @@ +ALTER TABLE jobs ADD COLUMN IF NOT EXISTS lease_until TIMESTAMPTZ; +CREATE INDEX IF NOT EXISTS idx_jobs_lease ON jobs(lease_until); \ No newline at end of file diff --git a/nginx.conf b/nginx.conf new file mode 100644 index 0000000..2c6b48d --- /dev/null +++ b/nginx.conf @@ -0,0 +1,31 @@ +worker_processes auto; + +events { + worker_connections 1024; +} + +http { + upstream api_backend { + server api:8080 max_fails=1 fail_timeout=10s; + } + + server { + listen 8080; + server_name _; + + client_max_body_size 11m; + + location / { + proxy_pass http://api_backend; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_connect_timeout 1s; + proxy_send_timeout 60s; + proxy_read_timeout 60s; + proxy_next_upstream error timeout http_502 http_503 http_504; + } + } +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..cf72753 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,12 @@ +fastapi==0.115.12 +uvicorn==0.34.3 +pydantic==2.11.4 +httpx==0.28.1 +pytest==8.3.5 +pytest-asyncio==0.25.3 +asyncpg==0.30.0 +argon2-cffi==23.1.0 +redis==5.1.1 +minio==7.2.15 +Pillow==11.2.1 +aio-pika==9.5.4 \ No newline at end of file diff --git a/scripts/benchmark_queue.py b/scripts/benchmark_queue.py new file mode 100644 index 0000000..dee0c11 --- /dev/null +++ b/scripts/benchmark_queue.py @@ -0,0 +1,122 @@ +import base64 +import io +import os +import subprocess +import time +import uuid +import threading +import statistics + +import httpx +from PIL import Image + +BASE = "http://localhost:8080" +CONCURRENCY = 10 +TOTAL_FILES = 30 + + +def _png(size=(320, 200), color=(0, 255, 0)): + buf = io.BytesIO() + Image.new("RGB", size, color).save(buf, format="PNG") + return buf.getvalue() + + +def _user(c): + u = "bench_" + uuid.uuid4().hex[:8] + p = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={"username": u, "display_name": "B", "password": p}) + cred = base64.b64encode(f"{u}:{p}".encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}).json() + return {"id": s["user"]["id"], "token": s["token"]} + + +def _chat(c, a, b): + return c.post( + f"{BASE}/api/v1/chats", + json={"title": "bench", "member_ids": [a["id"], b["id"]]}, + headers={"Authorization": "Bearer " + a["token"]}, + ).json() + + +def _mem(container): + out = subprocess.run( + ["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", container], + capture_output=True, text=True, check=True, + ).stdout.strip() + v = out.split("/")[0].strip() + units = {"B": 1, "KiB": 1024, "Ki": 1024, "MiB": 1024 ** 2, "Mi": 1024 ** 2, "GiB": 1024 ** 3, "Gi": 1024 ** 3} + for u in sorted(units, key=len, reverse=True): + if v.endswith(u): + return int(float(v[: -len(u)]) * units[u]) + return 0 + + +def main(): + prefetch = os.getenv("PREFETCH_COUNT", "1") + data = _png() + with httpx.Client(timeout=30) as c: + a = _user(c) + b = _user(c) + chat = _chat(c, a, b) + + containers = subprocess.run( + ["docker", "ps", "--filter", "name=mtusi2026lab5-worker-", "--format", "{{.Names}}"], + capture_output=True, text=True, check=True, + ).stdout.split() + if not containers: + raise SystemExit("worker not found") + worker_container = containers[0] + + start_time = time.monotonic() + ids = [] + + def upload_one(): + with httpx.Client(timeout=30) as c: + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments", + params={"filename": "bench.png"}, + content=data, + headers={"Authorization": "Bearer " + a["token"], "Content-Type": "image/png"}, + ) + if r.status_code == 202: + return r.json()["id"] + return None + + threads = [] + for _ in range(TOTAL_FILES): + t = threading.Thread(target=lambda: ids.append(upload_one())) + t.start() + threads.append(t) + if len(threads) >= CONCURRENCY: + for t in threads: t.join() + threads = [] + + for t in threads: t.join() + upload_time = time.monotonic() - start_time + ids = [i for i in ids if i] + print(f"Uploaded {len(ids)} files in {upload_time:.2f}s. RPS (upload): {len(ids) / upload_time:.2f}") + + ready_times = [] + start_wait = time.monotonic() + for att_id in ids: + with httpx.Client(timeout=10) as c: + while True: + r = c.get(f"{BASE}/api/v1/attachments/{att_id}", headers={"Authorization": "Bearer " + a["token"]}) + if r.status_code == 200 and r.json()["status"] == "ready": + ready_times.append(time.monotonic() - start_wait) + break + time.sleep(0.1) + + total_time = time.monotonic() - start_time + p95 = statistics.quantiles(ready_times, n=20)[18] if len(ready_times) > 1 else 0 + ram = _mem(worker_container) + + print(f"--- RESULTS (prefetch={prefetch}) ---") + print(f"Total time: {total_time:.2f}s") + print(f"Throughput: {len(ids) / total_time:.2f} files/sec") + print(f"p95 time to ready: {p95:.2f}s") + print(f"Worker RAM: {ram / 1024 ** 2:.1f} MiB") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/replay.py b/scripts/replay.py new file mode 100644 index 0000000..75df69a --- /dev/null +++ b/scripts/replay.py @@ -0,0 +1,31 @@ +import argparse +import sys +import urllib.error +import urllib.request + + +def main() -> int: + parser = argparse.ArgumentParser(description="Replay a failed attachment") + parser.add_argument("attachment_id") + parser.add_argument("--base-url", default="http://localhost:8080") + parser.add_argument("--token", required=True) + args = parser.parse_args() + + req = urllib.request.Request( + f"{args.base_url}/api/v1/attachments/{args.attachment_id}/replay", + method="POST", + headers={"Authorization": "Bearer " + args.token}, + ) + try: + with urllib.request.urlopen(req, timeout=10) as resp: + print(f"status={resp.status}") + print(resp.read().decode()) + return 0 + except urllib.error.HTTPError as e: + print(f"status={e.code}") + print(e.read().decode()) + return 1 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/scripts/check-balance.py b/scripts/scripts/check-balance.py new file mode 100644 index 0000000..4092857 --- /dev/null +++ b/scripts/scripts/check-balance.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +import threading +import time +import uuid +from collections import Counter + +import httpx + +BASE = "http://localhost:8080" + + +def main(): + counter = Counter() + lock = threading.Lock() + + def worker(): + with httpx.Client(timeout=5) as c: + for _ in range(20): + try: + r = c.get(f"{BASE}/health/live") + if r.status_code == 200: + with lock: + counter[r.headers.get("x-instance-id")] += 1 + except Exception: + pass + time.sleep(0.05) + + threads = [threading.Thread(target=worker) for _ in range(20)] + for t in threads: + t.start() + for t in threads: + t.join() + + print(counter) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/scripts/check-chat-validation.py b/scripts/scripts/check-chat-validation.py new file mode 100644 index 0000000..a5459a1 --- /dev/null +++ b/scripts/scripts/check-chat-validation.py @@ -0,0 +1,45 @@ +import base64 +import uuid + +import httpx + +BASE = "http://localhost:8080" + + +def main(): + with httpx.Client(timeout=10) as c: + username = "cv_" + uuid.uuid4().hex[:8] + password = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={ + "username": username, "display_name": "C", "password": password, + }) + credential = base64.b64encode((username + ":" + password).encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}).json() + alice_id = s["user"]["id"] + alice_token = s["token"] + + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": "dup", "member_ids": [alice_id, alice_id]}, + headers={"Authorization": "Bearer " + alice_token}, + ) + print("duplicate members:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": "bad uuid", "member_ids": [alice_id, "not-a-uuid"]}, + headers={"Authorization": "Bearer " + alice_token}, + ) + print("invalid uuid:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": "ok", "member_ids": [alice_id]}, + headers={"Authorization": "Bearer " + alice_token}, + ) + print("valid chat:", r.status_code) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/scripts/check-models.py b/scripts/scripts/check-models.py new file mode 100644 index 0000000..e60836f --- /dev/null +++ b/scripts/scripts/check-models.py @@ -0,0 +1,63 @@ +import base64 +import uuid + +import httpx + +BASE = "http://localhost:8080" + + +def register_and_login(c): + username = "m_" + uuid.uuid4().hex[:8] + password = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={ + "username": username, "display_name": "T", "password": password, + }) + credential = base64.b64encode((username + ":" + password).encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}).json() + return s["user"]["id"], s["token"] + + +def main(): + with httpx.Client(timeout=10) as c: + alice_id, alice_token = register_and_login(c) + chat = c.post(f"{BASE}/api/v1/chats", + json={"title": "t", "member_ids": [alice_id]}, + headers={"Authorization": "Bearer " + alice_token}).json() + + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": " "}, + headers={ + "Authorization": "Bearer " + alice_token, + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + print("blank text:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": "hi", "sender_id": "extra"}, + headers={ + "Authorization": "Bearer " + alice_token, + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + print("extra sender_id:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/users", + json={"username": " ", "display_name": "X", "password": "Test-password-1234"}, + ) + print("blank username:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": " ", "member_ids": [alice_id]}, + headers={"Authorization": "Bearer " + alice_token}, + ) + print("blank chat title:", r.status_code, r.text[:200]) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/scripts/check_contract.py b/scripts/scripts/check_contract.py new file mode 100644 index 0000000..dcb34df --- /dev/null +++ b/scripts/scripts/check_contract.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +"""Offline structural checks; full schema validation is a separate target.""" +import ast +import json +from pathlib import Path +import re + +ROOT = Path(__file__).resolve().parents[1] + +def main(): + lab = json.loads((ROOT/'lab.json').read_text())['number'] + spec = json.loads((ROOT/'contracts/openapi.json').read_text()) + assert spec['openapi']=='3.1.0' + assert spec['info']['version']=='1.%d.0'%lab + operation_ids = set() + def walk(value): + if isinstance(value,dict): + if '$ref' in value: + pointer = value['$ref'] + assert pointer.startswith('#/'), 'unexpected external reference' + target = spec + for part in pointer[2:].split('/'): + target = target[part.replace('~1','/').replace('~0','~')] + for v in value.values(): + walk(v) + elif isinstance(value,list): + for v in value: + walk(v) + walk(spec) + for route,methods in spec['paths'].items(): + placeholders = set(re.findall(r'\{([^}]+)\}',route)) + for method,op in methods.items(): + assert op['operationId'] not in operation_ids, 'duplicate operationId' + operation_ids.add(op['operationId']) + params = {p['name'] for p in op.get('parameters',[]) if p['in']=='path' and p.get('required')} + assert placeholders==params, 'path parameter mismatch: '+route + for response in op['responses'].values(): + assert 'X-Request-Id' in response['headers'] + if lab>=3: + assert 'X-Instance-Id' in response['headers'] + assert ('/api/v1/auth/sessions' in spec['paths']) == (lab>=2) + assert ('/api/v1/attachments/{attachment_id}' in spec['paths']) == (lab>=4) + for file in list((ROOT/'tests').glob('*.py'))+list((ROOT/'scripts').glob('*.py')): + ast.parse(file.read_text(),filename=str(file)) + for file in ROOT.rglob('*.json'): + if any(part in {'.git','.venv','node_modules','vendor','output'} for part in file.parts): + continue + json.loads(file.read_text()) + for required in ('README.md','COURSE.md','CONTRIBUTING.md','REPORT.md','contracts/README.md','tests/smoke.py','tests/README.md'): + assert (ROOT/required).is_file(), 'missing '+required + print('PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.') + +if __name__=='__main__': + main() diff --git a/scripts/scripts/fair-scaling-benchmark.py b/scripts/scripts/fair-scaling-benchmark.py new file mode 100644 index 0000000..8576a61 --- /dev/null +++ b/scripts/scripts/fair-scaling-benchmark.py @@ -0,0 +1,230 @@ +#!/usr/bin/env python3 +import base64 +import json +import os +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +import httpx + +BASE = "http://localhost:8080" +ROOT = Path(__file__).resolve().parent.parent +EVIDENCE = ROOT / "evidence" / "fair_scaling.json" + + +def register_and_login(client): + username = "fair_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={"username": username, "display_name": "F", "password": password}, + ) + assert r.status_code == 201, r.text + user = r.json() + credential = base64.b64encode((username + ":" + password).encode()).decode() + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def run_load(chat_id, token, concurrency, duration): + latencies = [] + errors = 0 + lock = threading.Lock() + + def worker(): + nonlocal errors + local_lat = [] + local_err = 0 + with httpx.Client(timeout=15) as c: + deadline = time.monotonic() + duration + i = 0 + while time.monotonic() < deadline: + t0 = time.monotonic() + try: + if i % 10 == 0: + r = c.get( + f"{BASE}/api/v1/chats/{chat_id}/messages?limit=10", + headers={"Authorization": "Bearer " + token}, + ) + else: + r = c.post( + f"{BASE}/api/v1/chats/{chat_id}/messages", + json={"text": "fair-" + uuid.uuid4().hex[:6]}, + headers={ + "Authorization": "Bearer " + token, + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + if r.status_code not in (200, 201): + local_err += 1 + else: + local_lat.append(time.monotonic() - t0) + except Exception: + local_err += 1 + i += 1 + with lock: + latencies.extend(local_lat) + errors += local_err + + threads = [threading.Thread(target=worker) for _ in range(concurrency)] + started = time.monotonic() + for t in threads: + t.start() + for t in threads: + t.join() + elapsed = time.monotonic() - started + latencies.sort() + + def pct(p): + if not latencies: + return None + idx = max(0, int(len(latencies) * p) - 1) + return round(latencies[idx] * 1000, 2) + + return { + "concurrency": concurrency, + "duration_s": round(elapsed, 2), + "success": len(latencies), + "errors": errors, + "rps": round(len(latencies) / elapsed, 2) if elapsed else 0, + "p50_ms": pct(0.50), + "p95_ms": pct(0.95), + "p99_ms": pct(0.99), + } + + +def write_nginx(strategy): + if strategy == "least_conn": + upstream = """ upstream api_backend { + least_conn; + server api:8080 max_fails=1 fail_timeout=10s; + }""" + else: + upstream = """ upstream api_backend { + server api:8080 max_fails=1 fail_timeout=10s; + }""" + + content = f"""worker_processes auto; + +events {{ + worker_connections 1024; +}} + +http {{ +{upstream} + + server {{ + listen 8080; + server_name _; + + location / {{ + proxy_pass http://api_backend; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_connect_timeout 1s; + proxy_send_timeout 30s; + proxy_read_timeout 30s; + proxy_next_upstream error timeout http_502 http_503 http_504; + }} + }} +}} +""" + (ROOT / "nginx.conf").write_text(content, encoding="utf-8") + + +def switch_stack(replicas, cpus, memory): + env = dict(os.environ) + env["API_CPUS"] = cpus + env["API_MEMORY"] = memory + + subprocess.run( + ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", "-f", "compose-scale.yaml", "down"], + cwd=ROOT, check=True, env=env, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + ) + subprocess.run( + ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", "-f", "compose-scale.yaml", + "up", "-d", "--build", "--scale", f"api={replicas}"], + cwd=ROOT, check=True, env=env, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + ) + for _ in range(120): + try: + with httpx.Client(timeout=2) as c: + r = c.get(f"{BASE}/health/ready") + if r.status_code == 200: + time.sleep(8) + return + except Exception: + pass + time.sleep(1) + raise RuntimeError("API did not become ready") + + +def run_series(name, strategy, configs): + results = [] + write_nginx(strategy) + print(f"\n### Series {name} ({strategy})", flush=True) + for cfg in configs: + replicas = cfg["replicas"] + cpus = cfg["cpus"] + memory = cfg["memory"] + print(f"\n=== replicas={replicas}, cpus={cpus}, memory={memory} ===", flush=True) + switch_stack(replicas, cpus, memory) + + with httpx.Client(timeout=15) as c: + alice = register_and_login(c) + bob = register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "fair", "member_ids": [alice["id"], bob["id"]]}, + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + for run in range(3): + print(f" run {run+1}/3...", flush=True) + m = run_load(chat["id"], alice["token"], concurrency=20, duration=20) + m["replicas"] = replicas + m["cpus_per_replica"] = cpus + m["memory_per_replica"] = memory + m["run"] = run + 1 + m["series"] = name + m["strategy"] = strategy + results.append(m) + print(f" RPS={m['rps']}, p95={m['p95_ms']}, errors={m['errors']}", flush=True) + return results + + +def main(): + all_results = [] + configs = [ + {"replicas": 1, "cpus": "2.0", "memory": "512M"}, + {"replicas": 2, "cpus": "1.0", "memory": "256M"}, + {"replicas": 4, "cpus": "0.5", "memory": "128M"}, + ] + + all_results.extend(run_series("A_least_conn", "least_conn", configs)) + all_results.extend(run_series("B_round_robin", "round_robin", configs)) + + EVIDENCE.parent.mkdir(parents=True, exist_ok=True) + EVIDENCE.write_text( + json.dumps(all_results, indent=2, ensure_ascii=False), + encoding="utf-8", + ) + print(f"\nSaved {len(all_results)} records to {EVIDENCE}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/scripts/measure-detection.py b/scripts/scripts/measure-detection.py new file mode 100644 index 0000000..b660008 --- /dev/null +++ b/scripts/scripts/measure-detection.py @@ -0,0 +1,201 @@ +#!/usr/bin/env python3 +import base64 +import json +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +import httpx + +BASE = "http://localhost:8080" +ROOT = Path(__file__).resolve().parent.parent +EVIDENCE = ROOT / "evidence" / "detection.json" + +STOP_LABEL = "mtusi2026lab3-api-" + + +def register_and_login(client: httpx.Client) -> dict: + username = "det_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={"username": username, "display_name": "D", "password": password}, + ) + assert r.status_code == 201, r.text + user = r.json() + credential = base64.b64encode( + (username + ":" + password).encode("utf-8") + ).decode("ascii") + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def find_container_by_instance(target: str) -> str: + names = subprocess.run( + ["docker", "ps", "--filter", f"name={STOP_LABEL}", "--format", "{{.Names}}"], + capture_output=True, text=True, check=True, + ).stdout.split() + for name in names: + result = subprocess.run( + ["docker", "logs", name], + capture_output=True, text=True, check=False, + ) + combined = result.stdout + result.stderr + if f"INSTANCE_ID={target}" in combined: + return name + raise RuntimeError(f"no container with INSTANCE_ID={target}") + + +def get_instances(n: int = 30) -> set: + seen = set() + with httpx.Client(timeout=2) as c: + for _ in range(n): + try: + r = c.get(f"{BASE}/health/live") + if r.status_code == 200: + seen.add(r.headers.get("x-instance-id")) + except Exception: + pass + return seen + + +def main(): + print("[measure] preparing user and chat", flush=True) + with httpx.Client(timeout=5) as c: + alice = register_and_login(c) + bob = register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "det", "member_ids": [alice["id"], bob["id"]]}, + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + instances_before = get_instances() + if len(instances_before) < 2: + print(f"[measure] need >=2 replicas, got {instances_before}", file=sys.stderr) + return 1 + print(f"[measure] instances before: {instances_before}", flush=True) + + target = sorted(instances_before)[0] + container = find_container_by_instance(target) + print(f"[measure] will stop {container} (instance={target})", flush=True) + + shared = { + "latencies": [], + "errors": 0, + "instances": [], + "stop_time": None, + "first_success_after_stop": None, + "first_success_instance": None, + "stop_seen": False, + } + lock = threading.Lock() + running = {"flag": True} + + def worker(): + with httpx.Client(timeout=3) as c: + while running["flag"]: + t0 = time.monotonic() + try: + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": "det-" + uuid.uuid4().hex[:8]}, + headers={ + "Authorization": "Bearer " + alice["token"], + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + dt = time.monotonic() - t0 + if r.status_code == 201: + inst = r.headers.get("x-instance-id") + with lock: + shared["latencies"].append(dt) + shared["instances"].append(inst) + if shared["stop_time"] is not None and not shared["stop_seen"]: + if inst != target: + shared["first_success_after_stop"] = time.monotonic() - shared["stop_time"] + shared["first_success_instance"] = inst + shared["stop_seen"] = True + else: + with lock: + shared["errors"] += 1 + except Exception: + with lock: + shared["errors"] += 1 + + print("[measure] starting background load", flush=True) + threads = [threading.Thread(target=worker) for _ in range(4)] + for t in threads: + t.start() + + time.sleep(3) + with lock: + baseline_count = len(shared["latencies"]) + baseline_rps = baseline_count / 3.0 + print(f"[measure] baseline RPS ~{baseline_rps:.1f}", flush=True) + + print(f"[measure] stopping {container}", flush=True) + with lock: + shared["stop_time"] = time.monotonic() + subprocess.run(["docker", "stop", "--time=2", container], check=True) + + deadline = time.monotonic() + 20 + while time.monotonic() < deadline: + with lock: + if shared["first_success_after_stop"] is not None: + break + time.sleep(0.05) + + time.sleep(2) + + running["flag"] = False + for t in threads: + t.join(timeout=5) + + with lock: + report = { + "target_instance": target, + "target_container": container, + "instances_before": list(instances_before), + "total_successful": len(shared["latencies"]), + "total_errors": shared["errors"], + "baseline_rps_3s": round(baseline_rps, 2), + "detection_seconds": ( + round(shared["first_success_after_stop"], 3) + if shared["first_success_after_stop"] else None + ), + "first_success_instance_after_stop": shared["first_success_instance"], + } + print(json.dumps(report, ensure_ascii=False, indent=2)) + + EVIDENCE.parent.mkdir(parents=True, exist_ok=True) + existing = [] + if EVIDENCE.exists(): + try: + existing = json.loads(EVIDENCE.read_text(encoding="utf-8")) + except json.JSONDecodeError: + existing = [] + existing.append(report) + EVIDENCE.write_text( + json.dumps(existing, indent=2, ensure_ascii=False), + encoding="utf-8", + ) + + print(f"[measure] restoring {container}", flush=True) + subprocess.run( + ["docker", "compose", "--env-file", ".env", "up", "-d", "--scale", "api=2"], + cwd=ROOT, check=True, + ) + time.sleep(5) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/scripts/plot-scaling.py b/scripts/scripts/plot-scaling.py new file mode 100644 index 0000000..6fbd70b --- /dev/null +++ b/scripts/scripts/plot-scaling.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +from pathlib import Path + +import plotly.graph_objects as go + +ROOT = Path(__file__).resolve().parent.parent +EVIDENCE = ROOT / "evidence" + + +def make_rps_chart(): + fig = go.Figure() + fig.add_trace(go.Scatter( + x=[1, 2, 4], y=[135, 58, 35], + mode="lines+markers+text", + text=["135", "58", "35"], + textposition="top center", + line=dict(width=3, color="#d62728"), + marker=dict(size=14, color="#d62728"), + name="Before (least_conn, 30 clients)", + )) + fig.add_trace(go.Scatter( + x=[1, 2], y=[137, 174], + mode="lines+markers+text", + text=["137", "174"], + textposition="top center", + line=dict(width=3, color="#2ca02c"), + marker=dict(size=14, color="#2ca02c"), + name="After (round-robin, 20 clients)", + )) + fig.update_layout( + title="RPS vs API replicas", + xaxis=dict(title="Number of API replicas", tickmode="array", tickvals=[1, 2, 4]), + yaxis_title="RPS (median of 3 runs)", + template="plotly_white", + ) + fig.write_image(str(EVIDENCE / "scaling-rps.png")) + + +def make_p95_chart(): + fig = go.Figure() + fig.add_trace(go.Scatter( + x=[1, 2, 4], y=[260, 165, 421], + mode="lines+markers+text", + text=["260", "165", "421"], + textposition="top center", + line=dict(width=3, color="#d62728"), + marker=dict(size=14, color="#d62728"), + name="Before (least_conn, 30 clients)", + )) + fig.add_trace(go.Scatter( + x=[1, 2], y=[124, 180], + mode="lines+markers+text", + text=["124", "180"], + textposition="top center", + line=dict(width=3, color="#2ca02c"), + marker=dict(size=14, color="#2ca02c"), + name="After (round-robin, 20 clients)", + )) + fig.update_layout( + title="p95 latency vs API replicas", + xaxis=dict(title="Number of API replicas", tickmode="array", tickvals=[1, 2, 4]), + yaxis_title="p95 latency (ms, median of 3 runs)", + template="plotly_white", + ) + fig.write_image(str(EVIDENCE / "scaling-p95.png")) + + +def main(): + make_rps_chart() + make_p95_chart() + print(f"Saved charts to {EVIDENCE}") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/scripts/presign_compare.py b/scripts/scripts/presign_compare.py new file mode 100644 index 0000000..5ae7ec9 --- /dev/null +++ b/scripts/scripts/presign_compare.py @@ -0,0 +1,144 @@ +#!/usr/bin/env python3 +"""Compare proxy vs presigned upload: API RAM peak and bytes through API.""" +import base64 +import io +import subprocess +import threading +import time +import uuid + +import httpx +from PIL import Image + +BASE = "http://localhost:8080" +SIZES = [1 * 1024 * 1024, 9 * 1024 * 1024] + + +def _png(size_bytes): + img = Image.new("RGB", (1000, 1000), (0, 0, 255)) + buf = io.BytesIO() + img.save(buf, format="PNG") + data = buf.getvalue() + if len(data) < size_bytes: + data = data + b"\x00" * (size_bytes - len(data)) + return data[:size_bytes] + + +def _user(c): + u = "cmp_" + uuid.uuid4().hex[:8] + p = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={"username": u, "display_name": "C", "password": p}) + cred = base64.b64encode(f"{u}:{p}".encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}).json() + return {"id": s["user"]["id"], "token": s["token"]} + + +def _chat(c, a, b): + return c.post( + f"{BASE}/api/v1/chats", + json={"title": "cmp", "member_ids": [a["id"], b["id"]]}, + headers={"Authorization": "Bearer " + a["token"]}, + ).json() + + +def _mem(container): + out = subprocess.run( + ["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", container], + capture_output=True, text=True, check=True, + ).stdout.strip() + v = out.split("/")[0].strip() + units = { + "B": 1, + "KiB": 1024, "Ki": 1024, + "MiB": 1024**2, "Mi": 1024**2, + "GiB": 1024**3, "Gi": 1024**3, + } + for u in sorted(units, key=len, reverse=True): + if v.endswith(u): + return int(float(v[: -len(u)]) * units[u]) + return 0 + + +def _measure(container, fn): + baseline = _mem(container) + peak = baseline + stop = {"flag": False} + + def sampler(): + nonlocal peak + while not stop["flag"]: + try: + m = _mem(container) + if m > peak: + peak = m + except Exception: + pass + time.sleep(0.15) + + t = threading.Thread(target=sampler) + t.start() + started = time.monotonic() + fn() + elapsed = time.monotonic() - started + stop["flag"] = True + t.join(timeout=5) + return baseline, peak, elapsed + + +def main(): + containers = subprocess.run( + ["docker", "ps", "--filter", "name=mtusi2026lab4-api-", "--format", "{{.Names}}"], + capture_output=True, text=True, check=True, + ).stdout.split() + if not containers: + raise SystemExit("no api containers found") + target = containers[0] + + with httpx.Client(timeout=60) as c: + a = _user(c) + b = _user(c) + chat = _chat(c, a, b) + + for size in SIZES: + data = _png(size) + + def proxy_upload(): + with httpx.Client(timeout=60) as c: + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments", + params={"filename": "x.png"}, + content=data, + headers={"Authorization": "Bearer " + a["token"], "Content-Type": "image/png"}, + ) + assert r.status_code == 201, r.text + + def presigned_upload(): + with httpx.Client(timeout=60) as c: + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments/presign", + params={"filename": "x.png", "size": len(data), "content_type": "image/png"}, + headers={"Authorization": "Bearer " + a["token"]}, + ) + assert r.status_code == 201, r.text + p = r.json() + put = httpx.put(p["upload_url"], content=data, headers={"Content-Type": "image/png"}, timeout=60) + assert put.status_code == 200, put.text + r = c.post( + f"{BASE}/api/v1/attachments/{p['attachment_id']}/complete", + headers={"Authorization": "Bearer " + a["token"]}, + ) + assert r.status_code == 201, r.text + + for label, fn in (("proxy", proxy_upload), ("presigned", presigned_upload)): + baseline, peak, elapsed = _measure(target, fn) + print( + f"size={size} mode={label} " + f"elapsed={elapsed:.2f}s " + f"api_ram_baseline={baseline/1024**2:.1f}MiB " + f"api_ram_peak={peak/1024**2:.1f}MiB " + f"delta={(peak-baseline)/1024**2:.1f}MiB" + ) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/scripts/ram_experiment.py b/scripts/scripts/ram_experiment.py new file mode 100644 index 0000000..8cc2ca3 --- /dev/null +++ b/scripts/scripts/ram_experiment.py @@ -0,0 +1,137 @@ +#!/usr/bin/env python3 +"""Measure API RAM peak under >=10 concurrent uploads via docker stats.""" +import base64 +import io +import subprocess +import threading +import time +import uuid + +import httpx +from PIL import Image + +BASE = "http://localhost:8080" +CONCURRENCY = 10 +UPLOAD_BYTES = 9 * 1024 * 1024 + + +def _png(size_bytes: int) -> bytes: + img = Image.new("RGB", (1000, 1000), (255, 0, 0)) + buf = io.BytesIO() + img.save(buf, format="PNG") + data = buf.getvalue() + if len(data) < size_bytes: + data = data + b"\x00" * (size_bytes - len(data)) + return data[:size_bytes] + + +def _register_and_login(c): + u = "ram_" + uuid.uuid4().hex[:8] + p = "Test-password-1234" + r = c.post(f"{BASE}/api/v1/users", json={"username": u, "display_name": "R", "password": p}) + assert r.status_code == 201, r.text + user = r.json() + cred = base64.b64encode(f"{u}:{p}".encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}).json() + return {"id": user["id"], "token": s["token"]} + + +def _stats_mem(container: str) -> int: + out = subprocess.run( + ["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", container], + capture_output=True, text=True, check=True, + ).stdout.strip() + value = out.split("/")[0].strip() + units = { + "B": 1, + "KiB": 1024, "Ki": 1024, + "MiB": 1024**2, "Mi": 1024**2, + "GiB": 1024**3, "Gi": 1024**3, + } + for u in sorted(units, key=len, reverse=True): + if value.endswith(u): + return int(float(value[: -len(u)]) * units[u]) + raise ValueError(f"unexpected docker stats format: {out!r}") + + +def main(): + data = _png(UPLOAD_BYTES) + with httpx.Client(timeout=30) as c: + alice = _register_and_login(c) + bob = _register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "ram", "member_ids": [alice["id"], bob["id"]]}, + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + containers = subprocess.run( + ["docker", "ps", "--filter", "name=mtusi2026lab4-api-", "--format", "{{.Names}}"], + capture_output=True, text=True, check=True, + ).stdout.split() + if not containers: + raise SystemExit("no api containers found") + target = containers[0] + baseline = _stats_mem(target) + + errors = [] + lock = threading.Lock() + + def worker(): + try: + with httpx.Client(timeout=60) as c: + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments", + params={"filename": "ram.png"}, + content=data, + headers={ + "Authorization": "Bearer " + alice["token"], + "Content-Type": "image/png", + }, + ) + if r.status_code != 201: + with lock: + errors.append((r.status_code, r.text[:200])) + except Exception as e: + with lock: + errors.append((0, str(e))) + + threads = [threading.Thread(target=worker) for _ in range(CONCURRENCY)] + peak = baseline + stop = {"flag": False} + + def sampler(): + nonlocal peak + while not stop["flag"]: + try: + m = _stats_mem(target) + if m > peak: + peak = m + except Exception: + pass + time.sleep(0.2) + + sampler_thread = threading.Thread(target=sampler) + sampler_thread.start() + started = time.monotonic() + for t in threads: + t.start() + for t in threads: + t.join() + elapsed = time.monotonic() - started + stop["flag"] = True + sampler_thread.join(timeout=5) + + print(f"container: {target}") + print(f"uploads: {CONCURRENCY} x {UPLOAD_BYTES} bytes") + print(f"elapsed: {elapsed:.2f}s") + print(f"errors: {len(errors)}") + for e in errors: + print(" error:", e) + print(f"baseline RAM: {baseline / 1024**2:.1f} MiB") + print(f"peak RAM: {peak / 1024**2:.1f} MiB") + print(f"delta: {(peak - baseline) / 1024**2:.1f} MiB") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/scripts/reconcile.py b/scripts/scripts/reconcile.py new file mode 100644 index 0000000..2e4eca3 --- /dev/null +++ b/scripts/scripts/reconcile.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +"""Find and clean orphan S3 objects older than GRACE; log metadata without object. + +Usage (inside api container): + docker compose exec -T api-1 python /tmp/reconcile.py --dry-run + docker compose exec -T api-1 python /tmp/reconcile.py +""" +import argparse +import asyncio +import os +from datetime import datetime, timedelta, timezone + +import asyncpg +from minio import Minio + +GRACE_HOURS = 1 +BUCKET = os.getenv("S3_BUCKET", "attachments") +DB_URL = os.getenv( + "DATABASE_URL", + "postgresql://messenger:messenger@postgres:5432/messenger", +) +S3 = Minio( + os.getenv("S3_ENDPOINT", "minio:9000"), + access_key=os.getenv("S3_ACCESS_KEY", "api-user"), + secret_key=os.getenv("S3_SECRET_KEY", "api-user-secret-123"), + secure=False, +) + + +async def main(dry_run: bool) -> int: + pool = await asyncpg.create_pool(DB_URL) + try: + async with pool.acquire() as conn: + rows = await conn.fetch("SELECT object_key FROM attachments") + known = {r["object_key"] for r in rows} + + cutoff = datetime.now(timezone.utc) - timedelta(hours=GRACE_HOURS) + removed = 0 + skipped_fresh = 0 + for obj in S3.list_objects(BUCKET, recursive=True): + if obj.object_name in known: + continue + if obj.last_modified and obj.last_modified > cutoff: + skipped_fresh += 1 + continue + print(f"orphan: {obj.object_name}") + if not dry_run: + S3.remove_object(BUCKET, obj.object_name) + removed += 1 + + missing = 0 + async with pool.acquire() as conn: + rows = await conn.fetch("SELECT id, object_key FROM attachments") + for r in rows: + try: + S3.stat_object(BUCKET, r["object_key"]) + except Exception: + missing += 1 + print(f"missing object for attachment {r['id']}: {r['object_key']}") + + mode = "dry-run" if dry_run else "apply" + print( + f"reconcile ({mode}): orphans_found={removed} " + f"fresh_skipped={skipped_fresh} metadata_without_object={missing}" + ) + return 0 + finally: + await pool.close() + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--dry-run", action="store_true") + args = parser.parse_args() + raise SystemExit(asyncio.run(main(args.dry_run))) \ No newline at end of file diff --git a/scripts/scripts/restart.cmd b/scripts/scripts/restart.cmd new file mode 100644 index 0000000..09abb2c --- /dev/null +++ b/scripts/scripts/restart.cmd @@ -0,0 +1,2 @@ +@echo off +python "%~dp0restart.py" %* \ No newline at end of file diff --git a/scripts/scripts/restart.example.sh b/scripts/scripts/restart.example.sh new file mode 100644 index 0000000..967e951 --- /dev/null +++ b/scripts/scripts/restart.example.sh @@ -0,0 +1,10 @@ +#!/bin/sh +set -eu +# TODO: copy to restart.sh and implement using YOUR compose/stack services. +# Restart API and ALL used state stores (DB, sessions, S3, broker as applicable). +# Preserve persistent volumes and schema/data; never down -v / flush / re-seed. +# Allow operator unseal if required in lab7; do not print credentials. +# Exit 0 only after the intended action; test waits for API readiness separately. +printf '%s +' 'TODO: implement restart.sh for your infrastructure' >&2 +exit 2 diff --git a/scripts/scripts/restart.py b/scripts/scripts/restart.py new file mode 100644 index 0000000..90814d5 --- /dev/null +++ b/scripts/scripts/restart.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +import subprocess +import sys +import time +import urllib.request +from pathlib import Path + +ROOT = Path(__file__).resolve().parent.parent +BASE_URL = "http://localhost:8080" + + +def run(cmd): + print(f"[restart] $ {' '.join(cmd)}", flush=True) + result = subprocess.run(cmd, cwd=ROOT) + if result.returncode != 0: + print( + f"[restart] command failed with code {result.returncode}", + file=sys.stderr, + ) + sys.exit(result.returncode) + + +def main(): + run(["docker", "compose", "--env-file", ".env", "down"]) + run([ + "docker", "compose", "--env-file", ".env", + "up", "-d", "--build", "--scale", "api=2", + ]) + + print("[restart] waiting for /health/ready", flush=True) + deadline = time.monotonic() + 90 + while time.monotonic() < deadline: + try: + with urllib.request.urlopen( + f"{BASE_URL}/health/ready", timeout=2 + ) as r: + if r.status == 200: + print("[restart] api is ready", flush=True) + return 0 + except Exception: + time.sleep(1) + print( + "[restart] api did not become ready in 90 seconds", + file=sys.stderr, + ) + return 1 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/scripts/restart.sh b/scripts/scripts/restart.sh new file mode 100644 index 0000000..d5c1313 --- /dev/null +++ b/scripts/scripts/restart.sh @@ -0,0 +1,22 @@ +#!/usr/bin/env bash +set -euo pipefail + +cd "$(dirname "$0")/.." + +echo "[restart.sh] docker compose down (volumes preserved)" +docker compose --env-file .env down + +echo "[restart.sh] docker compose up -d --build --scale api=2" +docker compose --env-file .env up -d --build --scale api=2 + +echo "[restart.sh] waiting for /health/ready" +for i in $(seq 1 90); do + if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then + echo "[restart.sh] api is ready" + exit 0 + fi + sleep 1 +done + +echo "[restart.sh] api did not become ready in 90 seconds" >&2 +exit 1 \ No newline at end of file diff --git a/scripts/scripts/rolling-update.py b/scripts/scripts/rolling-update.py new file mode 100644 index 0000000..069321e --- /dev/null +++ b/scripts/scripts/rolling-update.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +import base64 +import json +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +import httpx + +BASE = "http://localhost:8080" +ROOT = Path(__file__).resolve().parent.parent +EVIDENCE = ROOT / "evidence" / "rolling-update.json" + + +def register_and_login(client): + username = "roll_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={"username": username, "display_name": "R", "password": password}, + ) + assert r.status_code == 201, r.text + user = r.json() + credential = base64.b64encode((username + ":" + password).encode()).decode() + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def main(): + with httpx.Client(timeout=5) as c: + alice = register_and_login(c) + bob = register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "roll", "member_ids": [alice["id"], bob["id"]]}, + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + running = {"flag": True} + latencies = [] + errors = 0 + lock = threading.Lock() + + def worker(): + nonlocal errors + with httpx.Client(timeout=3) as c: + while running["flag"]: + t0 = time.monotonic() + try: + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": "roll-" + uuid.uuid4().hex[:8]}, + headers={ + "Authorization": "Bearer " + alice["token"], + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + dt = time.monotonic() - t0 + if r.status_code == 201: + with lock: + latencies.append(dt) + else: + with lock: + errors += 1 + except Exception: + with lock: + errors += 1 + + threads = [threading.Thread(target=worker) for _ in range(4)] + for t in threads: + t.start() + + time.sleep(3) + with lock: + before = len(latencies) + print(f"[roll] baseline RPS ~{before/3:.1f}", flush=True) + + for replica_name in ["mtusi2026lab3-api-1", "mtusi2026lab3-api-2"]: + print(f"[roll] restarting {replica_name}", flush=True) + subprocess.run(["docker", "restart", replica_name], check=True) + time.sleep(8) + + time.sleep(2) + + running["flag"] = False + for t in threads: + t.join(timeout=5) + + with lock: + report = { + "total_successful": len(latencies), + "total_errors": errors, + "baseline_rps_3s": round(before / 3.0, 2), + "avg_latency_ms": round(1000 * sum(latencies) / len(latencies), 2) if latencies else None, + } + print(json.dumps(report, indent=2, ensure_ascii=False)) + + EVIDENCE.parent.mkdir(parents=True, exist_ok=True) + EVIDENCE.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/scripts/scaling-benchmark.py b/scripts/scripts/scaling-benchmark.py new file mode 100644 index 0000000..7d23f65 --- /dev/null +++ b/scripts/scripts/scaling-benchmark.py @@ -0,0 +1,194 @@ +#!/usr/bin/env python3 +import base64 +import json +import os +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +import httpx + +BASE = "http://localhost:8080" +ROOT = Path(__file__).resolve().parent.parent +EVIDENCE = ROOT / "evidence" / "scaling.json" + + +def register_and_login(client): + username = "scale_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={"username": username, "display_name": "S", "password": password}, + ) + assert r.status_code == 201, r.text + user = r.json() + credential = base64.b64encode((username + ":" + password).encode()).decode() + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def run_load(chat_id: str, token: str, concurrency: int, duration: float): + latencies = [] + errors = 0 + lock = threading.Lock() + + def worker(): + nonlocal errors + local_lat = [] + local_err = 0 + with httpx.Client(timeout=15) as c: + deadline = time.monotonic() + duration + i = 0 + while time.monotonic() < deadline: + t0 = time.monotonic() + try: + if i % 10 == 0: + r = c.get( + f"{BASE}/api/v1/chats/{chat_id}/messages?limit=10", + headers={"Authorization": "Bearer " + token}, + ) + else: + r = c.post( + f"{BASE}/api/v1/chats/{chat_id}/messages", + json={"text": "s-" + uuid.uuid4().hex[:6]}, + headers={ + "Authorization": "Bearer " + token, + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + if r.status_code not in (200, 201): + local_err += 1 + else: + local_lat.append(time.monotonic() - t0) + except Exception: + local_err += 1 + i += 1 + with lock: + latencies.extend(local_lat) + errors += local_err + + threads = [threading.Thread(target=worker) for _ in range(concurrency)] + started = time.monotonic() + for t in threads: + t.start() + for t in threads: + t.join() + elapsed = time.monotonic() - started + + latencies.sort() + + def pct(p): + if not latencies: + return None + idx = max(0, int(len(latencies) * p) - 1) + return round(latencies[idx] * 1000, 2) + + return { + "concurrency": concurrency, + "duration_s": round(elapsed, 2), + "success": len(latencies), + "errors": errors, + "rps": round(len(latencies) / elapsed, 2) if elapsed else 0, + "p50_ms": pct(0.50), + "p95_ms": pct(0.95), + "p99_ms": pct(0.99), + } + + +def switch_stack(replicas: int, cpus: str, memory: str): + env = dict(os.environ) + env["API_CPUS"] = cpus + env["API_MEMORY"] = memory + + subprocess.run( + ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", "-f", "compose-scale.yaml", "down"], + cwd=ROOT, check=True, env=env, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + ) + subprocess.run( + ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", "-f", "compose-scale.yaml", + "up", "-d", "--build", "--scale", f"api={replicas}"], + cwd=ROOT, check=True, env=env, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + ) + + for _ in range(120): + try: + with httpx.Client(timeout=2) as c: + r = c.get(f"{BASE}/health/ready") + if r.status_code == 200: + time.sleep(8) + return + except Exception: + pass + time.sleep(1) + raise RuntimeError("API did not become ready") + + +def experiment_series(name, configurations, concurrency): + results = [] + for cfg in configurations: + replicas = cfg["replicas"] + cpus = cfg["cpus"] + memory = cfg["memory"] + print(f"\n=== {name}: replicas={replicas}, cpus={cpus}, memory={memory}, clients={concurrency} ===", flush=True) + switch_stack(replicas, cpus, memory) + + with httpx.Client(timeout=15) as c: + alice = register_and_login(c) + bob = register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "scale", "member_ids": [alice["id"], bob["id"]]}, + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + for run in range(3): + print(f" run {run+1}/3...", flush=True) + m = run_load(chat["id"], alice["token"], concurrency=concurrency, duration=20) + m["replicas"] = replicas + m["cpus_per_replica"] = cpus + m["memory_per_replica"] = memory + m["run"] = run + 1 + m["series"] = name + results.append(m) + print(f" RPS={m['rps']}, p95={m['p95_ms']}, errors={m['errors']}", flush=True) + + return results + + +def main(): + all_results = [] + + print("### Baseline: 1 replica, 2 CPU, 20 clients", flush=True) + all_results.extend(experiment_series( + "baseline", + [{"replicas": 1, "cpus": "2.0", "memory": "512M"}], + concurrency=20, + )) + + print("\n### Improved: 2 replicas, 1 CPU, 20 clients", flush=True) + all_results.extend(experiment_series( + "improved", + [{"replicas": 2, "cpus": "1.0", "memory": "256M"}], + concurrency=20, + )) + + EVIDENCE.parent.mkdir(parents=True, exist_ok=True) + EVIDENCE.write_text( + json.dumps(all_results, indent=2, ensure_ascii=False), + encoding="utf-8", + ) + print(f"\nSaved {len(all_results)} records to {EVIDENCE}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/scripts/stop-one.cmd b/scripts/scripts/stop-one.cmd new file mode 100644 index 0000000..ba5c965 --- /dev/null +++ b/scripts/scripts/stop-one.cmd @@ -0,0 +1,2 @@ +@echo off +python "%~dp0stop-one.py" %* \ No newline at end of file diff --git a/scripts/scripts/stop-one.example.sh b/scripts/scripts/stop-one.example.sh new file mode 100644 index 0000000..ae149e8 --- /dev/null +++ b/scripts/scripts/stop-one.example.sh @@ -0,0 +1,10 @@ +#!/bin/sh +set -eu +# TODO: copy to stop-one.sh, map TARGET_INSTANCE_ID to ONE API container/task. +# Stop that instance and leave it stopped; no stop of DB/LB/volumes. +# Return quickly (within 10 s); the test sends requests during this script. +# Restore the replica explicitly after the test. Never print credentials. +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" +printf '%s +' 'TODO: implement stop-one.sh for your infrastructure' >&2 +exit 2 diff --git a/scripts/scripts/stop-one.py b/scripts/scripts/stop-one.py new file mode 100644 index 0000000..e836501 --- /dev/null +++ b/scripts/scripts/stop-one.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 +import os +import subprocess +import sys + + +def main(): + target = os.environ.get("TARGET_INSTANCE_ID") + if not target: + print("[stop-one] TARGET_INSTANCE_ID not set", file=sys.stderr) + return 1 + + names = subprocess.run( + ["docker", "ps", "--filter", "name=mtusi2026lab4-api-", "--format", "{{.Names}}"], + capture_output=True, text=True, check=True, + ).stdout.split() + + for container in names: + logs = subprocess.run( + ["docker", "logs", container], + capture_output=True, text=True, check=False, + ) + combined = logs.stdout + logs.stderr + if f"INSTANCE_ID={target}" in combined: + print(f"[stop-one] stopping {container} (instance={target})", flush=True) + subprocess.run(["docker", "stop", "--time=2", container], check=True) + return 0 + + print(f"[stop-one] no container found for INSTANCE_ID={target}", file=sys.stderr) + return 1 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/scripts/stop-one.sh b/scripts/scripts/stop-one.sh new file mode 100644 index 0000000..5c084f9 --- /dev/null +++ b/scripts/scripts/stop-one.sh @@ -0,0 +1,15 @@ +#!/usr/bin/env bash +set -euo pipefail + +TARGET="${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID not set}" + +for container in $(docker ps --filter "name=mtusi2026lab4-api-" --format "{{.Names}}"); do + if docker logs "$container" 2>&1 | grep -q "INSTANCE_ID=$TARGET"; then + echo "[stop-one] stopping $container (instance=$TARGET)" + docker stop "$container" + exit 0 + fi +done + +echo "[stop-one] no container found for INSTANCE_ID=$TARGET" >&2 +exit 1 \ No newline at end of file diff --git a/scripts/scripts/test-idempotency.py b/scripts/scripts/test-idempotency.py new file mode 100644 index 0000000..cb5e2a5 --- /dev/null +++ b/scripts/scripts/test-idempotency.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 +import base64 +import json +import sys +import threading +import time +import uuid +from pathlib import Path + +import httpx + +BASE = "http://localhost:8080" +ROOT = Path(__file__).resolve().parent.parent +EVIDENCE = ROOT / "evidence" / "idempotency.json" + + +def register_and_login(client): + username = "idem_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={"username": username, "display_name": "I", "password": password}, + ) + assert r.status_code == 201, r.text + user = r.json() + credential = base64.b64encode((username + ":" + password).encode()).decode() + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def main(): + with httpx.Client(timeout=10) as c: + alice = register_and_login(c) + bob = register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "idem", "member_ids": [alice["id"], bob["id"]]}, + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + key = uuid.uuid4().hex + text = "idempotency-test-" + uuid.uuid4().hex[:8] + results = [] + lock = threading.Lock() + barrier = threading.Barrier(10) + + def worker(): + try: + with httpx.Client(timeout=10) as c: + barrier.wait() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": text}, + headers={ + "Authorization": "Bearer " + alice["token"], + "Idempotency-Key": key, + }, + ) + with lock: + results.append((r.status_code, r.headers.get("x-instance-id"))) + except Exception as e: + with lock: + results.append((0, str(e))) + + threads = [threading.Thread(target=worker) for _ in range(10)] + for t in threads: + t.start() + for t in threads: + t.join() + + time.sleep(1) + + with httpx.Client(timeout=10) as c: + page = c.get( + f"{BASE}/api/v1/chats/{chat['id']}/messages?limit=100", + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + matching = [m for m in page["items"] if m["text"] == text] + message_ids = {m["id"] for m in matching} + instances_seen = list({r[1] for r in results if r[1] and r[0] > 0}) + statuses = [r[0] for r in results] + + report = { + "concurrent_requests": len(results), + "statuses": statuses, + "unique_instances": instances_seen, + "messages_created": len(matching), + "unique_message_ids": len(message_ids), + "idempotency_ok": len(matching) == 1, + "instances_count": len(instances_seen), + } + print(json.dumps(report, indent=2, ensure_ascii=False)) + + EVIDENCE.parent.mkdir(parents=True, exist_ok=True) + EVIDENCE.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/scripts/scripts/validate_openapi.py b/scripts/scripts/validate_openapi.py new file mode 100644 index 0000000..1dfe4a9 --- /dev/null +++ b/scripts/scripts/validate_openapi.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +"""Full OpenAPI and JSON Schema checks; install requirements-dev.txt first.""" +import json +from pathlib import Path +from openapi_spec_validator import validate +from jsonschema import Draft202012Validator + +root = Path(__file__).resolve().parents[1] +spec = json.loads((root/'contracts/openapi.json').read_text()) +validate(spec) +from referencing import Registry, Resource +# The base URI resolves local #/components references inside examples. +resource = dict(spec, **{'$schema': 'https://json-schema.org/draft/2020-12/schema'}) +registry = Registry().with_resource('urn:mtusi:openapi', Resource.from_contents(resource)) +for name, example in json.loads((root/'contracts/examples.json').read_text()).items(): + schema = {'$ref': 'urn:mtusi:openapi#/components/schemas/' + name} + Draft202012Validator(schema, registry=registry).validate(example) +for path in (root/'contracts').glob('*.schema.json'): + schema = json.loads(path.read_text()) + Draft202012Validator.check_schema(schema) + for example in schema.get('examples',[]): + Draft202012Validator(schema).validate(example) +print('PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.') diff --git a/student-tests/__init__.py b/student-tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/student-tests/benchmark.py b/student-tests/benchmark.py new file mode 100644 index 0000000..2b5e843 --- /dev/null +++ b/student-tests/benchmark.py @@ -0,0 +1,117 @@ +import json +import time +import uuid +from concurrent.futures import ThreadPoolExecutor +import httpx + +BASE = "http://localhost:8080" + + +def register(client: httpx.Client) -> dict: + username = "u_" + uuid.uuid4().hex[:10] + return client.post( + f"{BASE}/api/v1/users", + json={"username": username, "display_name": "Bench"}, + ).json() + + +def setup(history_size: int): + with httpx.Client(timeout=120) as c: + alice = register(c) + bob = register(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "bench", "member_ids": [alice["id"], bob["id"]]}, + headers={"X-User-Id": alice["id"]}, + ).json() + for i in range(history_size): + c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": f"seed-{i}"}, + headers={"X-User-Id": alice["id"]}, + ) + return alice, bob, chat + + +def measure(chat_id: str, actor_id: str, concurrency: int, duration: float = 5.0): + latencies = [] + errors = 0 + lock = __import__("threading").Lock() + + def worker(worker_id): + nonlocal errors + local_lat = [] + local_err = 0 + with httpx.Client(timeout=10) as c: + deadline = time.monotonic() + duration + i = 0 + while time.monotonic() < deadline: + t0 = time.monotonic() + try: + if i % 10 == 0: + r = c.get( + f"{BASE}/api/v1/chats/{chat_id}/messages?limit=50", + headers={"X-User-Id": actor_id}, + ) + else: + r = c.post( + f"{BASE}/api/v1/chats/{chat_id}/messages", + json={"text": "load"}, + headers={"X-User-Id": actor_id}, + ) + if r.status_code not in (200, 201): + local_err += 1 + else: + local_lat.append(time.monotonic() - t0) + except Exception: + local_err += 1 + i += 1 + with lock: + latencies.extend(local_lat) + errors += local_err + + t_start = time.monotonic() + with ThreadPoolExecutor(max_workers=concurrency) as pool: + list(pool.map(lambda w: worker(w), range(concurrency))) + elapsed = time.monotonic() - t_start + + latencies.sort() + + def pct(p): + if not latencies: + return None + idx = max(0, int(len(latencies) * p) - 1) + return round(latencies[idx] * 1000, 3) + + rps = len(latencies) / elapsed if elapsed else 0 + return { + "concurrency": concurrency, + "elapsed_s": round(elapsed, 2), + "success": len(latencies), + "errors": errors, + "rps": round(rps, 2), + "p50_ms": pct(0.50), + "p95_ms": pct(0.95), + "p99_ms": pct(0.99), + } + + +def main(): + results = [] + for history in (100, 1000, 10000): + print(f"Setup history={history}...") + alice, _, chat = setup(history) + for conc in (1, 10, 50): + print(f" measure history={history} concurrency={conc}...") + m = measure(chat["id"], alice["id"], conc, duration=5.0) + m["history_size"] = history + results.append(m) + print(" ", json.dumps(m, ensure_ascii=False)) + + with open("benchmark_results.json", "w", encoding="utf-8") as f: + json.dump(results, f, ensure_ascii=False, indent=2) + print("Saved to benchmark_results.json") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/cache_experiment.py b/student-tests/cache_experiment.py new file mode 100644 index 0000000..83b6034 --- /dev/null +++ b/student-tests/cache_experiment.py @@ -0,0 +1,176 @@ +"""Cache stampede experiment. + +Measures SQL calls and latency for parallel GET /messages with cold cache. +Run twice: before and after single-flight protection. +""" +import base64 +import json +import os +import subprocess +import time +import uuid +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +import httpx + +BASE = "http://localhost:8080" +EVIDENCE = Path(__file__).resolve().parent.parent / "evidence" / "cache_experiment.json" + + +def register_and_login(client: httpx.Client) -> dict: + username = "cache_" + uuid.uuid4().hex[:10] + password = "Test-password-1234" + r = client.post( + f"{BASE}/api/v1/users", + json={ + "username": username, + "display_name": "Cache", + "password": password, + }, + ) + assert r.status_code == 201, r.text + user = r.json() + credential = base64.b64encode( + (username + ":" + password).encode("utf-8") + ).decode("ascii") + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def auth(actor: dict) -> dict: + return {"Authorization": "Bearer " + actor["token"]} + + +def sql_calls_for_query(substring: str) -> int: + """Count SQL calls from pg_stat_statements matching substring.""" + sql = ( + "SELECT COALESCE(SUM(calls), 0) FROM pg_stat_statements " + f"WHERE query ILIKE '%{substring}%';" + ) + result = subprocess.run( + [ + "docker", "compose", "exec", "-T", "postgres", + "psql", "-U", "messenger", "-d", "messenger", + "-t", "-A", "-c", sql, + ], + capture_output=True, text=True, check=True, + ) + return int(result.stdout.strip() or "0") + + +def reset_pg_stats() -> None: + subprocess.run( + [ + "docker", "compose", "exec", "-T", "postgres", + "psql", "-U", "messenger", "-d", "messenger", + "-c", "SELECT pg_stat_statements_reset();", + ], + capture_output=True, text=True, check=True, + ) + + +def flush_cache() -> None: + subprocess.run( + [ + "docker", "compose", "exec", "-T", "valkey", + "sh", "-c", + "valkey-cli --scan --pattern 'messages:*' | xargs -r valkey-cli DEL", + ], + capture_output=True, text=True, check=True, + ) + +def run_parallel_gets(chat_id: str, token: str, concurrency: int = 50): + """Fire N parallel GET requests; return list of latencies and statuses.""" + results = [] + + def worker(): + with httpx.Client(timeout=15) as c: + t0 = time.monotonic() + r = c.get( + f"{BASE}/api/v1/chats/{chat_id}/messages?limit=50", + headers={"Authorization": "Bearer " + token}, + ) + dt = time.monotonic() - t0 + return dt, r.status_code + + with ThreadPoolExecutor(max_workers=concurrency) as pool: + results = list(pool.map(lambda _: worker(), range(concurrency))) + return results + + +def main(): + label = os.getenv("LABEL", "before") + concurrency = int(os.getenv("CONCURRENCY", "50")) + + with httpx.Client(timeout=30) as c: + alice = register_and_login(c) + bob = register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "cache", "member_ids": [alice["id"], bob["id"]]}, + headers=auth(alice), + ).json() + for i in range(100): + c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": f"seed-{i:03d}"}, + headers=auth(alice), + ) + + flush_cache() + reset_pg_stats() + time.sleep(0.5) + + print(f"Running {concurrency} parallel GETs (label={label})...") + started = time.monotonic() + results = run_parallel_gets(chat["id"], alice["token"], concurrency) + elapsed = time.monotonic() - started + + latencies = sorted(dt for dt, _ in results) + statuses = [s for _, s in results] + ok_count = sum(1 for s in statuses if s == 200) + errors = concurrency - ok_count + + sql_calls = sql_calls_for_query("FROM messages") + + def pct(p): + idx = max(0, int(len(latencies) * p) - 1) + return round(latencies[idx] * 1000, 2) + + report = { + "label": label, + "concurrency": concurrency, + "elapsed_s": round(elapsed, 3), + "ok": ok_count, + "errors": errors, + "latency_ms": { + "p50": pct(0.5), + "p95": pct(0.95), + "p99": pct(0.99), + }, + "sql_calls_from_messages": sql_calls, + } + print(json.dumps(report, indent=2, ensure_ascii=False)) + + existing = [] + if EVIDENCE.exists(): + try: + existing = json.loads(EVIDENCE.read_text(encoding="utf-8")) + except json.JSONDecodeError: + existing = [] + existing.append(report) + EVIDENCE.parent.mkdir(parents=True, exist_ok=True) + EVIDENCE.write_text( + json.dumps(existing, indent=2, ensure_ascii=False), + encoding="utf-8", + ) + print(f"Saved to {EVIDENCE}") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/explain.py b/student-tests/explain.py new file mode 100644 index 0000000..9b3c9c4 --- /dev/null +++ b/student-tests/explain.py @@ -0,0 +1,90 @@ +"""Populate a chat with 10000 messages and run EXPLAIN (ANALYZE, BUFFERS). + +Saves the plan to evidence/explain.txt for the report. +""" +import base64 +import time +import uuid +from pathlib import Path + +import httpx + +BASE = "http://localhost:8080" +EVIDENCE = Path(__file__).resolve().parent.parent / "evidence" / "explain.txt" + + +def register_and_login(client: httpx.Client) -> dict: + username = "explain_" + uuid.uuid4().hex[:10] + password = "Test-password-1234" + r = client.post( + f"{BASE}/api/v1/users", + json={ + "username": username, + "display_name": "Explain", + "password": password, + }, + ) + assert r.status_code == 201, r.text + user = r.json() + + credential = base64.b64encode( + (username + ":" + password).encode("utf-8") + ).decode("ascii") + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + session = r.json() + return {"id": user["id"], "token": session["token"]} + + +def auth(actor: dict) -> dict: + return {"Authorization": "Bearer " + actor["token"]} + + +def main(): + total = 10000 + print(f"Setting up {total} messages...") + + with httpx.Client(timeout=120) as c: + alice = register_and_login(c) + bob = register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "explain", "member_ids": [alice["id"], bob["id"]]}, + headers=auth(alice), + ).json() + + print(f"chat_id = {chat['id']}") + + batch = 200 + started = time.monotonic() + for i in range(0, total, batch): + for j in range(batch): + c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": f"msg-{i+j:05d}"}, + headers=auth(alice), + ) + if (i + batch) % 2000 == 0: + elapsed = time.monotonic() - started + print(f" {i+batch}/{total} messages, {elapsed:.1f}s") + + print(f"Setup done in {time.monotonic() - started:.1f}s") + print(f"chat_id: {chat['id']}") + + print("Run in psql:") + print(f""" +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '{chat['id']}' + AND (created_at, id) > ('2026-01-01T00:00:00Z'::timestamptz, '00000000-0000-0000-0000-000000000000'::uuid) +ORDER BY created_at, id +LIMIT 51; +""") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/queue_benchmark.py b/student-tests/queue_benchmark.py new file mode 100644 index 0000000..cf2a51a --- /dev/null +++ b/student-tests/queue_benchmark.py @@ -0,0 +1,186 @@ +import argparse +import base64 +import io +import json +import os +import subprocess +import sys +import time +import uuid +from pathlib import Path + +import httpx +from PIL import Image + +BASE = "http://localhost:8080" +COMPOSE = ["docker", "compose", "--env-file", ".env"] +EVIDENCE = Path(__file__).resolve().parent.parent / "evidence" +WORKER_CONTAINER = "mtusi2026lab5-worker-1" +SIZES = { + "small": (320, 200), + "medium": (1280, 800), + "large": (4000, 3000), +} + + +def _png(size): + buf = io.BytesIO() + Image.new("RGB", size, (64, 128, 192)).save(buf, format="PNG") + return buf.getvalue() + + +def _user(c): + u = "qb_" + uuid.uuid4().hex[:10] + p = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={"username": u, "display_name": "Q", "password": p}) + cred = base64.b64encode(f"{u}:{p}".encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}).json() + return {"id": s["user"]["id"], "token": s["token"]} + + +def _auth(a): + return {"Authorization": "Bearer " + a["token"]} + + +def _worker_mem(): + out = subprocess.run( + ["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", WORKER_CONTAINER], + capture_output=True, text=True, + ).stdout.strip() + if not out or "/" not in out: + return None + v = out.split("/")[0].strip() + units = {"B": 1, "KiB": 1024, "Ki": 1024, "MiB": 1024**2, "Mi": 1024**2, + "GiB": 1024**3, "Gi": 1024**3} + for u in sorted(units, key=len, reverse=True): + if v.endswith(u): + return round(int(float(v[: -len(u)]) * units[u]) / 1024**2, 1) + return None + + +def _restart_worker(prefetch): + env = dict(os.environ) + env["PREFETCH_COUNT"] = str(prefetch) + subprocess.run( + COMPOSE + ["up", "-d", "--force-recreate", "worker"], + env=env, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + ) + time.sleep(5) + + +def _start_worker(prefetch): + env = dict(os.environ) + env["PREFETCH_COUNT"] = str(prefetch) + subprocess.run( + COMPOSE + ["up", "-d", "--force-recreate", "worker"], + env=env, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + ) + + +def _percentiles(values, ps=(0.5, 0.95, 0.99)): + if not values: + return {f"p{int(p*100)}": None for p in ps} + s = sorted(values) + return {f"p{int(p*100)}": round(s[max(0, int(len(s)*p)-1)], 3) for p in ps} + + +def run(prefetch, size_name, files, output): + size = SIZES[size_name] + data = _png(size) + with httpx.Client(timeout=30) as c: + a = _user(c) + b = _user(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": f"qb-{prefetch}-{size_name}", "member_ids": [a["id"], b["id"]]}, + headers=_auth(a), + ).json() + chat_id = chat["id"] + + _restart_worker(prefetch) + + uploads = [] + started = time.monotonic() + with httpx.Client(timeout=30) as c: + for i in range(files): + t = time.monotonic() + r = c.post( + f"{BASE}/api/v1/chats/{chat_id}/attachments", + params={"filename": f"f{i}.png"}, + content=data, + headers={**_auth(a), "Content-Type": "image/png"}, + ) + if r.status_code != 202: + print(f"upload failed: {r.status_code} {r.text[:100]}", file=sys.stderr) + continue + uploads.append({"id": r.json()["id"], "t_upload": t}) + + states = {u["id"]: {"t_upload": u["t_upload"], "t_processing": None, "t_ready": None} + for u in uploads} + deadline = time.monotonic() + 600 + pending = set(states) + with httpx.Client(timeout=10) as c: + while pending and time.monotonic() < deadline: + for att_id in list(pending): + r = c.get(f"{BASE}/api/v1/attachments/{att_id}", headers=_auth(a)) + if r.status_code != 200: + continue + st = r.json()["status"] + now = time.monotonic() + if st == "processing" and states[att_id]["t_processing"] is None: + states[att_id]["t_processing"] = now + if st in ("ready", "failed"): + if states[att_id]["t_processing"] is None: + states[att_id]["t_processing"] = now + states[att_id]["t_ready"] = now + pending.discard(att_id) + if pending: + time.sleep(0.2) + + finished = time.monotonic() + rss = _worker_mem() + + queue_lags = [ + s["t_processing"] - s["t_upload"] + for s in states.values() if s["t_processing"] is not None + ] + ready_times = [ + s["t_ready"] - s["t_upload"] + for s in states.values() if s["t_ready"] is not None + ] + duration = finished - started + ok = len(ready_times) + report = { + "prefetch": prefetch, + "size": size_name, + "files_requested": files, + "files_ok": ok, + "files_failed": files - ok, + "duration_s": round(duration, 3), + "throughput_files_per_s": round(ok / duration, 3) if duration else None, + "queue_lag_s": _percentiles(queue_lags), + "time_to_ready_s": _percentiles(ready_times), + "worker_rss_mib": rss, + } + out = Path(output) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8") + print(json.dumps(report, indent=2, ensure_ascii=False)) + _start_worker(prefetch) + return report + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--prefetch", type=int, required=True) + parser.add_argument("--size", choices=list(SIZES), required=True) + parser.add_argument("--files", type=int, default=50) + parser.add_argument("--output", required=True) + args = parser.parse_args() + run(args.prefetch, args.size, args.files, args.output) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/queue_recovery.py b/student-tests/queue_recovery.py new file mode 100644 index 0000000..9ca7e81 --- /dev/null +++ b/student-tests/queue_recovery.py @@ -0,0 +1,101 @@ +import argparse +import base64 +import io +import json +import subprocess +import time +import uuid +from pathlib import Path + +import httpx +from PIL import Image + +BASE = "http://localhost:8080" +COMPOSE = ["docker", "compose", "--env-file", ".env"] +EVIDENCE = Path(__file__).resolve().parent.parent / "evidence" + + +def _png(size=(1280, 800)): + buf = io.BytesIO() + Image.new("RGB", size, (128, 64, 192)).save(buf, format="PNG") + return buf.getvalue() + + +def _user(c): + u = "qr_" + uuid.uuid4().hex[:10] + p = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={"username": u, "display_name": "Q", "password": p}) + cred = base64.b64encode(f"{u}:{p}".encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}).json() + return {"id": s["user"]["id"], "token": s["token"]} + + +def _auth(a): + return {"Authorization": "Bearer " + a["token"]} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--files", type=int, default=100) + parser.add_argument("--output", default="evidence/queue-recovery.json") + args = parser.parse_args() + + data = _png() + with httpx.Client(timeout=30) as c: + a = _user(c) + b = _user(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "recovery", "member_ids": [a["id"], b["id"]]}, + headers=_auth(a), + ).json() + chat_id = chat["id"] + + subprocess.run(COMPOSE + ["stop", "worker"], check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + ids = [] + with httpx.Client(timeout=30) as c: + for i in range(args.files): + r = c.post( + f"{BASE}/api/v1/chats/{chat_id}/attachments", + params={"filename": f"f{i}.png"}, + content=data, + headers={**_auth(a), "Content-Type": "image/png"}, + ) + if r.status_code == 202: + ids.append(r.json()["id"]) + print(f"uploaded {len(ids)} files, queue accumulated", flush=True) + + time.sleep(10) + subprocess.run(COMPOSE + ["start", "worker"], check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + worker_started = time.monotonic() + + deadline = time.monotonic() + 600 + pending = set(ids) + with httpx.Client(timeout=10) as c: + while pending and time.monotonic() < deadline: + for att_id in list(pending): + r = c.get(f"{BASE}/api/v1/attachments/{att_id}", headers=_auth(a)) + if r.status_code != 200: + continue + if r.json()["status"] in ("ready", "failed"): + pending.discard(att_id) + if pending: + time.sleep(0.5) + finished = time.monotonic() + report = { + "files": args.files, + "finished": args.files - len(pending), + "pending_after_timeout": len(pending), + "recovery_time_s": round(finished - worker_started, 3), + } + out = Path(args.output) + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8") + print(json.dumps(report, indent=2, ensure_ascii=False)) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/test_attachments.py b/student-tests/test_attachments.py new file mode 100644 index 0000000..b3c10c6 --- /dev/null +++ b/student-tests/test_attachments.py @@ -0,0 +1,191 @@ +import base64 +import io +import uuid + +import httpx +from PIL import Image + +BASE = "http://localhost:8080" + + +def _register_and_login(client: httpx.Client) -> dict: + username = "att_" + uuid.uuid4().hex[:10] + password = "Test-password-1234" + r = client.post( + f"{BASE}/api/v1/users", + json={"username": username, "display_name": "A", "password": password}, + ) + assert r.status_code == 201, r.text + user = r.json() + cred = base64.b64encode((username + ":" + password).encode()).decode() + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + cred}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def _auth(actor: dict) -> dict: + return {"Authorization": "Bearer " + actor["token"]} + + +def _idem(actor: dict) -> dict: + return {**_auth(actor), "Idempotency-Key": uuid.uuid4().hex} + + +def _png(w: int = 320, h: int = 200, color=(255, 0, 0)) -> bytes: + buf = io.BytesIO() + Image.new("RGB", (w, h), color).save(buf, format="PNG") + return buf.getvalue() + + +def _chat(client: httpx.Client, owner: dict, *members: dict) -> dict: + member_ids = [owner["id"]] + [m["id"] for m in members] + r = client.post( + f"{BASE}/api/v1/chats", + json={"title": "att", "member_ids": member_ids}, + headers=_auth(owner), + ) + assert r.status_code == 201, r.text + return r.json() + + +def _upload(client, actor, chat_id, data, filename="x.png", content_type="image/png"): + return client.post( + f"{BASE}/api/v1/chats/{chat_id}/attachments", + params={"filename": filename}, + content=data, + headers={**_auth(actor), "Content-Type": content_type}, + ) + + +def test_oversize_returns_413(): + with httpx.Client(timeout=30) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat = _chat(c, a, b) + big = b"\x89PNG\r\n\x1a\n" + b"\x00" * (10 * 1024 * 1024) + r = _upload(c, a, chat["id"], big, filename="big.png") + assert r.status_code == 413, r.text + assert r.json()["error"]["code"] == "payload_too_large" + + +def test_corrupted_image_returns_415(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat = _chat(c, a, b) + data = _png()[:50] + r = _upload(c, a, chat["id"], data) + assert r.status_code == 415, r.text + assert r.json()["error"]["code"] == "unsupported_media_type" + + +def test_mime_spoof_returns_415(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat = _chat(c, a, b) + r = _upload(c, a, chat["id"], b"not an image at all") + assert r.status_code == 415, r.text + assert r.json()["error"]["code"] == "unsupported_media_type" + + +def test_bad_filename_returns_400(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat = _chat(c, a, b) + r = _upload(c, a, chat["id"], _png(), filename="../etc/passwd") + assert r.status_code == 400, r.text + assert r.json()["error"]["code"] == "invalid_request" + + +def test_empty_file_returns_415(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat = _chat(c, a, b) + r = _upload(c, a, chat["id"], b"") + assert r.status_code == 415, r.text + + +def test_outsider_cannot_download(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + eve = _register_and_login(c) + chat = _chat(c, a, b) + att = _upload(c, a, chat["id"], _png()).json() + r = c.get(f"{BASE}/api/v1/attachments/{att['id']}", headers=_auth(eve)) + assert r.status_code == 404 + r = c.get(f"{BASE}/api/v1/attachments/{att['id']}/content", headers=_auth(eve)) + assert r.status_code == 404 + + +def test_attach_foreign_attachment_returns_404(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat1 = _chat(c, a, b) + chat2 = _chat(c, a, b) + att = _upload(c, a, chat1["id"], _png()).json() + r = c.post( + f"{BASE}/api/v1/chats/{chat2['id']}/messages", + json={"text": "hi", "attachment_ids": [att["id"]]}, + headers=_idem(a), + ) + assert r.status_code == 404, r.text + + +def test_empty_text_without_attachments_returns_400(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat = _chat(c, a, b) + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": ""}, + headers=_idem(a), + ) + assert r.status_code == 400, r.text + assert r.json()["error"]["code"] == "invalid_request" + + +def test_empty_text_with_attachment_returns_201(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat = _chat(c, a, b) + att = _upload(c, a, chat["id"], _png()).json() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": "", "attachment_ids": [att["id"]]}, + headers=_idem(a), + ) + assert r.status_code == 201, r.text + assert r.json()["attachment_ids"] == [att["id"]] + + +def test_user_error_is_not_500(): + with httpx.Client(timeout=10) as c: + a = _register_and_login(c) + b = _register_and_login(c) + chat = _chat(c, a, b) + cases = [ + (_upload(c, a, chat["id"], b"not image"), 415), + (_upload(c, a, chat["id"], b""), 415), + (_upload(c, a, chat["id"], _png(), filename="../x"), 400), + ( + c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": ""}, + headers=_idem(a), + ), + 400, + ), + ] + for response, expected in cases: + assert response.status_code == expected, response.text + assert response.status_code < 500 \ No newline at end of file diff --git a/student-tests/test_cache.py b/student-tests/test_cache.py new file mode 100644 index 0000000..26b5bbf --- /dev/null +++ b/student-tests/test_cache.py @@ -0,0 +1,129 @@ +import base64 +import subprocess +import time +import uuid + +import httpx + +BASE = "http://localhost:8080" +COMPOSE = ["docker", "compose", "--env-file", ".env"] + + +def _register_and_login(client: httpx.Client) -> dict: + username = "cch_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={ + "username": username, + "display_name": "Cache Test", + "password": password, + }, + ) + assert r.status_code == 201, r.text + user = r.json() + credential = base64.b64encode( + (username + ":" + password).encode("utf-8") + ).decode("ascii") + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def _auth(actor: dict) -> dict: + return {"Authorization": "Bearer " + actor["token"]} + + +def _auth_idem(actor: dict) -> dict: + return { + "Authorization": "Bearer " + actor["token"], + "Idempotency-Key": uuid.uuid4().hex, + } + + +def test_read_after_write_sees_new_message(): + with httpx.Client() as c: + alice = _register_and_login(c) + bob = _register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "raw", "member_ids": [alice["id"], bob["id"]]}, + headers=_auth(alice), + ).json() + + r = c.get( + f"{BASE}/api/v1/chats/{chat['id']}/messages?limit=50", + headers=_auth(alice), + ) + assert r.status_code == 200 + before = r.json()["items"] + assert len(before) == 0 + + text = "read-after-write-" + uuid.uuid4().hex[:8] + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": text}, + headers=_auth_idem(alice), + ) + assert r.status_code == 201, r.text + + r = c.get( + f"{BASE}/api/v1/chats/{chat['id']}/messages?limit=50", + headers=_auth(alice), + ) + assert r.status_code == 200 + after = r.json()["items"] + texts = [m["text"] for m in after] + assert text in texts, f"read-after-write failed: {texts}" + + +def test_cache_recovers_after_valkey_restart(): + with httpx.Client() as c: + alice = _register_and_login(c) + bob = _register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "restart", "member_ids": [alice["id"], bob["id"]]}, + headers=_auth(alice), + ).json() + for i in range(5): + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": f"msg-{i}"}, + headers=_auth_idem(alice), + ) + assert r.status_code == 201, r.text + + r = c.get( + f"{BASE}/api/v1/chats/{chat['id']}/messages?limit=50", + headers=_auth(alice), + ) + assert r.status_code == 200 + before = r.json()["items"] + assert len(before) == 5 + + subprocess.run(COMPOSE + ["restart", "valkey"], check=True) + time.sleep(3) + + for _ in range(30): + try: + with httpx.Client(timeout=2) as c: + r = c.get(f"{BASE}/health/ready") + if r.status_code == 200: + break + except Exception: + pass + time.sleep(1) + + with httpx.Client() as c: + r = c.get( + f"{BASE}/api/v1/chats/{chat['id']}/messages?limit=50", + headers=_auth(alice), + ) + assert r.status_code == 200 + after = r.json()["items"] + assert len(after) == 5 + assert [m["id"] for m in after] == [m["id"] for m in before] \ No newline at end of file diff --git a/student-tests/test_presigned.py b/student-tests/test_presigned.py new file mode 100644 index 0000000..ff04f94 --- /dev/null +++ b/student-tests/test_presigned.py @@ -0,0 +1,134 @@ +import base64 +import hashlib +import io +import uuid + +import httpx +from PIL import Image + +BASE = "http://localhost:8080" + + +def _user(c): + u = "ps_" + uuid.uuid4().hex[:10] + p = "Test-password-1234" + r = c.post(f"{BASE}/api/v1/users", json={"username": u, "display_name": "P", "password": p}) + assert r.status_code == 201, r.text + user = r.json() + cred = base64.b64encode(f"{u}:{p}".encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}).json() + return {"id": user["id"], "token": s["token"]} + + +def _auth(a): + return {"Authorization": "Bearer " + a["token"]} + + +def _png(w=320, h=200): + buf = io.BytesIO() + Image.new("RGB", (w, h), (0, 255, 0)).save(buf, format="PNG") + return buf.getvalue() + + +def _chat(c, a, b): + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": "ps", "member_ids": [a["id"], b["id"]]}, + headers=_auth(a), + ) + assert r.status_code == 201, r.text + return r.json() + + +def test_presigned_happy_path(): + with httpx.Client(timeout=30) as c: + a = _user(c) + b = _user(c) + chat = _chat(c, a, b) + data = _png() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments/presign", + params={"filename": "p.png", "size": len(data), "content_type": "image/png"}, + headers=_auth(a), + ) + assert r.status_code == 201, r.text + presign = r.json() + put = httpx.put(presign["upload_url"], content=data, headers={"Content-Type": "image/png"}) + assert put.status_code == 200, put.text + r = c.post( + f"{BASE}/api/v1/attachments/{presign['attachment_id']}/complete", + headers=_auth(a), + ) + assert r.status_code == 201, r.text + att = r.json() + assert att["status"] == "ready" + assert att["sha256"] == hashlib.sha256(data).hexdigest() + dl = c.get(f"{BASE}/api/v1/attachments/{att['id']}/content", headers=_auth(b)) + assert dl.status_code == 200 + assert dl.content == data + + +def test_presigned_bad_signature_rejected(): + with httpx.Client(timeout=30) as c: + a = _user(c) + b = _user(c) + chat = _chat(c, a, b) + data = _png() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments/presign", + params={"filename": "p.png", "size": len(data), "content_type": "image/png"}, + headers=_auth(a), + ) + url = r.json()["upload_url"] + bad = url.replace("X-Amz-Signature=", "X-Amz-Signature=deadbeef") + put = httpx.put(bad, content=data, headers={"Content-Type": "image/png"}) + assert put.status_code == 403, put.text + + +def test_presigned_complete_without_upload_409(): + with httpx.Client(timeout=10) as c: + a = _user(c) + b = _user(c) + chat = _chat(c, a, b) + data = _png() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments/presign", + params={"filename": "p.png", "size": len(data), "content_type": "image/png"}, + headers=_auth(a), + ) + att_id = r.json()["attachment_id"] + r = c.post(f"{BASE}/api/v1/attachments/{att_id}/complete", headers=_auth(a)) + assert r.status_code == 409, r.text + + +def test_presigned_outsider_404(): + with httpx.Client(timeout=10) as c: + a = _user(c) + b = _user(c) + eve = _user(c) + chat = _chat(c, a, b) + data = _png() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments/presign", + params={"filename": "p.png", "size": len(data), "content_type": "image/png"}, + headers=_auth(a), + ) + att_id = r.json()["attachment_id"] + r = c.post(f"{BASE}/api/v1/attachments/{att_id}/complete", headers=_auth(eve)) + assert r.status_code == 404, r.text + + +def test_proxy_endpoint_still_works(): + with httpx.Client(timeout=10) as c: + a = _user(c) + b = _user(c) + chat = _chat(c, a, b) + data = _png() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments", + params={"filename": "proxy.png"}, + content=data, + headers={**_auth(a), "Content-Type": "image/png"}, + ) + assert r.status_code == 201, r.text + assert r.json()["status"] == "ready" \ No newline at end of file diff --git a/student-tests/test_race.py b/student-tests/test_race.py new file mode 100644 index 0000000..bd0a7bb --- /dev/null +++ b/student-tests/test_race.py @@ -0,0 +1,84 @@ +import base64 +import uuid +from concurrent.futures import ThreadPoolExecutor +import httpx + +BASE = "http://localhost:8080" + + +def _register_and_login(client: httpx.Client) -> dict: + username = "u_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={ + "username": username, + "display_name": "Тест", + "password": password, + }, + ) + user = r.json() + credential = base64.b64encode( + (username + ":" + password).encode("utf-8") + ).decode("ascii") + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + session = r.json() + return {"id": user["id"], "token": session["token"]} + + +def test_concurrent_writes_are_not_lost(): + with httpx.Client() as c: + alice = _register_and_login(c) + bob = _register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "race", "member_ids": [alice["id"], bob["id"]]}, + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + def worker(worker_id: int): + with httpx.Client(timeout=10) as c: + for i in range(10): + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": f"w{worker_id}-m{i}"}, + headers={ + "Authorization": "Bearer " + alice["token"], + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + if r.status_code != 201: + print(f"POST FAIL w{worker_id}-m{i}: {r.status_code} {r.text[:200]}") + + with ThreadPoolExecutor(max_workers=10) as pool: + list(pool.map(worker, range(10))) + + with httpx.Client() as c: + all_ids = [] + cursor = None + while True: + params = {"limit": 100} + if cursor: + params["cursor"] = cursor + r = c.get( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + params=params, + headers={"Authorization": "Bearer " + alice["token"]}, + ) + page = r.json() + if r.status_code != 200 or "items" not in page: + print(f"GET FAIL: {r.status_code} {r.text[:500]}") + print(f"chat_id: {chat['id']}") + print(f"alice_token: {alice['token'][:30]}...") + raise AssertionError(f"GET messages failed: {r.status_code}") + all_ids.extend(m["id"] for m in page["items"]) + cursor = page["next_cursor"] + if not cursor: + break + + print(f"Got {len(all_ids)} messages, unique: {len(set(all_ids))}") + assert len(all_ids) == 100 + assert len(set(all_ids)) == 100 \ No newline at end of file diff --git a/student-tests/test_resilience.py b/student-tests/test_resilience.py new file mode 100644 index 0000000..4815fd9 --- /dev/null +++ b/student-tests/test_resilience.py @@ -0,0 +1,153 @@ +"""Automatic resilience checks: expiry, Redis/DB unavailability. + +Requires Docker: test stops the service, checks API behaviour, restarts it. +Run: pytest student-tests/test_resilience.py -v -s +""" +import base64 +import subprocess +import time +import uuid + +import httpx + +BASE = "http://localhost:8080" +COMPOSE = ["docker", "compose", "--env-file", ".env"] + + +def _register_and_login(client: httpx.Client) -> dict: + username = "res_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={ + "username": username, + "display_name": "Res", + "password": password, + }, + ) + assert r.status_code == 201, r.text + user = r.json() + + credential = base64.b64encode( + (username + ":" + password).encode("utf-8") + ).decode("ascii") + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + session = r.json() + return { + "id": user["id"], + "username": username, + "password": password, + "token": session["token"], + } + + +def _wait_ready(timeout: float = 60.0) -> None: + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + with httpx.Client(timeout=2) as c: + r = c.get(f"{BASE}/health/ready") + if r.status_code == 200: + return + except Exception: + pass + time.sleep(1) + raise RuntimeError("API did not become ready in time") + + +def _compose(*args: str) -> None: + subprocess.run(COMPOSE + list(args), check=True) + + +def test_expiry_invalidates_session(monkeypatch): + """Session expires when SESSION_TTL_SECONDS is very small.""" + _compose("up", "-d", "--build", "api") + _wait_ready() + + with httpx.Client(timeout=5) as c: + actor = _register_and_login(c) + r = c.get( + f"{BASE}/api/v1/users/me", + headers={"Authorization": "Bearer " + actor["token"]}, + ) + assert r.status_code == 200 + + # Restart API with 2-second TTL + _compose("stop", "api") + subprocess.run( + ["docker", "compose", "--env-file", ".env", "rm", "-f", "api"], + check=False, + ) + subprocess.run( + [ + "docker", "compose", "--env-file", ".env", + "run", "-d", "--name", "api-short-ttl", + "-e", "SESSION_TTL_SECONDS=2", + "-p", "127.0.0.1:8080:8080", + "api", + ], + check=True, + ) + _wait_ready() + + with httpx.Client(timeout=5) as c: + fresh = _register_and_login(c) + r = c.get( + f"{BASE}/api/v1/users/me", + headers={"Authorization": "Bearer " + fresh["token"]}, + ) + assert r.status_code == 200 + print("Waiting 4 seconds for expiry...") + time.sleep(4) + r = c.get( + f"{BASE}/api/v1/users/me", + headers={"Authorization": "Bearer " + fresh["token"]}, + ) + assert r.status_code == 401, f"expected 401 after expiry, got {r.status_code}" + + subprocess.run(["docker", "stop", "api-short-ttl"], check=False) + subprocess.run(["docker", "rm", "api-short-ttl"], check=False) + _compose("up", "-d", "--build", "api") + _wait_ready() + + +def test_redis_unavailable_returns_503(): + """When Valkey is down, /health/ready returns 503.""" + _compose("up", "-d", "--build") + _wait_ready() + + _compose("stop", "valkey") + time.sleep(3) + + try: + with httpx.Client(timeout=5) as c: + r = c.get(f"{BASE}/health/ready") + assert r.status_code == 503, f"expected 503, got {r.status_code}" + body = r.json() + assert body["error"]["code"] == "unavailable" + finally: + _compose("start", "valkey") + _wait_ready() + + +def test_postgres_unavailable_returns_503(): + """When PostgreSQL is down, /health/ready returns 503.""" + _compose("up", "-d", "--build") + _wait_ready() + + _compose("stop", "postgres") + time.sleep(3) + + try: + with httpx.Client(timeout=5) as c: + r = c.get(f"{BASE}/health/ready") + assert r.status_code == 503, f"expected 503, got {r.status_code}" + body = r.json() + assert body["error"]["code"] == "unavailable" + finally: + _compose("start", "postgres") + _wait_ready() \ No newline at end of file diff --git a/student-tests/test_validation.py b/student-tests/test_validation.py new file mode 100644 index 0000000..299823d --- /dev/null +++ b/student-tests/test_validation.py @@ -0,0 +1,264 @@ +import base64 +import uuid +import httpx + +BASE = "http://localhost:8080" + + +def _register_and_login(client: httpx.Client) -> dict: + username = "u_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={ + "username": username, + "display_name": "Тест", + "password": password, + }, + ) + assert r.status_code == 201, r.text + user = r.json() + + credential = base64.b64encode( + (username + ":" + password).encode("utf-8") + ).decode("ascii") + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + session = r.json() + return { + "id": user["id"], + "username": username, + "password": password, + "token": session["token"], + } + + +def _auth(actor: dict) -> dict: + return {"Authorization": "Bearer " + actor["token"]} + + +def _auth_idem(actor: dict) -> dict: + return { + "Authorization": "Bearer " + actor["token"], + "Idempotency-Key": uuid.uuid4().hex, + } + + +def test_invalid_json_returns_400(): + with httpx.Client() as c: + r = c.post( + f"{BASE}/api/v1/users", + content=b"{not json at all", + headers={"Content-Type": "application/json"}, + ) + assert r.status_code == 400 + body = r.json() + assert body["error"]["code"] == "invalid_request" + assert "X-Request-Id" in r.headers + + +def test_duplicate_username_returns_409(): + with httpx.Client() as c: + actor = _register_and_login(c) + r = c.post( + f"{BASE}/api/v1/users", + json={ + "username": actor["username"], + "display_name": "Другой", + "password": "Another-password-123", + }, + ) + assert r.status_code == 409 + assert r.json()["error"]["code"] == "conflict" + + +def test_empty_message_returns_400(): + with httpx.Client() as c: + alice = _register_and_login(c) + bob = _register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "t", "member_ids": [alice["id"], bob["id"]]}, + headers=_auth(alice), + ).json() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": ""}, + headers=_auth_idem(alice), + ) + assert r.status_code == 400 + + +def test_outsider_gets_404_not_403(): + with httpx.Client() as c: + alice = _register_and_login(c) + bob = _register_and_login(c) + eve = _register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "t", "member_ids": [alice["id"], bob["id"]]}, + headers=_auth(alice), + ).json() + r = c.get( + f"{BASE}/api/v1/chats/{chat['id']}", + headers=_auth(eve), + ) + assert r.status_code == 404 + r2 = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": "вторжение"}, + headers=_auth_idem(eve), + ) + assert r2.status_code == 404 + + +def test_pagination_walks_all_pages(): + with httpx.Client() as c: + alice = _register_and_login(c) + bob = _register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "t", "member_ids": [alice["id"], bob["id"]]}, + headers=_auth(alice), + ).json() + sent_ids = [] + for i in range(5): + m = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": f"msg-{i}"}, + headers=_auth_idem(alice), + ).json() + sent_ids.append(m["id"]) + + collected = [] + cursor = None + while True: + params = {"limit": 2} + if cursor: + params["cursor"] = cursor + r = c.get( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + params=params, + headers=_auth(alice), + ) + assert r.status_code == 200, r.text + page = r.json() + collected.extend(m["id"] for m in page["items"]) + cursor = page["next_cursor"] + if not cursor: + break + assert collected == sent_ids + + +def test_wrong_password_returns_401(): + with httpx.Client() as c: + actor = _register_and_login(c) + bad = base64.b64encode( + (actor["username"] + ":wrong-password-1234").encode("utf-8") + ).decode("ascii") + r = c.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + bad}, + ) + assert r.status_code == 401 + assert "WWW-Authenticate" in r.headers + assert r.headers["WWW-Authenticate"].lower().startswith("basic") + + +def test_logout_invalidates_token(): + with httpx.Client() as c: + actor = _register_and_login(c) + r = c.delete( + f"{BASE}/api/v1/auth/sessions/current", + headers=_auth(actor), + ) + assert r.status_code == 204 + r = c.get(f"{BASE}/api/v1/users/me", headers=_auth(actor)) + assert r.status_code == 401 + + +def test_x_user_id_ignored_with_bearer(): + with httpx.Client() as c: + alice = _register_and_login(c) + bob = _register_and_login(c) + r = c.get( + f"{BASE}/api/v1/users/me", + headers={ + "Authorization": "Bearer " + alice["token"], + "X-User-Id": bob["id"], + }, + ) + assert r.status_code == 200 + assert r.json()["id"] == alice["id"] + + +def test_basic_on_business_endpoint_returns_401(): + with httpx.Client() as c: + actor = _register_and_login(c) + credential = base64.b64encode( + (actor["username"] + ":" + actor["password"]).encode("utf-8") + ).decode("ascii") + r = c.get( + f"{BASE}/api/v1/users/me", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 401 + + +def test_race_duplicate_username_only_one_wins(): + from concurrent.futures import ThreadPoolExecutor + + username = "race_" + uuid.uuid4().hex[:10] + password = "Test-password-1234" + + def register(): + with httpx.Client(timeout=10) as c: + return c.post( + f"{BASE}/api/v1/users", + json={ + "username": username, + "display_name": "Race", + "password": password, + }, + ).status_code + + with ThreadPoolExecutor(max_workers=2) as pool: + statuses = list(pool.map(lambda _: register(), range(2))) + + assert sorted(statuses) == [201, 409], f"got statuses {statuses}" + + credential = base64.b64encode( + (username + ":" + password).encode("utf-8") + ).decode("ascii") + with httpx.Client() as c: + r = c.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201 + assert r.json()["user"]["username"] == username + + +def test_rollback_chat_with_unknown_member(): + with httpx.Client() as c: + alice = _register_and_login(c) + fake_id = str(uuid.uuid4()) + r = c.post( + f"{BASE}/api/v1/chats", + json={ + "title": "Не должно создаться", + "member_ids": [alice["id"], fake_id], + }, + headers=_auth(alice), + ) + assert r.status_code == 400, r.text + + chats = c.get( + f"{BASE}/api/v1/chats?limit=100", + headers=_auth(alice), + ).json() + titles = [ch["title"] for ch in chats["items"]] + assert "Не должно создаться" not in titles \ No newline at end of file diff --git a/student-tests/test_worker_crash.py b/student-tests/test_worker_crash.py new file mode 100644 index 0000000..407c26e --- /dev/null +++ b/student-tests/test_worker_crash.py @@ -0,0 +1,100 @@ +import base64 +import io +import subprocess +import time +import uuid + +import httpx +from PIL import Image + +BASE = "http://localhost:8080" +COMPOSE = ["docker", "compose", "--env-file", ".env"] + + +def _user(c): + u = "crash_" + uuid.uuid4().hex[:10] + p = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={"username": u, "display_name": "C", "password": p}) + cred = base64.b64encode(f"{u}:{p}".encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}).json() + return {"id": s["user"]["id"], "token": s["token"]} + + +def _auth(a): + return {"Authorization": "Bearer " + a["token"]} + + +def _png(): + buf = io.BytesIO() + Image.new("RGB", (320, 200), (0, 128, 255)).save(buf, format="PNG") + return buf.getvalue() + + +def _wait_ready(c, att_id, token, timeout=60): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + r = c.get(f"{BASE}/api/v1/attachments/{att_id}", headers=_auth({"token": token})) + if r.status_code == 200 and r.json()["status"] == "ready": + return r.json() + time.sleep(0.5) + raise AssertionError("attachment did not become ready") + + +def _delete_variant(chat_id, att_id, name): + key = f"{name}s/{chat_id}/{att_id}.jpg" + script = "from app.s3 import s3\ns3.remove('" + key + "')\nprint('removed')\n" + subprocess.run( + COMPOSE + ["exec", "-T", "worker", "python", "-c", script], + check=True, + ) + + +def test_worker_recovers_after_ack_lost(): + with httpx.Client(timeout=30) as c: + a = _user(c) + b = _user(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "crash", "member_ids": [a["id"], b["id"]]}, + headers=_auth(a), + ).json() + data = _png() + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/attachments", + params={"filename": "c.png"}, + content=data, + headers={**_auth(a), "Content-Type": "image/png"}, + ) + assert r.status_code == 202, r.text + att = r.json() + att_id = att["id"] + + _wait_ready(c, att_id, a["token"]) + before = c.get(f"{BASE}/api/v1/attachments/{att_id}", headers=_auth(a)).json() + thumb1 = c.get( + f"{BASE}/api/v1/attachments/{att_id}/content?variant=thumbnail", + headers=_auth(a), + ) + assert thumb1.status_code == 200 + + _delete_variant(chat["id"], att_id, "thumbnail") + + subprocess.run( + COMPOSE + ["exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-c", + f"UPDATE attachments SET status='failed', error_code='ack_lost' WHERE id='{att_id}'"], + check=True, + ) + + r = c.post( + f"{BASE}/api/v1/attachments/{att_id}/replay", + headers=_auth(a), + ) + assert r.status_code == 202, r.text + + ready = _wait_ready(c, att_id, a["token"]) + thumb2 = c.get( + f"{BASE}/api/v1/attachments/{att_id}/content?variant=thumbnail", + headers=_auth(a), + ) + assert thumb2.status_code == 200 + assert ready["variants"] == before["variants"], "variants changed after replay" \ No newline at end of file