diff --git a/.dockerignore b/.dockerignore index bc16e556..11aa4498 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,14 @@ __pycache__ node_modules evidence .DS_Store +assets +contracts +examples +scripts +tests +*.md +Makefile +lab.json +requirements-dev.txt +Dockerfile* +.dockerignore diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..e9de8337 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,22 @@ +FROM golang:1.27.1-alpine3.24 AS build +WORKDIR /src +COPY go.mod go.sum ./ +RUN go mod download +COPY cmd ./cmd +COPY internal ./internal +RUN CGO_ENABLED=0 go build -trimpath -o /out/server ./cmd/server \ + && CGO_ENABLED=0 go build -trimpath -o /out/s3-init ./cmd/s3-init \ + && CGO_ENABLED=0 go build -trimpath -o /out/reconcile ./cmd/reconcile \ + && CGO_ENABLED=0 go build -trimpath -o /out/s3tool ./cmd/s3tool + +FROM alpine:3.24.1 +ARG BUILD_ID=dev +LABEL org.opencontainers.image.revision=$BUILD_ID +RUN adduser -D -H -u 10001 app +COPY --from=build /out/server /out/s3-init /out/reconcile /out/s3tool /usr/local/bin/ +USER app +ENV APP_HOST=0.0.0.0 APP_PORT=8080 +EXPOSE 8080 +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD wget -q -O /dev/null "http://127.0.0.1:${APP_PORT}/health/ready" || exit 1 +ENTRYPOINT ["/usr/local/bin/server"] \ No newline at end of file diff --git a/Makefile b/Makefile index 5d86d171..7b08dd6d 100644 --- a/Makefile +++ b/Makefile @@ -2,12 +2,23 @@ PYTHON ?= python3 BASE_URL ?= http://localhost:8080 CA_FILE ?= ACTION_SCRIPT ?= +ENGINE ?= $(shell command -v podman >/dev/null 2>&1 && echo podman || echo docker) +COMPOSE ?= $(if $(filter podman,$(ENGINE)),podman-compose,docker compose) +TEST_DATABASE_URL ?= $(shell sed 's/@postgres:5432/@127.0.0.1:55432/' secrets/database_url 2>/dev/null) +TEST_REDIS_URL ?= redis://127.0.0.1:56379/0 TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help up down check validate test load test-persistence test-failover test-idempotency test-attachments test-contract test-memory test-cost test-reconcile test-go help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "up/down: start/stop the stand, volumes kept; test-idempotency: one key in parallel via LB; test-attachments: attachment contract checks; test-memory: concurrent upload memory; test-cost: reconciler traversal cost; test-reconcile: reconciler dry-run; test-go: Go tests against the running stand" + +up: + $(COMPOSE) up -d --build + +down: + $(COMPOSE) down check: $(PYTHON) scripts/check_contract.py @@ -28,3 +39,25 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +test-idempotency: + BASE_URL="$(BASE_URL)" $(PYTHON) scripts/idempotency-race.py + +test-attachments: + BASE_URL="$(BASE_URL)" $(PYTHON) scripts/attachments-check.py + +test-contract: + BASE_URL="$(BASE_URL)" $(PYTHON) scripts/contract-audit.py + +test-memory: + BASE_URL="$(BASE_URL)" $(PYTHON) scripts/upload-load.py --concurrency 10 --output evidence/upload-memory.json + +test-cost: + $(PYTHON) scripts/track2-cost.py + +test-reconcile: + scripts/reconcile.sh -grace 0s + +test-go: + @TEST_DATABASE_URL="$(TEST_DATABASE_URL)" TEST_REDIS_URL="$(TEST_REDIS_URL)" go test -count=1 -v ./... + diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..b9c82827 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,183 @@ # Отчёт — лабораторная 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Спесивцев Даниил, БПИ2301 +- Целевая оценка: 5, трек 2 — согласованность двух хранилищ +- Commit/PR: commit 60e8f4474b9f635acbbc4920ff04c7901431acda +- Использованные источники, библиотеки и помощь ИИ: Go 1.27, стандартная библиотека и перечисленные ниже модули; S3 API и MinIO-совместимая семантика — по документации AWS и RustFS. При подготовке решения и текста отчёта использовались LLM; все команды и результаты в отчёте воспроизведены на локальном стенде. + +Библиотеки и компоненты: + +| Компонент | Версия | Назначение | +| --- | --- | --- | +| go-chi/chi | v5.3.2 | HTTP-роутинг и middleware | +| jackc/pgx | v5.11.0 | PostgreSQL, пул `pgxpool`, транзакции | +| redis/go-redis | v9.23.0 | общие сессии | +| golang.org/x/crypto | v0.58.0 | Argon2id | +| minio/minio-go | v7.4.1 | S3-клиент (API и операторские утилиты) | +| minio/madmin-go | v3.0.110 | идемпотентный bootstrap пользователя и политики | +| migrate/migrate | v4.20.1 (образ) | однократные миграции | +| HAProxy | 3.4.7-alpine (образ) | единая точка входа | ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Стенд: i5-11400H (12 потоков), 15 GiB RAM, Linux 7.3.5, podman 6.2.0 + podman-compose 1.6.0 (`evidence/env.txt`). Образы закреплены тегами: `rustfs/rustfs:1.0.6`, `postgres:18.6-alpine3.24`, `redis:8.10.3-alpine3.23`, `haproxy:3.4.7-alpine`, `migrate/migrate:v4.20.1`, сборка API — `golang:1.27.1-alpine3.24` → `alpine:3.24.1`. + +```sh +scripts/init-secrets.sh +make up +until curl -sf http://localhost:8080/health/ready; do sleep 1; done + +make check +make validate PYTHON=.venv/bin/python +make test +make test-attachments +make test-contract +make test-memory +make test-cost +make test-reconcile +make test-go +make test-idempotency +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh + +scripts/reconcile.sh # dry-run, grace 1h +scripts/reconcile.sh -grace 0s -dry-run=false + +make down # остановка, volumes сохраняются +podman-compose down -v # намеренное удаление учебных данных +``` + +Движок выбирается так же, как в lab3: `ENGINE=podman`/`COMPOSE=podman-compose` при наличии podman, иначе docker. `compose.yaml` проходит `docker compose config --quiet` и `podman-compose config`. + +`scripts/init-secrets.sh` создаёт локальные файлы секретов, повторный запуск их не перезаписывает (проверено хэшами, `evidence/credentials.txt`). Bootstrap S3 (`s3-init`) идемпотентен и запускается один раз перед API. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +client → lb (HAProxy :8080) ──edge──▶ api ×2 ──backend──▶ postgres (метаданные, источник истины) + ├────────▶ rustfs (байты, приватный bucket) + └────────▶ redis (сессии) + +migrate (one-shot) ─▶ postgres +s3-init (one-shot) ─▶ rustfs: bucket + policy + app user +reconcile (операторский запуск) ─▶ rustfs + postgres +``` + +| Роль | Service | Образ | Health/readiness | Volume | Сеть / порты | Credentials | +| --- | --- | --- | --- | --- | --- | --- | +| LB | `lb` | `haproxy:3.4.7-alpine` | активная проверка `/health/ready` | — | edge, публикует `8080` | нет | +| API | `api` ×2 | `localhost/messenger-api:lab4` | `/health/live`; `/health/ready` = PostgreSQL + Redis + S3 + не draining | — | edge + backend, порт не публикуется | `database_url`, `cache_url`, app-креды S3 | +| БД | `postgres` | `postgres:18.6-alpine3.24` | `pg_isready` | `pgdata` | backend, `127.0.0.1:55432` для `make test-go` | `postgres_password` | +| Сессии | `redis` | `redis:8.10.3-alpine3.23` | `redis-cli ping` | `redisdata` (AOF) | backend, `127.0.0.1:56379` | нет | +| S3 | `s3` | `rustfs/rustfs:1.0.6` | `GET /health` | `s3data` | backend, порт 9000 не публикуется, консоль отключена | root-креды | +| Bootstrap | `s3-init` | тот же образ | exit 0 | — | backend | root + app креды | +| Миграции | `migrate` | `migrate/migrate:v4.20.1` | exit 0 | SQL read-only | backend | `database_url` | + +Ключевые решения: + +- **Хранилище.** Выбран RustFS: MinIO-совместимый S3, публично доступный образ с обычным semver-тегом (`1.0.6`). MinIO community-образы на момент работы не отдаются ни Docker Hub, ни Quay (проверено), поэтому закреплять их тег было бы невоспроизводимо. +- **Разделение данных.** В PostgreSQL только метаданные и связи; байты — в приватном bucket. Ключ объекта `chats/{chat_id}/{attachment_id}` генерирует сервер, `filename` — только для отображения. В таблице `attachments` нет бинарных колонок (`evidence/storage.txt`). +- **Порядок записи.** `PUT` в S3 → транзакция PostgreSQL (метаданные + ключ идемпотентности + связи). При ошибке БД выполняется компенсирующий `DELETE`; если и он не удался — объект остаётся и снимается reconciler'ом после grace period. +- **Креды.** API работает отдельным S3-пользователем с политикой `ListBucket`/`GetBucketLocation` на bucket и `GetObject`/`PutObject`/`DeleteObject` на объекты. Root-креды смонтированы только в `s3` и `s3-init`; удаление bucket app-кредами запрещено (`Access Denied`). +- **Ограничение RAM.** Тело ограничено 10 MiB и читается потоково в буфер; до полной распаковки проверяются формат (`image.DecodeConfig`) и лимит 40 млн пикселей; полное декодирование идёт под семафором (`MAX_CONCURRENT_DECODES=1`), общая параллельность загрузок — `MAX_CONCURRENT_UPLOADS=8`. Один декод 40-мегапиксельного PNG — самая дорогая операция, поэтому верхняя граница памяти детерминирована. +- **Идемпотентность сообщений.** Ключ, сообщение и связи `message_attachments` пишутся одной транзакцией; в хэш входят `text` и канонизированный (отсортированный) набор `attachment_ids`, отсутствие поля эквивалентно `[]`. +- **Reconciler.** Сверяет объекты S3 (по префиксу) со строками `attachments`. Orphan-объект удаляется только если он старше grace period и на него нет строки метаданных. «Мёртвая» строка метаданных (объект отсутствует) удаляется, только если сообщения на неё не ссылаются; используемая строка сохраняется и попадает в отчёт, потому что восстановить утраченные байты нельзя, а удаление нарушило бы историю. +- **Соответствие `.env.example`.** `SESSION_STORE=postgres` в примере, фактически используются Redis-сессии из lab3 (контракт допускает оба варианта); `S3_ACCESS_KEY_ID_FILE`/`S3_SECRET_ACCESS_KEY_FILE` указывают на app-креды; `MAX_UPLOAD_BYTES`/`MAX_IMAGE_PIXELS` передаются в API; `API_REPLICAS` → `scale`; `IDEMPOTENCY_TTL_SECONDS` не используется — ключи хранятся бессрочно. + +Таймауты: PostgreSQL `statement_timeout` 5 s / connect 3 s; readiness-ping 1 s; HTTP-сервер 5/15/15/60 s; HAProxy connect/server/check 2/20/1 s; graceful shutdown: drain 3 s + `Shutdown` 5 s при `stop_grace_period: 10s`. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий | Команда/сценарий | Наблюдаемый результат | Файл | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `make test` | PASS | `evidence/smoke.txt` | +| Контракт вложений и сообщений | `make test-attachments` | 23/23 проверки | `evidence/negative.txt` | +| Аудит краевых случаев контракта | `make test-contract` | 30/30 проверки | `evidence/contract-audit.txt` | +| Полная OpenAPI-валидация | `make validate PYTHON=.venv/bin/python` | PASS | вывод команды | +| Собственные Go-тесты | `make test-go` | 26 PASS | `evidence/test-go.txt` | +| ≥2 реплики, одна точка входа, `X-Instance-Id` | `make up`, 20 запросов через LB | 10/10 на каждую реплику, публикует только `lb` | `evidence/instances.txt` | +| S3 в стенде, приватный bucket, постоянный volume | анонимный GET и listing | 403, порт наружу не публикуется | `evidence/private-bucket.txt` | +| Метаданные в PostgreSQL, байты в S3 | `psql`, листинг volume | в таблице нет бинарных колонок, объект лежит в `s3data` | `evidence/storage.txt` | +| `201 ready` после S3 и БД; скачивание байт-в-байт | `make test` | SHA-256 и размер совпадают | `evidence/smoke.txt` | +| Доступ только участникам (404 постороннему) | `make test`, `make test-attachments` | 404 для metadata и content | `evidence/smoke.txt`, `evidence/negative.txt` | +| Ограничения 10 MiB / 40 млн пикселей / MIME / filename | `make test-attachments` | 413, 415, 400; PNG ровно 40 000 000 px принят | `evidence/negative.txt` | +| Ошибки пользователя не превращаются в 500 | `make test-attachments` | только 400/404/409/413/415 | `evidence/negative.txt` | +| Upload → остановка реплики → download через другую | `make test-failover` ×2 | 0 ошибок, восстановление 3.19–3.32 s | `evidence/failover-1.txt`, `evidence/failover-2.txt` | +| Restart с volumes сохраняет метаданные и оригинал | `make test-persistence` | PASS, контейнеры перезапущены, volumes те же | `evidence/persistence.txt` | +| Идемпотентность сообщений через разные реплики | `make test-idempotency` | 20 запросов → одно сообщение, обе реплики | `evidence/idempotency-race.txt` | +| Миграции отдельным контейнером | `make up` | версия 3, `dirty=f`, повторный запуск — `no change` | `evidence/migrate.txt` | +| Лимиты и секреты по ролям | `inspect`, `ls /run/secrets` | лимиты у всех сервисов, секреты только у нужных ролей | `evidence/limits.txt` | +| Недоступность S3 | `/health/live` 200, `/health/ready` 503, клиент через LB получает 503 | `evidence/s3-outage.txt` | +| Ограничение памяти, ≥10 параллельных загрузок | `make test-memory` | пик 333 МБ при лимите 512 МБ, 10/10 успешно | `evidence/memory.txt`, `evidence/upload-memory.json` | +| Отказ между S3 и БД не оставляет объектов | инъекция отказа вставки + `reconcile` | 503, число объектов не изменилось | `evidence/compensation.txt` | +| Идемпотентный bootstrap | `s3-init` дважды | одинаковый результат | `evidence/credentials.txt` | +| Ограниченные креды API | удаление bucket app-кредами | `Access Denied` | `evidence/credentials.txt` | +| Трек 2: reconciler, инъекции с обеих сторон | `scripts/reconcile.sh`, `scripts/s3tool.sh` | детекция и безопасный ремонт | `evidence/track2-injection.txt` | +| Трек 2: dry-run и повторный запуск | `-dry-run`, повтор `-dry-run=false` | второй прогон ничего не меняет | `evidence/reconcile.txt`, `evidence/track2-injection.txt` | +| Трек 2: свежие и используемые не удаляются | apply с grace 1h | свежий объект и используемое вложение целы | `evidence/track2-injection.txt` | +| Трек 2: стоимость обхода | `make test-cost` | 0.033–0.09 мс/объект, 1 LIST-страница на 1000 | `evidence/track2-cost.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### Память при загрузках -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +Гипотеза: лимиты тела и пикселей вместе с семафором декодирования не дают одной загрузке занять неограниченную память. + +Методика: 10 одновременных загрузок PNG 8000×5000 (40 000 000 пикселей, 126 609 байт) на реплику, лимит API 512 MiB, `MAX_CONCURRENT_UPLOADS=8`, `MAX_CONCURRENT_DECODES=1`; пик снимался через `/sys/fs/cgroup/memory.peak` после пересоздания реплик. + +Результат: 10/10 успешно, 1.01 s, p50 613 мс, p95 1040 мс, пик **333 МБ** на реплику (65 % лимита). При `MAX_CONCURRENT_DECODES=2` пик упирался в лимит 512 МБ, поэтому значение по умолчанию — 1. + +### Стоимость обхода (трек 2) + +| Объектов | Скан | S3-запросов (LIST) | DB-запросов | мс/объект | Ремонт (удаление) | +| --- | --- | --- | --- | --- | --- | +| 100 | 9 мс | 1 | 2 | 0.09 | 1.3 s (100 DELETE) | +| 1000 | 34 мс | 1 | 2 | 0.034 | 12.2 s (1000 DELETE) | +| 5000 | 166 мс | 5 | 2 | 0.033 | 69.9 s (5000 DELETE) | + +Скан линеен по числу объектов и страниц LIST (1000 на страницу), число обращений к БД постоянно. Ремонт доминируется последовательными DELETE — это осознанное упрощение, возможное улучшение — пакетное или параллельное удаление. + +### Инъекции и восстановление + +| Воздействие | Ожидание | Наблюдение | +| --- | --- | --- | +| Отказ вставки метаданных после успешного `PUT` | объект удаляется компенсацией, ответ 503 | число объектов не изменилось, после снятия инъекции загрузка снова 201 | +| Объект без метаданных (свежий) | не удаляется в пределах grace | при `-grace 1h` `deleted_objects=0`, объект на месте | +| Объект без метаданных (старше grace) | удаляется | `-grace 0s` → `deleted_objects=1`, повторный прогон — 0 | +| Метаданные без объекта, сообщение не ссылается | строка удаляется | `deleted_metadata=1` | +| Метаданные без объекта, сообщение ссылается | строка сохраняется, попадает в отчёт | `retained_missing=1`, строка в БД остаётся | +| Остановка реплики под нагрузкой | без потери подтверждённых данных | 85–100 успешных записей, 0 ошибок | +| Перезапуск всех сервисов | данные и токен сохраняются | PASS, volumes не тронуты | +| Недоступность S3 | `/health/live` 200, `/health/ready` 503, восстановление | 200 / 503 / 200 | + +## Аудит контракта и спорные места + +Краевые случаи проверяются отдельным сьютом `make test-contract` (`scripts/contract-audit.py`, 30 проверок, `evidence/contract-audit.txt`). Аудит выявил три места, где реализация была мягче контракта; они исправлены: + +| Место | Было | Стало | Основание | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `attachment_ids: null` | принималось как отсутствие поля | `400` | схема: поле — массив; «неверные типы — 400» | +| `?variant=` (пустое значение) | считалось `original` | `400` | «в lab4 допустим только `original`»; отсутствие параметра — отдельный случай | +| `filename` из одних пробелов | принималось | `400` | «обязательные строки не состоят только из пробельных символов» | + +Решения по остальным неоднозначностям: + +- `Content-Type` с параметрами (`image/png; charset=utf-8`) принимается: сравнивается медиатип, параметры не влияют. +- Порядок проверок загрузки: `Content-Type` (415) → размер тела (413) → MIME по содержимому (415) → лимит пикселей (413) → целостность (415). Если нарушено несколько правил, возвращается первая сработавшая проверка; контракт приоритет не задаёт. +- Пустой или пробельный `text` разрешён только с вложениями (`anyOf` в схеме); без вложений — `400`. +- `variant` проверяется до проверки членства: посторонний с неизвестным вариантом получает `400`, а не `404`. Существование чужого объекта это не раскрывает: для любого `id` ответ одинаков. +- Ключи идемпотентности хранятся бессрочно; контракт требует лишь повтор «в течение 24 часов». +- Неподдерживаемый HTTP-метод на известном пути даёт `405` с кодом `invalid_request` — контракт этот код не описывает, поведение выбрано явно. +- `429 rate_limited` есть в перечислении кодов, но rate limiting не входит в обязательный минимум и не реализован. +- Cursor привязан к ресурсу: курсор истории чата на списке чатов и наоборот даёт `400` (проверяется аудитом). +- S3 включён в readiness. Пока объектное хранилище недоступно, реплики выводятся из балансировщика и клиент получает `503` на любой запрос, включая текстовые сообщения; так гарантируется, что обязательный синхронный путь (сообщения с вложениями) не обслуживается частично. `/health/live` при этом остаётся `200` (`evidence/s3-outage.txt`). +- Валидация выполняется до проверки доступа только там, где это не раскрывает существование объекта; порядок «сначала аутентификация, затем ресурс» в middleware сохранён. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Один Docker-host: отказ host, единственного PostgreSQL и единственного LB не выдерживается. Проверен только отказ одной API-реплики. +- Reconciler — операторская утилита, запускается вручную; расписания и фонового worker'а нет (это уже тема lab5). Удаление объектов последовательное. +- Если объект утрачен, но на него ссылается сообщение, автоматический ремонт невозможен: байты не восстановить, а удаление строки нарушило бы историю. Такие случаи остаются в отчёте reconciler'а и требуют решения оператора. В демонстрационном наборе данных есть одно такое вложение — оно появилось в результате учения и остаётся видимым в `missing`. +- Тело загрузки буферизуется в память: верхняя граница — `MAX_CONCURRENT_UPLOADS × MAX_UPLOAD_BYTES` (по умолчанию 80 MiB) плюс один декод. +- Нет ограничения частоты запросов, TLS/mTLS, асинхронной обработки и вариантов изображений — это следующие лабораторные. +- `filename` хранится как отображаемое имя и не используется в ключах; санитизация ограничена контролем недопустимых символов. diff --git a/cmd/reconcile/main.go b/cmd/reconcile/main.go new file mode 100644 index 00000000..5ad1d1d6 --- /dev/null +++ b/cmd/reconcile/main.go @@ -0,0 +1,216 @@ +package main + +import ( + "context" + "encoding/json" + "flag" + "fmt" + "net/http" + "os" + "sync/atomic" + "time" + "uuid" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "messenger/internal/config" + "messenger/internal/reconcile" + "messenger/internal/repository/postgres" + "messenger/internal/repository/s3" +) + +type countingTransport struct { + base http.RoundTripper + count atomic.Int64 +} + +func (t *countingTransport) RoundTrip(request *http.Request) (*http.Response, error) { + t.count.Add(1) + return t.base.RoundTrip(request) +} + +func main() { + dryRun := flag.Bool("dry-run", true, "report only, do not delete or repair anything") + grace := flag.Duration("grace", time.Hour, "minimum object age before it can be deleted") + prefix := flag.String("prefix", "chats/", "object key prefix to scan") + limit := flag.Int("limit", 10000, "maximum number of objects to scan") + repairMissing := flag.Bool("repair-missing", true, "delete metadata rows whose object is gone and that no message references") + flag.Parse() + + if err := run(*dryRun, *grace, *prefix, *limit, *repairMissing); err != nil { + fmt.Fprintln(os.Stderr, "reconcile failed:", err) + os.Exit(1) + } +} + +func run(dryRun bool, grace time.Duration, prefix string, limit int, repairMissing bool) error { + if grace < 0 { + return fmt.Errorf("grace must not be negative") + } + if limit <= 0 { + return fmt.Errorf("limit must be positive") + } + started := time.Now() + + endpoint := getenv("S3_ENDPOINT", "http://s3:9000") + region := getenv("S3_REGION", "us-east-1") + bucket := getenv("S3_BUCKET", "messenger-attachments") + accessKeyID, err := config.ReadSecret("S3_ACCESS_KEY_ID_FILE", "/run/secrets/s3_access_key_id") + if err != nil { + return err + } + secretAccessKey, err := config.ReadSecret("S3_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_secret_access_key") + if err != nil { + return err + } + databaseURL, err := config.ReadSecret("DATABASE_URL_FILE", "/run/secrets/database_url") + if err != nil { + return err + } + + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute) + defer cancel() + + transport := &countingTransport{base: http.DefaultTransport} + store, err := s3.NewWithTransport(endpoint, region, accessKeyID, secretAccessKey, bucket, transport) + if err != nil { + return err + } + scanned, truncated, err := store.List(ctx, prefix, limit) + if err != nil { + return err + } + + pool, err := postgres.NewPool(ctx, databaseURL) + if err != nil { + return err + } + defer pool.Close() + + rows, err := loadMetadata(ctx, pool) + if err != nil { + return err + } + referenced, err := loadReferences(ctx, pool) + if err != nil { + return err + } + + orphans, missing := reconcile.Plan(toObjects(scanned), rows, referenced, prefix, time.Now(), grace) + if truncated { + missing = nil + } + + report := reconcile.Report{ + Prefix: prefix, + GraceSeconds: int64(grace.Seconds()), + DryRun: dryRun, + ScannedObjects: len(scanned), + ScannedRows: len(rows), + Truncated: truncated, + Orphans: orphans, + Missing: missing, + } + dbQueries := 2 + + if !dryRun { + for _, orphan := range orphans { + if err := store.Delete(ctx, orphan.Key); err != nil { + report.DeleteFailures++ + continue + } + report.DeletedObjects++ + } + if repairMissing { + for _, item := range missing { + if item.Referenced { + report.RetainedMissing++ + continue + } + id, err := uuid.Parse(item.ID) + if err != nil { + report.DeleteFailures++ + continue + } + tag, err := pool.Exec(ctx, `DELETE FROM attachments WHERE id = $1`, id) + dbQueries++ + if err != nil { + report.DeleteFailures++ + continue + } + report.DeletedMetadata += int(tag.RowsAffected()) + } + } else { + for _, item := range missing { + if item.Referenced { + report.RetainedMissing++ + } + } + } + } + + report.S3Requests = transport.count.Load() + report.DBQueries = dbQueries + report.DurationMS = time.Since(started).Milliseconds() + if report.DurationMS > 0 { + report.ObjectsPerSecond = float64(report.ScannedObjects) / (float64(report.DurationMS) / 1000) + } + + encoder := json.NewEncoder(os.Stdout) + encoder.SetIndent("", " ") + if err := encoder.Encode(report); err != nil { + return err + } + if report.DeleteFailures > 0 { + return fmt.Errorf("%d repair operations failed", report.DeleteFailures) + } + return nil +} + +func loadMetadata(ctx context.Context, pool *pgxpool.Pool) ([]reconcile.Metadata, error) { + rows, err := pool.Query(ctx, `SELECT id, object_key, chat_id, created_at FROM attachments`) + if err != nil { + return nil, err + } + return pgx.CollectRows(rows, func(row pgx.CollectableRow) (reconcile.Metadata, error) { + var metadata reconcile.Metadata + err := row.Scan(&metadata.ID, &metadata.ObjectKey, &metadata.ChatID, &metadata.CreatedAt) + return metadata, err + }) +} + +func loadReferences(ctx context.Context, pool *pgxpool.Pool) (map[uuid.UUID]bool, error) { + rows, err := pool.Query(ctx, `SELECT DISTINCT attachment_id FROM message_attachments`) + if err != nil { + return nil, err + } + ids, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (uuid.UUID, error) { + var id uuid.UUID + err := row.Scan(&id) + return id, err + }) + if err != nil { + return nil, err + } + referenced := make(map[uuid.UUID]bool, len(ids)) + for _, id := range ids { + referenced[id] = true + } + return referenced, nil +} + +func toObjects(scanned []s3.ObjectInfo) []reconcile.Object { + objects := make([]reconcile.Object, len(scanned)) + for i, info := range scanned { + objects[i] = reconcile.Object{Key: info.Key, Size: info.Size, LastModified: info.LastModified} + } + return objects +} + +func getenv(key, def string) string { + if value := os.Getenv(key); value != "" { + return value + } + return def +} diff --git a/cmd/s3-init/main.go b/cmd/s3-init/main.go new file mode 100644 index 00000000..0659e6fb --- /dev/null +++ b/cmd/s3-init/main.go @@ -0,0 +1,126 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "os" + "time" + + "github.com/minio/madmin-go/v3" + + "messenger/internal/config" + "messenger/internal/repository/s3" +) + +const policyName = "messenger-app" + +func main() { + if err := run(); err != nil { + fmt.Fprintln(os.Stderr, "s3-init failed:", err) + os.Exit(1) + } +} + +func run() error { + endpoint := getenv("S3_ENDPOINT", "http://s3:9000") + region := getenv("S3_REGION", "us-east-1") + bucket := getenv("S3_BUCKET", "messenger-attachments") + rootAccessKey, err := config.ReadSecret("S3_ROOT_ACCESS_KEY_ID_FILE", "/run/secrets/s3_root_access_key") + if err != nil { + return err + } + rootSecretKey, err := config.ReadSecret("S3_ROOT_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_root_secret_key") + if err != nil { + return err + } + appAccessKey, err := config.ReadSecret("S3_ACCESS_KEY_ID_FILE", "/run/secrets/s3_access_key_id") + if err != nil { + return err + } + appSecretKey, err := config.ReadSecret("S3_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_secret_access_key") + if err != nil { + return err + } + + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + + store, err := s3.New(endpoint, region, rootAccessKey, rootSecretKey, bucket) + if err != nil { + return err + } + if err := store.EnsureBucket(ctx); err != nil { + return err + } + fmt.Println("bucket ready:", bucket) + + policy, err := policyDocument(bucket) + if err != nil { + return err + } + host, secure := s3.EndpointHost(endpoint) + admin, err := madmin.New(host, rootAccessKey, rootSecretKey, secure) + if err != nil { + return err + } + if err := retry(ctx, func(ctx context.Context) error { return admin.AddCannedPolicy(ctx, policyName, policy) }); err != nil { + return err + } + fmt.Println("policy ready:", policyName) + if err := retry(ctx, func(ctx context.Context) error { + return admin.SetUser(ctx, appAccessKey, appSecretKey, madmin.AccountEnabled) + }); err != nil { + return err + } + fmt.Println("application credentials ready") + if err := retry(ctx, func(ctx context.Context) error { + _, err := admin.AttachPolicy(ctx, madmin.PolicyAssociationReq{Policies: []string{policyName}, User: appAccessKey}) + return err + }); err != nil { + return err + } + fmt.Println("policy attached to application credentials") + return nil +} + +func retry(ctx context.Context, fn func(context.Context) error) error { + var err error + for attempt := 1; attempt <= 12; attempt++ { + if err = fn(ctx); err == nil { + return nil + } + select { + case <-ctx.Done(): + return err + case <-time.After(time.Duration(attempt) * time.Second): + } + } + return err +} + +func policyDocument(bucket string) ([]byte, error) { + document := map[string]any{ + "Version": "2012-10-17", + "Statement": []map[string]any{ + { + "Effect": "Allow", + "Action": []string{"s3:ListBucket", "s3:GetBucketLocation"}, + "Resource": []string{"arn:aws:s3:::" + bucket}, + }, + { + "Effect": "Allow", + "Action": []string{"s3:GetObject", "s3:PutObject", "s3:DeleteObject"}, + "Resource": []string{"arn:aws:s3:::" + bucket + "/*"}, + }, + }, + } + return json.Marshal(document) +} + +func getenv(key, def string) string { + if value := os.Getenv(key); value != "" { + return value + } + return def +} diff --git a/cmd/s3tool/main.go b/cmd/s3tool/main.go new file mode 100644 index 00000000..55eb1347 --- /dev/null +++ b/cmd/s3tool/main.go @@ -0,0 +1,164 @@ +package main + +import ( + "bytes" + "context" + "fmt" + "io" + "os" + "strconv" + "sync" + "time" + + "messenger/internal/config" + "messenger/internal/repository/s3" +) + +func main() { + if len(os.Args) < 2 { + usage() + } + if err := run(os.Args[1], os.Args[2:]); err != nil { + fmt.Fprintln(os.Stderr, "s3tool failed:", err) + os.Exit(1) + } +} + +func run(command string, args []string) error { + store, err := newStore() + if err != nil { + return err + } + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) + defer cancel() + + switch command { + case "put": + if len(args) != 2 { + usage() + } + content, err := readContent(args[1]) + if err != nil { + return err + } + if err := store.Put(ctx, args[0], bytes.NewReader(content), int64(len(content)), "application/octet-stream"); err != nil { + return err + } + fmt.Printf("put %s (%d bytes)\n", args[0], len(content)) + case "delete": + if len(args) != 1 { + usage() + } + if err := store.Delete(ctx, args[0]); err != nil { + return err + } + fmt.Printf("deleted %s\n", args[0]) + case "list": + prefix := "" + if len(args) > 0 { + prefix = args[0] + } + objects, _, err := store.List(ctx, prefix, 1000) + if err != nil { + return err + } + for _, object := range objects { + fmt.Printf("%s\t%d\t%s\n", object.Key, object.Size, object.LastModified.UTC().Format(time.RFC3339)) + } + case "buckets": + buckets, err := store.Buckets(ctx) + if err != nil { + return err + } + for _, bucket := range buckets { + fmt.Println(bucket) + } + case "remove-bucket": + if len(args) != 1 { + usage() + } + if err := store.RemoveBucket(ctx, args[0]); err != nil { + return err + } + fmt.Printf("removed %s\n", args[0]) + case "seed": + if len(args) != 3 { + usage() + } + count, err := strconv.Atoi(args[1]) + if err != nil || count <= 0 { + return fmt.Errorf("count must be a positive integer") + } + size, err := strconv.Atoi(args[2]) + if err != nil || size <= 0 { + return fmt.Errorf("size must be a positive integer") + } + if err := seed(ctx, store, args[0], count, size); err != nil { + return err + } + fmt.Printf("seeded %d objects under %s\n", count, args[0]) + default: + usage() + } + return nil +} + +func readContent(source string) ([]byte, error) { + if source == "-" { + return io.ReadAll(os.Stdin) + } + return os.ReadFile(source) +} + +func newStore() (*s3.Store, error) { + accessKeyID, err := config.ReadSecret("S3_ACCESS_KEY_ID_FILE", "/run/secrets/s3_access_key_id") + if err != nil { + return nil, err + } + secretAccessKey, err := config.ReadSecret("S3_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_secret_access_key") + if err != nil { + return nil, err + } + return s3.New(getenv("S3_ENDPOINT", "http://s3:9000"), getenv("S3_REGION", "us-east-1"), + accessKeyID, secretAccessKey, getenv("S3_BUCKET", "messenger-attachments")) +} + +func seed(ctx context.Context, store *s3.Store, prefix string, count, size int) error { + content := make([]byte, size) + workers := 8 + work := make(chan int) + errors := make(chan error, workers) + var group sync.WaitGroup + for i := 0; i < workers; i++ { + group.Add(1) + go func() { + defer group.Done() + for index := range work { + key := fmt.Sprintf("%s/%06d", prefix, index) + if err := store.Put(ctx, key, bytes.NewReader(content), int64(size), "application/octet-stream"); err != nil { + errors <- err + return + } + } + }() + } + for index := 0; index < count; index++ { + work <- index + } + close(work) + group.Wait() + close(errors) + return <-errors +} + +func usage() { + fmt.Fprintln(os.Stderr, "usage: s3tool put | delete | list [prefix] | buckets | remove-bucket | seed ") + os.Exit(2) +} + +func getenv(key, def string) string { + if value := os.Getenv(key); value != "" { + return value + } + return def +} diff --git a/cmd/server/main.go b/cmd/server/main.go new file mode 100644 index 00000000..04c45a5d --- /dev/null +++ b/cmd/server/main.go @@ -0,0 +1,112 @@ +package main + +import ( + "context" + "errors" + "log/slog" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "messenger/internal/config" + "messenger/internal/handler" + "messenger/internal/repository/postgres" + "messenger/internal/repository/redis" + "messenger/internal/repository/s3" + "messenger/internal/router" + "messenger/internal/service" +) + +const ( + drainDelay = 3 * time.Second + shutdownTimeout = 5 * time.Second +) + +func main() { + log := slog.New(slog.NewJSONHandler(os.Stdout, nil)) + if err := run(log); err != nil { + log.Error("server failed", "err", err) + os.Exit(1) + } +} + +func run(log *slog.Logger) error { + cfg, err := config.Load() + if err != nil { + return err + } + + instanceID, err := os.Hostname() + if err != nil { + return err + } + + pool, err := postgres.NewPool(context.Background(), cfg.DatabaseURL) + if err != nil { + return err + } + defer pool.Close() + store := postgres.New(pool) + + redisClient, err := redis.NewClient(cfg.CacheURL) + if err != nil { + return err + } + defer redisClient.Close() + sessions := redis.NewSessionStore(redisClient) + + users := service.NewUserService(store) + auth := service.NewAuthService(store, sessions, cfg.SessionTTL) + chats := service.NewChatService(store) + messages := service.NewMessageService(chats, store) + + objects, err := s3.New(cfg.S3Endpoint, cfg.S3Region, cfg.S3AccessKeyID, cfg.S3SecretAccessKey, cfg.S3Bucket) + if err != nil { + return err + } + attachments := service.NewAttachmentService(chats, store, objects, cfg.MaxUploadBytes, cfg.MaxImagePixels, + cfg.MaxConcurrentUploads, cfg.MaxConcurrentDecodes) + + deps := []handler.Pinger{store.Ping, sessions.Ping, objects.Ping} + + h := handler.New(users, auth, chats, messages, attachments, deps, log) + srv := &http.Server{ + Addr: cfg.Addr(), + Handler: router.New(h, instanceID), + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 15 * time.Second, + IdleTimeout: 60 * time.Second, + } + + ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, os.Interrupt) + defer stop() + + errCh := make(chan error, 1) + go func() { + log.Info("starting server", "addr", srv.Addr, "instance_id", instanceID, "env", cfg.Env, "session_ttl", cfg.SessionTTL.String()) + if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- err + } + }() + + select { + case err := <-errCh: + return err + case <-ctx.Done(): + } + log.Info("shutdown signal received, draining", "drain", drainDelay.String(), "timeout", shutdownTimeout.String()) + h.StartDraining() + srv.SetKeepAlivesEnabled(false) + time.Sleep(drainDelay) + + shutdownCtx, cancel := context.WithTimeout(context.Background(), shutdownTimeout) + defer cancel() + if err := srv.Shutdown(shutdownCtx); err != nil { + return err + } + log.Info("server stopped") + return nil +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..2fe9b8a2 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,216 @@ +name: messenger-lab4 + +services: + postgres: + image: docker.io/library/postgres:18.6-alpine3.24 + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql + networks: + - backend + ports: + - "127.0.0.1:55432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 3s + retries: 30 + deploy: + resources: + limits: + cpus: "1.0" + memory: 512M + restart: unless-stopped + + redis: + image: docker.io/library/redis:8.10.3-alpine3.23 + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"] + volumes: + - redisdata:/data + networks: + - backend + ports: + - "127.0.0.1:56379:6379" + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 2s + timeout: 3s + retries: 30 + deploy: + resources: + limits: + cpus: "0.5" + memory: 128M + restart: unless-stopped + + s3: + image: docker.io/rustfs/rustfs:1.0.6 + environment: + RUSTFS_ACCESS_KEY_FILE: /run/secrets/s3_root_access_key + RUSTFS_SECRET_KEY_FILE: /run/secrets/s3_root_secret_key + RUSTFS_REGION: ${S3_REGION:-us-east-1} + RUSTFS_CONSOLE_ENABLE: "false" + RUSTFS_OBS_LOGGER_LEVEL: warn + secrets: + - s3_root_access_key + - s3_root_secret_key + volumes: + - s3data:/data + networks: + - backend + healthcheck: + test: ["CMD", "curl", "-f", "http://127.0.0.1:9000/health"] + interval: 2s + timeout: 3s + retries: 30 + deploy: + resources: + limits: + cpus: "1.0" + memory: 512M + restart: unless-stopped + + s3-init: + build: . + image: localhost/messenger-api:lab4 + entrypoint: ["/usr/local/bin/s3-init"] + environment: + S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000} + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ROOT_ACCESS_KEY_ID_FILE: /run/secrets/s3_root_access_key + S3_ROOT_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_root_secret_key + S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id + S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key + secrets: + - s3_root_access_key + - s3_root_secret_key + - s3_access_key_id + - s3_secret_access_key + networks: + - backend + depends_on: + s3: + condition: service_healthy + deploy: + resources: + limits: + cpus: "0.5" + memory: 256M + restart: "no" + + migrate: + image: docker.io/migrate/migrate:v4.20.1 + entrypoint: ["/bin/sh", "-c"] + command: ['migrate -path /migrations -database "$$(cat /run/secrets/database_url)" up'] + secrets: + - database_url + volumes: + - ./internal/repository/postgres/migrations:/migrations:ro + networks: + - backend + depends_on: + postgres: + condition: service_healthy + deploy: + resources: + limits: + cpus: "0.5" + memory: 64M + restart: "no" + + api: + build: . + image: localhost/messenger-api:lab4 + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000} + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${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: ${MAX_UPLOAD_BYTES:-10485760} + MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000} + MAX_CONCURRENT_UPLOADS: ${MAX_CONCURRENT_UPLOADS:-8} + MAX_CONCURRENT_DECODES: ${MAX_CONCURRENT_DECODES:-1} + secrets: + - database_url + - cache_url + - s3_access_key_id + - s3_secret_access_key + networks: + - edge + - backend + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/health/ready"] + interval: 5s + timeout: 2s + retries: 3 + start_period: 5s + stop_grace_period: 10s + scale: ${API_REPLICAS:-2} + deploy: + resources: + limits: + cpus: "1.0" + memory: 512M + depends_on: + migrate: + condition: service_completed_successfully + redis: + condition: service_healthy + s3: + condition: service_healthy + s3-init: + condition: service_completed_successfully + restart: unless-stopped + + lb: + image: docker.io/library/haproxy:3.4.7-alpine + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + networks: + - edge + ports: + - "8080:8080" + deploy: + resources: + limits: + cpus: "0.5" + memory: 64M + restart: unless-stopped + +networks: + edge: + backend: + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url + s3_root_access_key: + file: ./secrets/s3_root_access_key + s3_root_secret_key: + file: ./secrets/s3_root_secret_key + s3_access_key_id: + file: ./secrets/s3_access_key_id + s3_secret_access_key: + file: ./secrets/s3_secret_access_key + +volumes: + pgdata: + redisdata: + s3data: \ No newline at end of file diff --git a/evidence/attachments-check.txt b/evidence/attachments-check.txt new file mode 100644 index 00000000..f8c36d4b --- /dev/null +++ b/evidence/attachments-check.txt @@ -0,0 +1,28 @@ +2026-11-20T03:51:30+03:00 +make test-attachments + +BASE_URL="http://localhost:8080" python3 scripts/attachments-check.py +ok: upload 201 ready, sha256=99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75, size=111817 +ok: jpeg upload/download byte-identical; jpeg declared as png -> 415 +ok: png with 40,000,000 pixels accepted and downloaded byte-identical +ok: filename with slash -> 400 +ok: filename with NUL -> 400 +ok: empty filename -> 400 +ok: declared jpeg with png body -> 415 +ok: truncated png -> 415 +ok: 10485761 bytes -> 413 +ok: text/plain -> 415 +ok: unknown variant -> 400 +ok: variant=original -> 200 +ok: unknown attachment id -> 404 +ok: upload by outsider -> 404 +ok: attachment from another chat -> 404 +ok: unknown attachment id in message -> 404 +ok: duplicate attachment_ids -> 400 +ok: eleven attachment_ids -> 400 +ok: empty text without attachments -> 400 +ok: idempotent replay with same attachment set -> same message +ok: absent attachment_ids equals [] for idempotency +ok: same key with a different attachment set -> 409 +ok: history exposes attachment_ids on every message +PASS: 23 attachment contract checks diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 00000000..5a9f1da8 --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,5 @@ +2026-11-20T04:38:30+03:00 +make check + +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/compensation.txt b/evidence/compensation.txt new file mode 100644 index 00000000..014bd694 --- /dev/null +++ b/evidence/compensation.txt @@ -0,0 +1,79 @@ +2026-11-20T04:41:27+03:00 +failure between S3 write and database commit: an object must not stay unaccounted + +$ scripts/reconcile.sh # baseline +{ + "prefix": "chats/", + "grace_seconds": 3600, + "dry_run": true, + "scanned_objects": 17, + "scanned_rows": 17, + "truncated": false, + "orphans": [], + "missing": [], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 7, + "objects_per_second": 2428.5714285714284 +} + +$ podman exec -i postgres psql < scripts/sql/inject-db-failure.sql +CREATE FUNCTION +NOTICE: trigger "inject_attachment_insert_failure" for relation "attachments" does not exist, skipping +DROP TRIGGER +CREATE TRIGGER + +$ scripts/upload-once.py --expect 503 # insert fails after a successful S3 PUT +status=503 + +$ scripts/reconcile.sh # same object count: compensating DELETE removed the object +{ + "prefix": "chats/", + "grace_seconds": 3600, + "dry_run": true, + "scanned_objects": 17, + "scanned_rows": 17, + "truncated": false, + "orphans": [], + "missing": [], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 7, + "objects_per_second": 2428.5714285714284 +} + +$ podman exec -i postgres psql < scripts/sql/reset-db-failure.sql +DROP TRIGGER +DROP FUNCTION + +$ scripts/upload-once.py --expect 201 # service healthy again +status=201 +attachment=7dd89013-32f1-4732-a2fd-529fe2081bb8 size=653 + +$ scripts/reconcile.sh # one more accounted object +{ + "prefix": "chats/", + "grace_seconds": 3600, + "dry_run": true, + "scanned_objects": 18, + "scanned_rows": 18, + "truncated": false, + "orphans": [], + "missing": [], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 7, + "objects_per_second": 2571.4285714285716 +} diff --git a/evidence/contract-audit.txt b/evidence/contract-audit.txt new file mode 100644 index 00000000..7005e11f --- /dev/null +++ b/evidence/contract-audit.txt @@ -0,0 +1,35 @@ +2026-11-20T04:53:36+03:00 +make test-contract + +BASE_URL="http://localhost:8080" python3 scripts/contract-audit.py +ok: explicit attachment_ids=null is 400 +ok: empty variant is 400 +ok: whitespace-only filename is 400 +ok: Content-Type parameters are accepted +ok: 41,000,000 pixels is 413 +ok: text length bounds +ok: attachment count bounds +ok: duplicate attachment_ids is 400 +ok: idempotent replay with the same set +ok: absent and empty attachment_ids agree +ok: attachment from another chat is 404 +ok: unknown attachment id is 404 +ok: outsider access is 404 +ok: upload to unknown chat is 404 +ok: media errors are 415 +ok: oversize is 413 +ok: filename errors are 400 +ok: chat validation errors are 400 +ok: pagination errors are 400 +ok: idempotency errors +ok: null request fields are 400 +ok: more than 100 members is 400 +ok: user field validation +ok: missing Content-Type is 415 +ok: variant is case sensitive +ok: filename control characters are 400 +ok: chat title bounds +ok: cursor is bound to the endpoint +ok: 204 responses carry headers and no body +ok: download Content-Length matches the bytes +PASS: 30 checks diff --git a/evidence/credentials.txt b/evidence/credentials.txt new file mode 100644 index 00000000..ea758b38 --- /dev/null +++ b/evidence/credentials.txt @@ -0,0 +1,25 @@ +2026-11-20T04:43:58+03:00 +separate restricted S3 credentials for the API and idempotent bucket bootstrap + +$ podman-compose run --rm s3-init (first run) +bucket ready: messenger-attachments +policy ready: messenger-app +application credentials ready +policy attached to application credentials + +$ podman-compose run --rm s3-init (second run: idempotent) +bucket ready: messenger-attachments +policy ready: messenger-app +application credentials ready +policy attached to application credentials + +secret files mounted into api vs s3 (hashes differ) +api_1 app secret sha256: 02b5014e8a0f03ac52a0a32d19abe13cd0e64ad9a9c61f178e3eede9989c82ce +s3 root secret sha256: 970780881d80d85eb3f084c147c71e390fa563e0e022fa75cd8170d5a607cacc + +secrets per role +messenger-lab4_api_1: cache_url database_url s3_access_key_id s3_secret_access_key +messenger-lab4_s3_1: s3_root_access_key s3_root_secret_key + +$ scripts/s3tool.sh remove-bucket messenger-attachments (must be denied) +s3tool failed: dependency unavailable: Access Denied diff --git a/evidence/dataset.txt b/evidence/dataset.txt new file mode 100644 index 00000000..570dffc8 --- /dev/null +++ b/evidence/dataset.txt @@ -0,0 +1,7 @@ +2026-11-20T04:56:32+03:00 + + users | chats | messages | attachments | links | db_size +-------+-------+----------+-------------+-------+--------- + 125 | 43 | 634 | 101 | 56 | 8958 kB +(1 row) + diff --git a/evidence/env.txt b/evidence/env.txt new file mode 100644 index 00000000..828b6476 --- /dev/null +++ b/evidence/env.txt @@ -0,0 +1,19 @@ +2026-11-20T04:56:17+03:00 + +Linux archlinux 7.3.5-arch1-1 #1 SMP PREEMPT_DYNAMIC Tue, 17 Nov 2026 22:28:33 +0000 x86_64 GNU/Linux +12 + total used free shared buff/cache available +Mem: 15Gi 6.5Gi 3.6Gi 440Mi 5.8Gi 8.8Gi +Swap: 8.0Gi 187Mi 7.8Gi +podman version 6.2.0 +podman version 6.2.0 +podman-compose version 1.6.0 +go version go1.27.4-X:nodwarf5 linux/amd64 + +images +docker.io/library/haproxy:3.4.7-alpine 49c6afb26f02 +docker.io/library/postgres:18.6-alpine3.24 57b23a0326ee +docker.io/library/redis:8.10.3-alpine3.23 9722accf3e8e +docker.io/migrate/migrate:v4.20.1 719a6f5d0ade +docker.io/rustfs/rustfs:1.0.6 7cd1c573d76d +localhost/messenger-api:lab4 4c57d3f41dfb diff --git a/evidence/failover-1.txt b/evidence/failover-1.txt new file mode 100644 index 00000000..e7d810a1 --- /dev/null +++ b/evidence/failover-1.txt @@ -0,0 +1,7 @@ +2026-11-20T04:55:04+03:00 +make test-failover ACTION_SCRIPT=scripts/stop-one.sh + +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 88, "failed_attempts": 0, "first_recovery_seconds": 3.256} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/failover-2.txt b/evidence/failover-2.txt new file mode 100644 index 00000000..ecec6f64 --- /dev/null +++ b/evidence/failover-2.txt @@ -0,0 +1,7 @@ +2026-11-20T04:55:38+03:00 +make test-failover ACTION_SCRIPT=scripts/stop-one.sh + +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 99, "failed_attempts": 0, "first_recovery_seconds": 3.236} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/idempotency-race.txt b/evidence/idempotency-race.txt new file mode 100644 index 00000000..c9f24b29 --- /dev/null +++ b/evidence/idempotency-race.txt @@ -0,0 +1,11 @@ +2026-11-20T04:53:46+03:00 +make test-idempotency + +BASE_URL="http://localhost:8080" python3 scripts/idempotency-race.py +parallel requests with one key: 20 +successful responses (201): 20 +failed requests: 0 [] +distinct message ids in responses: 1 +messages stored in history: 1 +instances that served requests: ['72c9d7b6cc57', 'e6d2e0d15c36'] +OK: exactly one message created diff --git a/evidence/instances.txt b/evidence/instances.txt new file mode 100644 index 00000000..1e212267 --- /dev/null +++ b/evidence/instances.txt @@ -0,0 +1,23 @@ +2026-11-20T04:56:16+03:00 +API replicas and single entrypoint + +messenger-lab4_api_1 Up 53 seconds (healthy) +messenger-lab4_api_2 Up 21 seconds (healthy) +messenger-lab4_lb_1 Up About a minute +messenger-lab4_postgres_1 Up About a minute (healthy) +messenger-lab4_redis_1 Up About a minute (healthy) +messenger-lab4_s3_1 Up About a minute (healthy) + +published ports (only lb must publish 8080) + +messenger-lab4_api_1 8080/tcp +messenger-lab4_api_2 8080/tcp +messenger-lab4_lb_1 0.0.0.0:8080->8080/tcp +messenger-lab4_postgres_1 127.0.0.1:55432->5432/tcp +messenger-lab4_redis_1 127.0.0.1:56379->6379/tcp +messenger-lab4_s3_1 9000-9001/tcp + +X-Instance-Id distribution over 20 requests through LB + + 10 x-instance-id: a089fe9cc382 + 10 x-instance-id: f309c2ef4e46 diff --git a/evidence/limits.txt b/evidence/limits.txt new file mode 100644 index 00000000..358d425f --- /dev/null +++ b/evidence/limits.txt @@ -0,0 +1,20 @@ +2026-11-20T04:56:16+03:00 +per-container limits, networks, secrets + +messenger-lab4_api_1 nano_cpus=1000000000 memory=536870912 networks=messenger-lab4_backend messenger-lab4_edge +messenger-lab4_api_2 nano_cpus=1000000000 memory=536870912 networks=messenger-lab4_backend messenger-lab4_edge +messenger-lab4_lb_1 nano_cpus=500000000 memory=67108864 networks=messenger-lab4_edge +messenger-lab4_postgres_1 nano_cpus=1000000000 memory=536870912 networks=messenger-lab4_backend +messenger-lab4_redis_1 nano_cpus=500000000 memory=134217728 networks=messenger-lab4_backend +messenger-lab4_s3_1 nano_cpus=1000000000 memory=536870912 networks=messenger-lab4_backend +messenger-lab4_s3-init_1 nano_cpus=500000000 memory=268435456 networks=messenger-lab4_backend +messenger-lab4_migrate_1 nano_cpus=500000000 memory=67108864 networks=messenger-lab4_backend + +ls /run/secrets per running container + +messenger-lab4_api_1: cache_url database_url s3_access_key_id s3_secret_access_key +messenger-lab4_api_2: cache_url database_url s3_access_key_id s3_secret_access_key +messenger-lab4_lb_1: +messenger-lab4_postgres_1: postgres_password +messenger-lab4_redis_1: +messenger-lab4_s3_1: s3_root_access_key s3_root_secret_key diff --git a/evidence/memory.txt b/evidence/memory.txt new file mode 100644 index 00000000..78ea566d --- /dev/null +++ b/evidence/memory.txt @@ -0,0 +1,36 @@ +2026-11-20T04:54:15+03:00 +10 concurrent uploads of a 8000x5000 PNG (40,000,000 pixels) per replica; API limit 512 MiB; MAX_CONCURRENT_UPLOADS=8, MAX_CONCURRENT_DECODES=1 + +BASE_URL="http://localhost:8080" python3 scripts/upload-load.py --concurrency 10 --output evidence/upload-memory.json +{ + "concurrency": 10, + "uploads": 10, + "fixture": "large.png", + "fixture_bytes": 126609, + "elapsed_seconds": 1.009, + "successful": 10, + "failed": 0, + "failures": [], + "latency_ms": { + "p50": 660.9, + "p95": 999.3, + "p99": 999.3 + }, + "api_containers": [ + "messenger-lab4_api_1", + "messenger-lab4_api_2" + ], + "peak_bytes_before": { + "messenger-lab4_api_1": 5951488, + "messenger-lab4_api_2": 4993024 + }, + "peak_bytes_after": { + "messenger-lab4_api_1": 348913664, + "messenger-lab4_api_2": 348721152 + }, + "peak_delta_bytes": { + "messenger-lab4_api_1": 342962176, + "messenger-lab4_api_2": 343728128 + }, + "peak_max_mb": 332.75 +} diff --git a/evidence/migrate.txt b/evidence/migrate.txt new file mode 100644 index 00000000..6cd4b2c9 --- /dev/null +++ b/evidence/migrate.txt @@ -0,0 +1,16 @@ +2026-11-20T04:56:17+03:00 +migrate container logs and schema version + +1/u init (18.672238ms) +2/u message_idempotency (27.931065ms) +3/u attachments (37.481418ms) +no change +no change + +schema_migrations + + version | dirty +---------+------- + 3 | f +(1 row) + diff --git a/evidence/negative.txt b/evidence/negative.txt new file mode 100644 index 00000000..2b4f1635 --- /dev/null +++ b/evidence/negative.txt @@ -0,0 +1,28 @@ +2026-11-20T04:53:36+03:00 +make test-attachments + +BASE_URL="http://localhost:8080" python3 scripts/attachments-check.py +ok: upload 201 ready, sha256=99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75, size=111817 +ok: jpeg upload/download byte-identical; jpeg declared as png -> 415 +ok: png with 40,000,000 pixels accepted and downloaded byte-identical +ok: filename with slash -> 400 +ok: filename with NUL -> 400 +ok: empty filename -> 400 +ok: declared jpeg with png body -> 415 +ok: truncated png -> 415 +ok: 10485761 bytes -> 413 +ok: text/plain -> 415 +ok: unknown variant -> 400 +ok: variant=original -> 200 +ok: unknown attachment id -> 404 +ok: upload by outsider -> 404 +ok: attachment from another chat -> 404 +ok: unknown attachment id in message -> 404 +ok: duplicate attachment_ids -> 400 +ok: eleven attachment_ids -> 400 +ok: empty text without attachments -> 400 +ok: idempotent replay with same attachment set -> same message +ok: absent attachment_ids equals [] for idempotency +ok: same key with a different attachment set -> 409 +ok: history exposes attachment_ids on every message +PASS: 23 attachment contract checks diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..a9ff82b5 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,32 @@ +2026-11-20T04:54:22+03:00 +make test-persistence ACTION_SCRIPT=scripts/restart.sh + +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. + +--- hook scope: containers and volumes before/after scripts/restart.sh --- + +messenger-lab4_api_1 a089fe9cc382 Up 5 seconds (healthy) +messenger-lab4_api_2 f309c2ef4e46 Up 5 seconds (healthy) +messenger-lab4_lb_1 efc7da123526 Up 5 seconds +messenger-lab4_postgres_1 c64e954cf92a Up 5 seconds (healthy) +messenger-lab4_redis_1 90ac9f642b09 Up 5 seconds (healthy) +messenger-lab4_s3_1 6ae98c5aef4f Up 5 seconds (healthy) +messenger-lab4_pgdata +messenger-lab4_redisdata +messenger-lab4_s3data + +$ scripts/restart.sh + + +messenger-lab4_api_1 a089fe9cc382 Up 15 seconds (healthy) +messenger-lab4_api_2 f309c2ef4e46 Up 15 seconds (healthy) +messenger-lab4_lb_1 efc7da123526 Up 15 seconds +messenger-lab4_postgres_1 c64e954cf92a Up 15 seconds (healthy) +messenger-lab4_redis_1 90ac9f642b09 Up 15 seconds (healthy) +messenger-lab4_s3_1 6ae98c5aef4f Up 15 seconds (healthy) +messenger-lab4_pgdata +messenger-lab4_redisdata +messenger-lab4_s3data +ready: 200 diff --git a/evidence/private-bucket.txt b/evidence/private-bucket.txt new file mode 100644 index 00000000..9416439d --- /dev/null +++ b/evidence/private-bucket.txt @@ -0,0 +1,22 @@ +2026-11-20T04:44:19+03:00 +bucket privacy and disabled console (checks outside the application API) + +$ anonymous GET of an existing object from the backend network +Connecting to s3:9000 (10.89.5.22:9000) + HTTP/1.1 403 Forbidden +wget: server returned error: HTTP/1.1 403 Forbidden + +$ anonymous bucket listing +Connecting to s3:9000 (10.89.5.22:9000) + HTTP/1.1 403 Forbidden +wget: server returned error: HTTP/1.1 403 Forbidden + +$ console port inside the s3 container +console_http=000 +console-closed + +$ published ports +messenger-lab4_api_1 8080/tcp +messenger-lab4_api_2 8080/tcp +messenger-lab4_lb_1 0.0.0.0:8080->8080/tcp +messenger-lab4_s3_1 9000-9001/tcp diff --git a/evidence/reconcile.txt b/evidence/reconcile.txt new file mode 100644 index 00000000..7f57a9f8 --- /dev/null +++ b/evidence/reconcile.txt @@ -0,0 +1,183 @@ +2026-11-20T04:41:03+03:00 +reconciler drill: baseline, grace period, dry-run, apply, repeat + +$ scripts/reconcile.sh # dry-run, grace 1h, clean baseline +{ + "prefix": "chats/", + "grace_seconds": 3600, + "dry_run": true, + "scanned_objects": 18, + "scanned_rows": 18, + "truncated": false, + "orphans": [], + "missing": [], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 7, + "objects_per_second": 2571.4285714285716 +} + +$ scripts/s3tool.sh put chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000 - < scripts/fixtures/sample.jpg +put chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000 (653 bytes) + +$ scripts/reconcile.sh # fresh orphan skipped by grace +{ + "prefix": "chats/", + "grace_seconds": 3600, + "dry_run": true, + "scanned_objects": 19, + "scanned_rows": 18, + "truncated": false, + "orphans": [], + "missing": [], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 8, + "objects_per_second": 2375 +} + +$ scripts/reconcile.sh -grace 0s # detected, dry-run keeps it +{ + "prefix": "chats/", + "grace_seconds": 0, + "dry_run": true, + "scanned_objects": 19, + "scanned_rows": 18, + "truncated": false, + "orphans": [ + { + "key": "chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000", + "size_bytes": 653, + "last_modified": "2026-11-20T01:41:03Z", + "age_seconds": 0 + } + ], + "missing": [], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 7, + "objects_per_second": 2714.285714285714 +} + +$ scripts/reconcile.sh -grace 0s -dry-run=false # apply +{ + "prefix": "chats/", + "grace_seconds": 0, + "dry_run": false, + "scanned_objects": 19, + "scanned_rows": 18, + "truncated": false, + "orphans": [ + { + "key": "chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000", + "size_bytes": 653, + "last_modified": "2026-11-20T01:41:03Z", + "age_seconds": 4 + } + ], + "missing": [], + "deleted_objects": 1, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 2, + "db_queries": 2, + "duration_ms": 15, + "objects_per_second": 1266.6666666666667 +} + +$ scripts/reconcile.sh -grace 0s -dry-run=false # repeat: nothing left +{ + "prefix": "chats/", + "grace_seconds": 0, + "dry_run": false, + "scanned_objects": 18, + "scanned_rows": 18, + "truncated": false, + "orphans": [], + "missing": [], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 8, + "objects_per_second": 2250 +} + +missing drill: metadata row without object + +$ scripts/s3tool.sh delete chats// of an existing attachment +$ scripts/s3tool.sh delete chats/bd1c9e17-0366-44b4-bd98-0a479a2a637c/1e9b9e12-eab2-4846-8952-e739a4257b37 +deleted chats/bd1c9e17-0366-44b4-bd98-0a479a2a637c/1e9b9e12-eab2-4846-8952-e739a4257b37 + +$ scripts/reconcile.sh -grace 0s # missing reported, metadata kept in dry-run +{ + "prefix": "chats/", + "grace_seconds": 0, + "dry_run": true, + "scanned_objects": 17, + "scanned_rows": 18, + "truncated": false, + "orphans": [], + "missing": [ + { + "id": "1e9b9e12-eab2-4846-8952-e739a4257b37", + "object_key": "chats/bd1c9e17-0366-44b4-bd98-0a479a2a637c/1e9b9e12-eab2-4846-8952-e739a4257b37", + "chat_id": "bd1c9e17-0366-44b4-bd98-0a479a2a637c", + "created_at": "2026-11-20T01:40:28Z", + "referenced_by_message": false + } + ], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 9, + "objects_per_second": 1888.8888888888891 +} + +metadata rows still present: 1 + +$ scripts/reconcile.sh -grace 0s -dry-run=false # safe repair: unreferenced dead row removed +{ + "prefix": "chats/", + "grace_seconds": 0, + "dry_run": false, + "scanned_objects": 17, + "scanned_rows": 18, + "truncated": false, + "orphans": [], + "missing": [ + { + "id": "1e9b9e12-eab2-4846-8952-e739a4257b37", + "object_key": "chats/bd1c9e17-0366-44b4-bd98-0a479a2a637c/1e9b9e12-eab2-4846-8952-e739a4257b37", + "chat_id": "bd1c9e17-0366-44b4-bd98-0a479a2a637c", + "created_at": "2026-11-20T01:40:28Z", + "referenced_by_message": false + } + ], + "deleted_objects": 0, + "deleted_metadata": 1, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 3, + "duration_ms": 8, + "objects_per_second": 2125 +} diff --git a/evidence/s3-outage.txt b/evidence/s3-outage.txt new file mode 100644 index 00000000..7aef16e2 --- /dev/null +++ b/evidence/s3-outage.txt @@ -0,0 +1,17 @@ +2026-11-20T04:57:42+03:00 +S3 unavailable: readiness and client-visible behaviour + +$ GET /health/ready on a replica + HTTP/1.1 503 Service Unavailable +wget: server returned error: HTTP/1.1 503 Service Unavailable + +$ GET /health/live on a replica (process is alive) + HTTP/1.1 200 OK + Content-Type: application/json; charset=utf-8 + X-Instance-Id: a089fe9cc382 + +$ client request through the load balancer +status=503 + +$ readiness after S3 recovery +status=200 diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..01ae22b7 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,5 @@ +2026-11-20T04:53:35+03:00 +make test + +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab4 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/storage.txt b/evidence/storage.txt new file mode 100644 index 00000000..e73446da --- /dev/null +++ b/evidence/storage.txt @@ -0,0 +1,32 @@ +2026-11-20T04:56:31+03:00 +object bytes live in the RustFS volume, metadata in PostgreSQL + + id | object_key | size_bytes | sha256 +--------------------------------------+---------------------------------------------------------------------------------+------------+------------------------------------------------------------------ + 82d5d4f3-e97a-4aea-9501-69ef2b74e138 | chats/e8618579-667a-4423-aa62-5402596e57d8/82d5d4f3-e97a-4aea-9501-69ef2b74e138 | 111817 | 99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75 +(1 row) + + +S3 volume listing for that object + +total 112 +-rw-r--r-- 1 rustfs rustfs 112398 Nov 20 01:55 xl.meta + +attachments table columns (no binary content) + + column_name | data_type +--------------+-------------------------- + id | uuid + chat_id | uuid + owner_id | uuid + filename | text + content_type | text + size_bytes | bigint + sha256 | text + object_key | text + status | text + error_code | text + created_at | timestamp with time zone + updated_at | timestamp with time zone +(12 rows) + diff --git a/evidence/test-go.txt b/evidence/test-go.txt new file mode 100644 index 00000000..20ab2197 --- /dev/null +++ b/evidence/test-go.txt @@ -0,0 +1,79 @@ +2026-11-20T04:53:38+03:00 +make test-go + +? messenger/cmd/reconcile [no test files] +? messenger/cmd/s3-init [no test files] +? messenger/cmd/s3tool [no test files] +? messenger/cmd/server [no test files] +? messenger/internal/config [no test files] +? messenger/internal/domain [no test files] +=== RUN TestSessionExpiry +--- PASS: TestSessionExpiry (3.09s) +=== RUN TestLogout +--- PASS: TestLogout (0.13s) +=== RUN TestWrongPassword +--- PASS: TestWrongPassword (0.10s) +=== RUN TestRedisUnavailable +redis: 2026/11/20 04:53:42 pool.go:770: redis: connection pool: failed to dial after 5 attempts: dial tcp 127.0.0.1:1: connect: connection refused +redis: 2026/11/20 04:53:43 pool.go:770: redis: connection pool: failed to dial after 5 attempts: dial tcp 127.0.0.1:1: connect: connection refused +redis: 2026/11/20 04:53:43 pool.go:770: redis: connection pool: failed to dial after 5 attempts: dial tcp 127.0.0.1:1: connect: connection refused +redis: 2026/11/20 04:53:44 pool.go:770: redis: connection pool: failed to dial after 5 attempts: dial tcp 127.0.0.1:1: connect: connection refused +redis: 2026/11/20 04:53:44 pool.go:770: redis: connection pool: failed to dial after 5 attempts: dial tcp 127.0.0.1:1: connect: connection refused +redis: 2026/11/20 04:53:44 pool.go:770: redis: connection pool: failed to dial after 5 attempts: dial tcp 127.0.0.1:1: connect: connection refused +--- PASS: TestRedisUnavailable (2.95s) +=== RUN TestDatabaseUnavailable +--- PASS: TestDatabaseUnavailable (0.17s) +=== RUN TestInvalidJSON +--- PASS: TestInvalidJSON (0.01s) +=== RUN TestForeignChat +--- PASS: TestForeignChat (0.18s) +=== RUN TestEmptyMessage +redis: 2026/11/20 04:53:45 pool.go:770: redis: connection pool: failed to dial after 5 attempts: dial tcp 127.0.0.1:1: connect: connection refused +--- PASS: TestEmptyMessage (0.08s) +=== RUN TestDuplicateUsername +--- PASS: TestDuplicateUsername (0.10s) +=== RUN TestPaginationMultiplePages +--- PASS: TestPaginationMultiplePages (0.09s) +=== RUN TestConcurrentMessages +--- PASS: TestConcurrentMessages (0.57s) +PASS +ok messenger/internal/handler 7.474s +=== RUN TestPlanDetectsOrphansAndMissing +--- PASS: TestPlanDetectsOrphansAndMissing (0.00s) +=== RUN TestPlanHonoursGraceAndPrefix +--- PASS: TestPlanHonoursGraceAndPrefix (0.00s) +=== RUN TestPlanNeverDeletesReferencedObjects +--- PASS: TestPlanNeverDeletesReferencedObjects (0.00s) +=== RUN TestPlanOnlyReportsRowsInsidePrefix +--- PASS: TestPlanOnlyReportsRowsInsidePrefix (0.00s) +=== RUN TestPlanOutputIsSorted +--- PASS: TestPlanOutputIsSorted (0.00s) +PASS +ok messenger/internal/reconcile 0.002s +=== RUN TestRegisterUsernameRace +--- PASS: TestRegisterUsernameRace (0.02s) +=== RUN TestCreateChatRollback +--- PASS: TestCreateChatRollback (0.02s) +PASS +ok messenger/internal/repository/postgres 0.040s +? messenger/internal/repository/redis [no test files] +? messenger/internal/repository/s3 [no test files] +? messenger/internal/router [no test files] +=== RUN TestCheckFilename +--- PASS: TestCheckFilename (0.00s) +=== RUN TestDetectImageType +--- PASS: TestDetectImageType (0.00s) +=== RUN TestCheckPixels +--- PASS: TestCheckPixels (0.00s) +=== RUN TestCheckIntegrity +--- PASS: TestCheckIntegrity (0.00s) +=== RUN TestCheckMessageText +--- PASS: TestCheckMessageText (0.00s) +=== RUN TestCheckAttachmentIDs +--- PASS: TestCheckAttachmentIDs (0.00s) +=== RUN TestMessageHash +--- PASS: TestMessageHash (0.00s) +=== RUN TestReadLimited +--- PASS: TestReadLimited (0.00s) +PASS +ok messenger/internal/service 0.004s diff --git a/evidence/track2-cost.txt b/evidence/track2-cost.txt new file mode 100644 index 00000000..6745ea0e --- /dev/null +++ b/evidence/track2-cost.txt @@ -0,0 +1,41 @@ +2026-11-20T04:42:15+03:00 +traversal cost of the reconciler (synthetic objects under chats/bench/, 1 KiB each); scan uses LIST pages, repair deletes one by one + +{ + "prefix": "chats/bench", + "measurements": [ + { + "objects": 100, + "scan_ms": 9, + "scan_s3_requests": 1, + "scan_db_queries": 2, + "scan_objects_per_second": 11111.1, + "scan_ms_per_object": 0.09, + "repair_ms": 1324, + "repair_s3_requests": 101, + "repair_deleted": 100 + }, + { + "objects": 1000, + "scan_ms": 34, + "scan_s3_requests": 1, + "scan_db_queries": 2, + "scan_objects_per_second": 29411.8, + "scan_ms_per_object": 0.034, + "repair_ms": 12232, + "repair_s3_requests": 1001, + "repair_deleted": 1000 + }, + { + "objects": 5000, + "scan_ms": 166, + "scan_s3_requests": 5, + "scan_db_queries": 2, + "scan_objects_per_second": 30120.5, + "scan_ms_per_object": 0.0332, + "repair_ms": 69929, + "repair_s3_requests": 5005, + "repair_deleted": 5000 + } + ] +} diff --git a/evidence/track2-injection.txt b/evidence/track2-injection.txt new file mode 100644 index 00000000..f9dbbf5b --- /dev/null +++ b/evidence/track2-injection.txt @@ -0,0 +1,193 @@ +2026-11-20T04:41:49+03:00 +two-store consistency: injections on both sides, dry-run, safe repair, repeat, protection of fresh and used data + +injections: + S3 has an object that has no metadata row (fresh orphan) + metadata exists but the object is gone: one attachment used by a message, one unused + +$ scripts/s3tool.sh put chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000 - < scripts/fixtures/sample.jpg +put chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000 (653 bytes) +$ scripts/s3tool.sh delete chats/47f62016-7525-4910-9823-0b21f2664b10/6a9f0506-2126-497a-b8b4-89ac728fe5a1 # used +deleted chats/47f62016-7525-4910-9823-0b21f2664b10/6a9f0506-2126-497a-b8b4-89ac728fe5a1 +$ scripts/s3tool.sh delete chats/d03b2c6b-67fd-4b5d-bc17-9e926440ff8d/c49ab2de-258a-4851-8ad2-f7f585fd3488 # unused +deleted chats/d03b2c6b-67fd-4b5d-bc17-9e926440ff8d/c49ab2de-258a-4851-8ad2-f7f585fd3488 + +$ scripts/reconcile.sh -grace 1h # dry-run +{ + "prefix": "chats/", + "grace_seconds": 3600, + "dry_run": true, + "scanned_objects": 19, + "scanned_rows": 20, + "truncated": false, + "orphans": [], + "missing": [ + { + "id": "6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "object_key": "chats/47f62016-7525-4910-9823-0b21f2664b10/6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "chat_id": "47f62016-7525-4910-9823-0b21f2664b10", + "created_at": "2026-11-20T01:41:41Z", + "referenced_by_message": true + }, + { + "id": "c49ab2de-258a-4851-8ad2-f7f585fd3488", + "object_key": "chats/d03b2c6b-67fd-4b5d-bc17-9e926440ff8d/c49ab2de-258a-4851-8ad2-f7f585fd3488", + "chat_id": "d03b2c6b-67fd-4b5d-bc17-9e926440ff8d", + "created_at": "2026-11-20T01:41:41Z", + "referenced_by_message": false + } + ], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 8, + "objects_per_second": 2375 +} + +$ scripts/reconcile.sh -grace 1h -dry-run=false # apply: fresh object survives, safe metadata repair +{ + "prefix": "chats/", + "grace_seconds": 3600, + "dry_run": false, + "scanned_objects": 19, + "scanned_rows": 20, + "truncated": false, + "orphans": [], + "missing": [ + { + "id": "6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "object_key": "chats/47f62016-7525-4910-9823-0b21f2664b10/6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "chat_id": "47f62016-7525-4910-9823-0b21f2664b10", + "created_at": "2026-11-20T01:41:41Z", + "referenced_by_message": true + }, + { + "id": "c49ab2de-258a-4851-8ad2-f7f585fd3488", + "object_key": "chats/d03b2c6b-67fd-4b5d-bc17-9e926440ff8d/c49ab2de-258a-4851-8ad2-f7f585fd3488", + "chat_id": "d03b2c6b-67fd-4b5d-bc17-9e926440ff8d", + "created_at": "2026-11-20T01:41:41Z", + "referenced_by_message": false + } + ], + "deleted_objects": 0, + "deleted_metadata": 1, + "retained_missing": 1, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 3, + "duration_ms": 12, + "objects_per_second": 1583.3333333333333 +} + +$ scripts/s3tool.sh list chats/aaaaaaaa-0000-4000-8000-000000000000 # fresh orphan still present +chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000 653 2026-11-20T01:41:49Z + +$ scripts/reconcile.sh -grace 0s # now eligible for deletion +{ + "prefix": "chats/", + "grace_seconds": 0, + "dry_run": true, + "scanned_objects": 19, + "scanned_rows": 19, + "truncated": false, + "orphans": [ + { + "key": "chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000", + "size_bytes": 653, + "last_modified": "2026-11-20T01:41:49Z", + "age_seconds": 7 + } + ], + "missing": [ + { + "id": "6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "object_key": "chats/47f62016-7525-4910-9823-0b21f2664b10/6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "chat_id": "47f62016-7525-4910-9823-0b21f2664b10", + "created_at": "2026-11-20T01:41:41Z", + "referenced_by_message": true + } + ], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 0, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 8, + "objects_per_second": 2375 +} + +$ scripts/reconcile.sh -grace 0s -dry-run=false # apply +{ + "prefix": "chats/", + "grace_seconds": 0, + "dry_run": false, + "scanned_objects": 19, + "scanned_rows": 19, + "truncated": false, + "orphans": [ + { + "key": "chats/aaaaaaaa-0000-4000-8000-000000000000/bbbbbbbb-0000-4000-8000-000000000000", + "size_bytes": 653, + "last_modified": "2026-11-20T01:41:49Z", + "age_seconds": 13 + } + ], + "missing": [ + { + "id": "6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "object_key": "chats/47f62016-7525-4910-9823-0b21f2664b10/6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "chat_id": "47f62016-7525-4910-9823-0b21f2664b10", + "created_at": "2026-11-20T01:41:41Z", + "referenced_by_message": true + } + ], + "deleted_objects": 1, + "deleted_metadata": 0, + "retained_missing": 1, + "delete_failures": 0, + "s3_requests": 2, + "db_queries": 2, + "duration_ms": 15, + "objects_per_second": 1266.6666666666667 +} + +$ scripts/reconcile.sh -grace 0s -dry-run=false # repeat: idempotent +{ + "prefix": "chats/", + "grace_seconds": 0, + "dry_run": false, + "scanned_objects": 18, + "scanned_rows": 19, + "truncated": false, + "orphans": [], + "missing": [ + { + "id": "6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "object_key": "chats/47f62016-7525-4910-9823-0b21f2664b10/6a9f0506-2126-497a-b8b4-89ac728fe5a1", + "chat_id": "47f62016-7525-4910-9823-0b21f2664b10", + "created_at": "2026-11-20T01:41:41Z", + "referenced_by_message": true + } + ], + "deleted_objects": 0, + "deleted_metadata": 0, + "retained_missing": 1, + "delete_failures": 0, + "s3_requests": 1, + "db_queries": 2, + "duration_ms": 9, + "objects_per_second": 2000.0000000000002 +} + +used attachments remain untouched (rows and objects) + used_attachments | ready +------------------+------- + 3 | 3 +(1 row) + +retained referenced metadata row for the attachment whose object was deleted: 1 +object of that referenced attachment is still absent: 0 diff --git a/evidence/upload-memory.json b/evidence/upload-memory.json new file mode 100644 index 00000000..36f1ada8 --- /dev/null +++ b/evidence/upload-memory.json @@ -0,0 +1,32 @@ +{ + "concurrency": 10, + "uploads": 10, + "fixture": "large.png", + "fixture_bytes": 126609, + "elapsed_seconds": 1.009, + "successful": 10, + "failed": 0, + "failures": [], + "latency_ms": { + "p50": 660.9, + "p95": 999.3, + "p99": 999.3 + }, + "api_containers": [ + "messenger-lab4_api_1", + "messenger-lab4_api_2" + ], + "peak_bytes_before": { + "messenger-lab4_api_1": 5951488, + "messenger-lab4_api_2": 4993024 + }, + "peak_bytes_after": { + "messenger-lab4_api_1": 348913664, + "messenger-lab4_api_2": 348721152 + }, + "peak_delta_bytes": { + "messenger-lab4_api_1": 342962176, + "messenger-lab4_api_2": 343728128 + }, + "peak_max_mb": 332.75 +} diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..ceb61dcf --- /dev/null +++ b/go.mod @@ -0,0 +1,57 @@ +module messenger + +go 1.27.1 + +require ( + github.com/go-chi/chi/v5 v5.3.2 + github.com/jackc/pgx/v5 v5.11.0 + github.com/minio/madmin-go/v3 v3.0.110 + github.com/minio/minio-go/v7 v7.4.1 + github.com/redis/go-redis/v9 v9.23.0 + golang.org/x/crypto v0.58.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/golang-jwt/jwt/v4 v4.5.2 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/klauspost/compress v1.19.2 // indirect + github.com/klauspost/cpuid/v2 v2.4.0 // indirect + github.com/klauspost/crc32 v1.3.0 // indirect + github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // indirect + github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect + github.com/minio/crc64nvme v1.1.1 // indirect + github.com/minio/md5-simd v1.1.2 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/philhofer/fwd v1.2.0 // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v0.63.0 // indirect + github.com/prometheus/procfs v0.16.0 // indirect + github.com/prometheus/prom2json v1.4.2 // indirect + github.com/prometheus/prometheus v0.303.0 // indirect + github.com/rs/xid v1.6.0 // indirect + github.com/safchain/ethtool v0.5.10 // indirect + github.com/secure-io/sio-go v0.3.1 // indirect + github.com/shirou/gopsutil/v3 v3.24.5 // indirect + github.com/shoenig/go-m1cpu v0.1.6 // indirect + github.com/tinylib/msgp v1.6.4 // indirect + github.com/tklauser/go-sysconf v0.3.15 // indirect + github.com/tklauser/numcpus v0.10.0 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + github.com/zeebo/xxh3 v1.1.0 // indirect + go.uber.org/atomic v1.12.0 // indirect + go.yaml.in/yaml/v3 v3.0.5 // indirect + golang.org/x/net v0.60.0 // indirect + golang.org/x/sync v0.24.0 // indirect + golang.org/x/sys v0.49.0 // indirect + golang.org/x/text v0.43.0 // indirect + google.golang.org/protobuf v1.36.12 // indirect + gopkg.in/ini.v1 v1.67.3 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..6776f843 --- /dev/null +++ b/go.sum @@ -0,0 +1,141 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/go-chi/chi/v5 v5.3.2 h1:5YQkICvTCSZ25hoRsyJazN0scjzKGiu4VAUc7H1o1nY= +github.com/go-chi/chi/v5 v5.3.2/go.mod h1:R+tYY2hNuVUUjxoPtqUdgBqevM9s9njzkTLutVsOCto= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI= +github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8= +github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= +github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw= +github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= +github.com/klauspost/crc32 v1.3.0 h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM= +github.com/klauspost/crc32 v1.3.0/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw= +github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 h1:PpXWgLPs+Fqr325bN2FD2ISlRRztXibcX6e8f5FR5Dc= +github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg= +github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= +github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI= +github.com/minio/crc64nvme v1.1.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= +github.com/minio/madmin-go/v3 v3.0.110 h1:FIYekj7YPc430ffpXFWiUtyut3qBt/unIAcDzJn9H5M= +github.com/minio/madmin-go/v3 v3.0.110/go.mod h1:WOe2kYmYl1OIlY2DSRHVQ8j1v4OItARQ6jGyQqcCud8= +github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= +github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= +github.com/minio/minio-go/v7 v7.4.1 h1:PtU/zIOfQRWZ+QydXAZysc+xZYHdG+BBR4Z6TUvy73w= +github.com/minio/minio-go/v7 v7.4.1/go.mod h1:nQnQi7zTfXR4lREtYXZQWqo5aw0Rqv+ZqCGrTORygRk= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM= +github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.63.0 h1:YR/EIY1o3mEFP/kZCD7iDMnLPlGyuU2Gb3HIcXnA98k= +github.com/prometheus/common v0.63.0/go.mod h1:VVFF/fBIoToEnWRVkYoXEkq3R3paCoxG9PXP74SnV18= +github.com/prometheus/procfs v0.16.0 h1:xh6oHhKwnOJKMYiYBDWmkHqQPyiY40sny36Cmx2bbsM= +github.com/prometheus/procfs v0.16.0/go.mod h1:8veyXUu3nGP7oaCxhX6yeaM5u4stL2FeMXnCqhDthZg= +github.com/prometheus/prom2json v1.4.2 h1:PxCTM+Whqi/eykO1MKsEL0p/zMpxp9ybpsmdFamw6po= +github.com/prometheus/prom2json v1.4.2/go.mod h1:zuvPm7u3epZSbXPWHny6G+o8ETgu6eAK3oPr6yFkRWE= +github.com/prometheus/prometheus v0.303.0 h1:wsNNsbd4EycMCphYnTmNY9JASBVbp7NWwJna857cGpA= +github.com/prometheus/prometheus v0.303.0/go.mod h1:8PMRi+Fk1WzopMDeb0/6hbNs9nV6zgySkU/zds5Lu3o= +github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s= +github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0= +github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= +github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= +github.com/safchain/ethtool v0.5.10 h1:Im294gZtuf4pSGJRAOGKaASNi3wMeFaGaWuSaomedpc= +github.com/safchain/ethtool v0.5.10/go.mod h1:w9jh2Lx7YBR4UwzLkzCmWl85UY0W2uZdd7/DckVE5+c= +github.com/secure-io/sio-go v0.3.1 h1:dNvY9awjabXTYGsTF1PiCySl9Ltofk9GA3VdWlo7rRc= +github.com/secure-io/sio-go v0.3.1/go.mod h1:+xbkjDzPjwh4Axd07pRKSNriS9SCiYksWnZqdnfpQxs= +github.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI= +github.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk= +github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM= +github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ= +github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU= +github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +github.com/tinylib/msgp v1.6.4 h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ= +github.com/tinylib/msgp v1.6.4/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA= +github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4= +github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4= +github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso= +github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ= +github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= +github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= +github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= +go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE= +go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54= +golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU= +golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= +golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= +golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc= +golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/ini.v1 v1.67.3 h1:iM9Lhz5MRSGhHVGGwCuzG9KO8PoirCXj/m/qTmOJJQw= +gopkg.in/ini.v1 v1.67.3/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..d31efa8b --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,30 @@ +global + log stdout format raw local0 info + maxconn 2000 + +defaults + mode http + log global + option httplog + timeout connect 2s + timeout client 30s + timeout server 20s + timeout http-request 10s + timeout check 1s + retries 3 + option redispatch + +resolvers dns + parse-resolv-conf + hold valid 1s + +frontend public + bind :8080 + default_backend api + +backend api + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server check inter 1s fall 2 rise 2 resolvers dns init-addr none + server-template api 4 api:8080 diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..502fd2c0 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,129 @@ +package config + +import ( + "fmt" + "net" + "os" + "strconv" + "strings" + "time" +) + +type Config struct { + Host string + Port string + Env string + SessionTTL time.Duration + DatabaseURL string + CacheURL string + S3Endpoint string + S3Region string + S3Bucket string + S3AccessKeyID string + S3SecretAccessKey string + MaxUploadBytes int64 + MaxImagePixels int64 + MaxConcurrentUploads int + MaxConcurrentDecodes int +} + +func Load() (Config, error) { + ttl, err := strconv.Atoi(getenv("SESSION_TTL_SECONDS", "3600")) + if err != nil || ttl <= 0 { + return Config{}, fmt.Errorf("SESSION_TTL_SECONDS must be a positive integer") + } + maxUploadBytes, err := positiveInt64("MAX_UPLOAD_BYTES", "10485760") + if err != nil { + return Config{}, err + } + maxImagePixels, err := positiveInt64("MAX_IMAGE_PIXELS", "40000000") + if err != nil { + return Config{}, err + } + maxConcurrentUploads, err := positiveInt("MAX_CONCURRENT_UPLOADS", "8") + if err != nil { + return Config{}, err + } + maxConcurrentDecodes, err := positiveInt("MAX_CONCURRENT_DECODES", "1") + if err != nil { + return Config{}, err + } + databaseURL, err := ReadSecret("DATABASE_URL_FILE", "/run/secrets/database_url") + if err != nil { + return Config{}, err + } + cacheURL, err := ReadSecret("CACHE_URL_FILE", "/run/secrets/cache_url") + if err != nil { + return Config{}, err + } + accessKeyID, err := ReadSecret("S3_ACCESS_KEY_ID_FILE", "/run/secrets/s3_access_key_id") + if err != nil { + return Config{}, err + } + secretAccessKey, err := ReadSecret("S3_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_secret_access_key") + if err != nil { + return Config{}, err + } + if accessKeyID == "" || secretAccessKey == "" { + return Config{}, fmt.Errorf("S3_ACCESS_KEY_ID_FILE and S3_SECRET_ACCESS_KEY_FILE must not be empty") + } + bucket := getenv("S3_BUCKET", "messenger-attachments") + if strings.TrimSpace(bucket) == "" { + return Config{}, fmt.Errorf("S3_BUCKET must not be empty") + } + endpoint := getenv("S3_ENDPOINT", "http://s3:9000") + if strings.TrimSpace(endpoint) == "" { + return Config{}, fmt.Errorf("S3_ENDPOINT must not be empty") + } + return Config{ + Host: getenv("APP_HOST", "0.0.0.0"), + Port: getenv("APP_PORT", "8080"), + Env: getenv("APP_ENV", "lab"), + SessionTTL: time.Duration(ttl) * time.Second, + DatabaseURL: databaseURL, + CacheURL: cacheURL, + S3Endpoint: endpoint, + S3Region: getenv("S3_REGION", "us-east-1"), + S3Bucket: bucket, + S3AccessKeyID: accessKeyID, + S3SecretAccessKey: secretAccessKey, + MaxUploadBytes: maxUploadBytes, + MaxImagePixels: maxImagePixels, + MaxConcurrentUploads: maxConcurrentUploads, + MaxConcurrentDecodes: maxConcurrentDecodes, + }, nil +} + +func (c Config) Addr() string { return net.JoinHostPort(c.Host, c.Port) } + +func positiveInt64(key, def string) (int64, error) { + value, err := strconv.ParseInt(getenv(key, def), 10, 64) + if err != nil || value <= 0 { + return 0, fmt.Errorf("%s must be a positive integer", key) + } + return value, nil +} + +func positiveInt(key, def string) (int, error) { + value, err := strconv.Atoi(getenv(key, def)) + if err != nil || value <= 0 { + return 0, fmt.Errorf("%s must be a positive integer", key) + } + return value, nil +} + +func ReadSecret(key, def string) (string, error) { + path := getenv(key, def) + b, err := os.ReadFile(path) + if err != nil { + return "", fmt.Errorf("%s: cannot read %s", key, path) + } + return strings.TrimSpace(string(b)), nil +} + +func getenv(key, def string) string { + if v := os.Getenv(key); v != "" { + return v + } + return def +} diff --git a/internal/domain/domain.go b/internal/domain/domain.go new file mode 100644 index 00000000..1b6e1f90 --- /dev/null +++ b/internal/domain/domain.go @@ -0,0 +1,83 @@ +package domain + +import ( + "time" + "uuid" +) + +type User struct { + ID uuid.UUID + Username string + DisplayName string + CreatedAt time.Time +} + +type Chat struct { + ID uuid.UUID + Title string + MemberIDs []uuid.UUID + CreatedAt time.Time +} + +func (c Chat) HasMember(userID uuid.UUID) bool { + for _, id := range c.MemberIDs { + if id == userID { + return true + } + } + return false +} + +type Message struct { + ID uuid.UUID + ChatID uuid.UUID + SenderID uuid.UUID + Text string + AttachmentIDs []uuid.UUID + CreatedAt time.Time +} + +const ( + AttachmentReady = "ready" + ContentPNG = "image/png" + ContentJPEG = "image/jpeg" +) + +type Attachment struct { + ID uuid.UUID + ChatID uuid.UUID + OwnerID uuid.UUID + Filename string + ContentType string + SizeBytes int64 + SHA256 string + ObjectKey string + Status string + ErrorCode *string + CreatedAt time.Time + UpdatedAt time.Time +} + +type Session struct { + Token string + ExpiresAt time.Time + User User +} + +type Cursor struct { + Scope uuid.UUID + CreatedAt time.Time + ID uuid.UUID +} + +func CompareKey(aTime time.Time, aID uuid.UUID, bTime time.Time, bID uuid.UUID) int { + if c := aTime.Compare(bTime); c != 0 { + return c + } + return aID.Compare(bID) +} + +type Page[T any] struct { + Items []T + Next *Cursor +} diff --git a/internal/domain/errors.go b/internal/domain/errors.go new file mode 100644 index 00000000..2a15990f --- /dev/null +++ b/internal/domain/errors.go @@ -0,0 +1,13 @@ +package domain + +import "errors" + +var ( + ErrInvalidInput = errors.New("invalid input") + ErrUnauthorized = errors.New("unauthorized") + ErrNotFound = errors.New("not found") + ErrConflict = errors.New("conflict") + ErrUnavailable = errors.New("dependency unavailable") + ErrTooLarge = errors.New("payload too large") + ErrUnsupportedMedia = errors.New("unsupported media type") +) diff --git a/internal/handler/attachments.go b/internal/handler/attachments.go new file mode 100644 index 00000000..3ab2b07e --- /dev/null +++ b/internal/handler/attachments.go @@ -0,0 +1,82 @@ +package handler + +import ( + "io" + "mime" + "net/http" + "strconv" + "uuid" + + "github.com/go-chi/chi/v5" +) + +func (h *Handler) UploadAttachment(w http.ResponseWriter, r *http.Request) { + chatID, err := chatIDParam(r) + if err != nil { + h.fail(w, r, err) + return + } + filename := r.URL.Query().Get("filename") + if filename == "" { + h.fail(w, r, badRequest("filename is required")) + return + } + contentType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + contentType = "" + } + attachment, err := h.attachments.Upload(r.Context(), actor(r), chatID, filename, contentType, r.Body) + if err != nil { + h.fail(w, r, err) + return + } + writeJSON(w, http.StatusCreated, toAttachmentResponse(attachment)) +} + +func (h *Handler) GetAttachment(w http.ResponseWriter, r *http.Request) { + id, err := attachmentIDParam(r) + if err != nil { + h.fail(w, r, err) + return + } + attachment, err := h.attachments.Get(r.Context(), actor(r), id) + if err != nil { + h.fail(w, r, err) + return + } + writeJSON(w, http.StatusOK, toAttachmentResponse(attachment)) +} + +func (h *Handler) DownloadAttachment(w http.ResponseWriter, r *http.Request) { + id, err := attachmentIDParam(r) + if err != nil { + h.fail(w, r, err) + return + } + query := r.URL.Query() + variant := query.Get("variant") + if query.Has("variant") && variant == "" { + h.fail(w, r, badRequest("variant must be original")) + return + } + attachment, content, err := h.attachments.Open(r.Context(), actor(r), id, variant) + if err != nil { + h.fail(w, r, err) + return + } + defer content.Close() + w.Header().Set("Content-Type", attachment.ContentType) + w.Header().Set("Content-Length", strconv.FormatInt(attachment.SizeBytes, 10)) + w.WriteHeader(http.StatusOK) + if _, err := io.Copy(w, content); err != nil { + h.log.Error("attachment download interrupted", "request_id", w.Header().Get(headerRequestID), "err", err) + } +} + +func attachmentIDParam(r *http.Request) (uuid.UUID, error) { + id, ok := parseUUID(chi.URLParam(r, "attachment_id")) + if !ok { + return uuid.UUID{}, badRequest("attachment_id must be a UUID") + } + return id, nil +} diff --git a/internal/handler/auth.go b/internal/handler/auth.go new file mode 100644 index 00000000..cea44f64 --- /dev/null +++ b/internal/handler/auth.go @@ -0,0 +1,53 @@ +package handler + +import ( + "encoding/base64" + "errors" + "net/http" + "strings" + "unicode/utf8" + + "messenger/internal/domain" +) + +func (h *Handler) CreateSession(w http.ResponseWriter, r *http.Request) { + username, password, ok := basicCredentials(r) + if !ok { + h.failLogin(w, r, domain.ErrUnauthorized) + return + } + session, err := h.auth.Login(r.Context(), username, password) + if err != nil { + h.failLogin(w, r, err) + return + } + writeJSON(w, http.StatusCreated, toSessionResponse(session)) +} + +func (h *Handler) failLogin(w http.ResponseWriter, r *http.Request, err error) { + if errors.Is(err, domain.ErrUnauthorized) { + w.Header().Set(headerWWWAuthenticate, basicChallenge) + } + h.fail(w, r, err) +} + +func (h *Handler) DeleteSession(w http.ResponseWriter, r *http.Request) { + if err := h.auth.Logout(r.Context(), current(r).token); err != nil { + h.fail(w, r, err) + return + } + w.WriteHeader(http.StatusNoContent) +} + +func basicCredentials(r *http.Request) (string, string, bool) { + encoded, ok := authCredentials(r, "Basic") + if !ok { + return "", "", false + } + raw, err := base64.StdEncoding.DecodeString(encoded) + if err != nil || !utf8.Valid(raw) { + return "", "", false + } + username, password, ok := strings.Cut(string(raw), ":") + return username, password, ok +} diff --git a/internal/handler/auth_test.go b/internal/handler/auth_test.go new file mode 100644 index 00000000..9fb027be --- /dev/null +++ b/internal/handler/auth_test.go @@ -0,0 +1,102 @@ +package handler_test + +import ( + "net/http" + "strings" + "testing" + "time" +) + +const ( + deadDatabaseURL = "postgres://messenger:x@127.0.0.1:1/messenger?sslmode=disable" + deadRedisURL = "redis://127.0.0.1:1/0" +) + +func TestSessionExpiry(t *testing.T) { + dbURL, redisURL := testURLs(t) + srv := newStack(t, dbURL, redisURL, 2*time.Second) + alice := createUser(t, srv, "alice") + + if status, _ := do(t, srv, http.MethodGet, "/api/v1/users/me", alice.Token, ""); status != http.StatusOK { + t.Fatalf("fresh session: got %d, want 200", status) + } + time.Sleep(3 * time.Second) + resp := request(t, srv, http.MethodGet, "/api/v1/users/me", alice.Token, "") + resp.Body.Close() + if resp.StatusCode != http.StatusUnauthorized { + t.Fatalf("expired session: got %d, want 401", resp.StatusCode) + } + if got := resp.Header.Get("WWW-Authenticate"); !strings.HasPrefix(got, "Bearer") { + t.Errorf("WWW-Authenticate = %q, want Bearer challenge", got) + } +} + +func TestLogout(t *testing.T) { + srv := newServer(t) + alice := createUser(t, srv, "alice") + + resp := request(t, srv, http.MethodDelete, "/api/v1/auth/sessions/current", alice.Token, "") + resp.Body.Close() + if resp.StatusCode != http.StatusNoContent { + t.Fatalf("logout: got %d, want 204", resp.StatusCode) + } + if status, _ := do(t, srv, http.MethodGet, "/api/v1/users/me", alice.Token, ""); status != http.StatusUnauthorized { + t.Errorf("revoked token on /users/me: got %d, want 401", status) + } + if status, _ := do(t, srv, http.MethodDelete, "/api/v1/auth/sessions/current", alice.Token, ""); status != http.StatusUnauthorized { + t.Errorf("repeated logout: got %d, want 401", status) + } +} + +func TestWrongPassword(t *testing.T) { + srv := newServer(t) + alice := createUser(t, srv, "alice") + + for name, password := range map[string]string{"wrong password": "Wrong-password-123", "unknown user": alice.Password} { + username := alice.Username + if name == "unknown user" { + username = "nobody_" + alice.Username[:10] + } + resp := login(t, srv, username, password) + resp.Body.Close() + if resp.StatusCode != http.StatusUnauthorized { + t.Errorf("%s: got %d, want 401", name, resp.StatusCode) + } + if got := resp.Header.Get("WWW-Authenticate"); got != `Basic realm="messenger", charset="UTF-8"` { + t.Errorf("%s: WWW-Authenticate = %q", name, got) + } + } +} + +func TestRedisUnavailable(t *testing.T) { + dbURL, _ := testURLs(t) + srv := newStack(t, dbURL, deadRedisURL, time.Hour) + + if status, body := do(t, srv, http.MethodGet, "/api/v1/users/me", "some-token-from-before-the-outage", ""); status != http.StatusServiceUnavailable || errorCode(body) != "unavailable" { + t.Errorf("bearer request: got %d %q, want 503 unavailable", status, errorCode(body)) + } + if status, _ := do(t, srv, http.MethodGet, "/api/v1/users/me", "", ""); status != http.StatusUnauthorized { + t.Errorf("anonymous request: got %d, want 401", status) + } + if status, _ := do(t, srv, http.MethodGet, "/health/ready", "", ""); status != http.StatusServiceUnavailable { + t.Errorf("ready: got %d, want 503", status) + } +} + +func TestDatabaseUnavailable(t *testing.T) { + dbURL, redisURL := testURLs(t) + healthy := newStack(t, dbURL, redisURL, time.Hour) + alice := createUser(t, healthy, "alice") + + srv := newStack(t, deadDatabaseURL, redisURL, time.Hour) + if status, body := do(t, srv, http.MethodGet, "/api/v1/users/me", alice.Token, ""); status != http.StatusServiceUnavailable || errorCode(body) != "unavailable" { + t.Errorf("valid session: got %d %q, want 503 unavailable", status, errorCode(body)) + } + if status, _ := do(t, srv, http.MethodPost, "/api/v1/users", "", + `{"username":"db_down_user","display_name":"X","password":"long-enough-pass"}`); status != http.StatusServiceUnavailable { + t.Errorf("register: got %d, want 503", status) + } + if status, _ := do(t, srv, http.MethodGet, "/health/ready", "", ""); status != http.StatusServiceUnavailable { + t.Errorf("ready: got %d, want 503", status) + } +} diff --git a/internal/handler/chats.go b/internal/handler/chats.go new file mode 100644 index 00000000..c655ab00 --- /dev/null +++ b/internal/handler/chats.go @@ -0,0 +1,104 @@ +package handler + +import ( + "net/http" + "strconv" + "uuid" + + "github.com/go-chi/chi/v5" + + "messenger/internal/domain" + "messenger/internal/service" +) + +func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) { + var req createChatRequest + if err := decodeJSON(w, r, &req); err != nil { + h.fail(w, r, err) + return + } + if req.Title == nil || req.MemberIDs == nil { + h.fail(w, r, badRequest("title and member_ids are required")) + return + } + memberIDs := make([]uuid.UUID, len(*req.MemberIDs)) + for i, s := range *req.MemberIDs { + id, ok := parseUUID(s) + if !ok { + h.fail(w, r, badRequest("member_ids must contain UUIDs")) + return + } + memberIDs[i] = id + } + chat, err := h.chats.Create(r.Context(), actor(r), *req.Title, memberIDs) + if err != nil { + h.fail(w, r, err) + return + } + writeJSON(w, http.StatusCreated, toChatResponse(chat)) +} + +func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) { + limit, cursor, err := pageParams(r) + if err != nil { + h.fail(w, r, err) + return + } + page, err := h.chats.List(r.Context(), actor(r), cursor, limit) + if err != nil { + h.fail(w, r, err) + return + } + writeJSON(w, http.StatusOK, toPageResponse(page, toChatResponse)) +} + +func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) { + chatID, err := chatIDParam(r) + if err != nil { + h.fail(w, r, err) + return + } + chat, err := h.chats.Get(r.Context(), actor(r), chatID) + if err != nil { + h.fail(w, r, err) + return + } + writeJSON(w, http.StatusOK, toChatResponse(chat)) +} + +func chatIDParam(r *http.Request) (uuid.UUID, error) { + id, ok := parseUUID(chi.URLParam(r, "chat_id")) + if !ok { + return uuid.UUID{}, badRequest("chat_id must be a UUID") + } + return id, nil +} + +func parseUUID(s string) (uuid.UUID, bool) { + if len(s) != 36 { + return uuid.UUID{}, false + } + id, err := uuid.Parse(s) + return id, err == nil +} + +func pageParams(r *http.Request) (int, *domain.Cursor, error) { + q := r.URL.Query() + limit := service.DefaultLimit + if q.Has("limit") { + n, err := strconv.Atoi(q.Get("limit")) + if err != nil { + return 0, nil, badRequest("limit must be an integer") + } + limit = n + } + var cursor *domain.Cursor + if q.Has("cursor") { + c, ok := decodeCursor(q.Get("cursor")) + if !ok { + return 0, nil, badRequest("invalid cursor") + } + cursor = &c + } + return limit, cursor, nil +} diff --git a/internal/handler/cursor.go b/internal/handler/cursor.go new file mode 100644 index 00000000..94c3f7ff --- /dev/null +++ b/internal/handler/cursor.go @@ -0,0 +1,34 @@ +package handler + +import ( + "encoding/base64" + "strconv" + "strings" + "time" + "uuid" + + "messenger/internal/domain" +) + +func encodeCursor(c domain.Cursor) string { + raw := c.Scope.String() + "." + strconv.FormatInt(c.CreatedAt.UnixMicro(), 10) + "." + c.ID.String() + return base64.RawURLEncoding.EncodeToString([]byte(raw)) +} + +func decodeCursor(s string) (domain.Cursor, bool) { + raw, err := base64.RawURLEncoding.DecodeString(s) + if err != nil { + return domain.Cursor{}, false + } + parts := strings.Split(string(raw), ".") + if len(parts) != 3 { + return domain.Cursor{}, false + } + scope, err1 := uuid.Parse(parts[0]) + micros, err2 := strconv.ParseInt(parts[1], 10, 64) + id, err3 := uuid.Parse(parts[2]) + if err1 != nil || err2 != nil || err3 != nil { + return domain.Cursor{}, false + } + return domain.Cursor{Scope: scope, CreatedAt: time.UnixMicro(micros).UTC(), ID: id}, true +} diff --git a/internal/handler/dto.go b/internal/handler/dto.go new file mode 100644 index 00000000..ad3773c9 --- /dev/null +++ b/internal/handler/dto.go @@ -0,0 +1,182 @@ +package handler + +import ( + "encoding/json" + "time" + "uuid" + + "messenger/internal/domain" +) + +type createUserRequest struct { + Username *string `json:"username"` + DisplayName *string `json:"display_name"` + Password *string `json:"password"` +} + +type createChatRequest struct { + Title *string `json:"title"` + MemberIDs *[]string `json:"member_ids"` +} + +type createMessageRequest struct { + Text *string `json:"text"` + AttachmentIDs json.RawMessage `json:"attachment_ids"` +} + +type userResponse struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt string `json:"created_at"` +} + +type chatResponse struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` +} + +type messageResponse struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt string `json:"created_at"` + AttachmentIDs []string `json:"attachment_ids"` +} + +type variantResponse struct { + Name string `json:"name"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + Width int `json:"width"` + Height int `json:"height"` + SHA256 string `json:"sha256"` +} + +type attachmentResponse struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + OwnerID string `json:"owner_id"` + Filename string `json:"filename"` + ContentType string `json:"content_type"` + SizeBytes int64 `json:"size_bytes"` + SHA256 string `json:"sha256"` + Status string `json:"status"` + Variants []variantResponse `json:"variants"` + ErrorCode *string `json:"error_code"` + CreatedAt string `json:"created_at"` + UpdatedAt string `json:"updated_at"` +} + +type pageResponse[T any] struct { + Items []T `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +type sessionResponse struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt string `json:"expires_at"` + User userResponse `json:"user"` +} + +type healthResponse struct { + Status string `json:"status"` +} + +type errorBody struct { + Error errorDetails `json:"error"` +} + +type errorDetails struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} + +const timeLayout = "2006-01-02T15:04:05.000000Z" + +func formatTime(t time.Time) string { return t.UTC().Format(timeLayout) } + +func toUserResponse(u domain.User) userResponse { + return userResponse{ + ID: u.ID.String(), + Username: u.Username, + DisplayName: u.DisplayName, + CreatedAt: formatTime(u.CreatedAt), + } +} + +func toSessionResponse(s domain.Session) sessionResponse { + return sessionResponse{ + Token: s.Token, + TokenType: "Bearer", + ExpiresAt: formatTime(s.ExpiresAt), + User: toUserResponse(s.User), + } +} + +func toChatResponse(c domain.Chat) chatResponse { + members := make([]string, len(c.MemberIDs)) + for i, id := range c.MemberIDs { + members[i] = id.String() + } + return chatResponse{ + ID: c.ID.String(), + Title: c.Title, + MemberIDs: members, + CreatedAt: formatTime(c.CreatedAt), + } +} + +func toMessageResponse(m domain.Message) messageResponse { + return messageResponse{ + ID: m.ID.String(), + ChatID: m.ChatID.String(), + SenderID: m.SenderID.String(), + Text: m.Text, + CreatedAt: formatTime(m.CreatedAt), + AttachmentIDs: toIDStrings(m.AttachmentIDs), + } +} + +func toAttachmentResponse(a domain.Attachment) attachmentResponse { + return attachmentResponse{ + ID: a.ID.String(), + ChatID: a.ChatID.String(), + OwnerID: a.OwnerID.String(), + Filename: a.Filename, + ContentType: a.ContentType, + SizeBytes: a.SizeBytes, + SHA256: a.SHA256, + Status: a.Status, + Variants: []variantResponse{}, + ErrorCode: a.ErrorCode, + CreatedAt: formatTime(a.CreatedAt), + UpdatedAt: formatTime(a.UpdatedAt), + } +} + +func toIDStrings(ids []uuid.UUID) []string { + result := make([]string, len(ids)) + for i, id := range ids { + result[i] = id.String() + } + return result +} + +func toPageResponse[D, R any](p domain.Page[D], conv func(D) R) pageResponse[R] { + items := make([]R, len(p.Items)) + for i, it := range p.Items { + items[i] = conv(it) + } + resp := pageResponse[R]{Items: items} + if p.Next != nil { + s := encodeCursor(*p.Next) + resp.NextCursor = &s + } + return resp +} diff --git a/internal/handler/errors.go b/internal/handler/errors.go new file mode 100644 index 00000000..d636b871 --- /dev/null +++ b/internal/handler/errors.go @@ -0,0 +1,59 @@ +package handler + +import ( + "errors" + "net/http" + + "messenger/internal/domain" +) + +type apiError struct { + status int + code string + message string +} + +func (e *apiError) Error() string { return e.message } + +func badRequest(msg string) *apiError { + return &apiError{http.StatusBadRequest, "invalid_request", msg} +} + +func writeError(w http.ResponseWriter, status int, code, message string) { + writeJSON(w, status, errorBody{Error: errorDetails{ + Code: code, + Message: message, + RequestID: w.Header().Get(headerRequestID), + }}) +} + +func (h *Handler) fail(w http.ResponseWriter, r *http.Request, err error) { + var ae *apiError + switch { + case errors.As(err, &ae): + writeError(w, ae.status, ae.code, ae.message) + case errors.Is(err, domain.ErrInvalidInput): + writeError(w, http.StatusBadRequest, "invalid_request", err.Error()) + case errors.Is(err, domain.ErrUnauthorized): + if w.Header().Get(headerWWWAuthenticate) == "" { + w.Header().Set(headerWWWAuthenticate, bearerChallenge) + } + writeError(w, http.StatusUnauthorized, "unauthorized", "valid authentication is required") + case errors.Is(err, domain.ErrNotFound): + writeError(w, http.StatusNotFound, "not_found", "resource not found") + case errors.Is(err, domain.ErrConflict): + writeError(w, http.StatusConflict, "conflict", err.Error()) + case errors.Is(err, domain.ErrTooLarge): + writeError(w, http.StatusRequestEntityTooLarge, "payload_too_large", err.Error()) + case errors.Is(err, domain.ErrUnsupportedMedia): + writeError(w, http.StatusUnsupportedMediaType, "unsupported_media_type", err.Error()) + case errors.Is(err, domain.ErrUnavailable): + h.log.Error("dependency unavailable", "request_id", w.Header().Get(headerRequestID), + "method", r.Method, "path", r.URL.Path, "err", err) + writeError(w, http.StatusServiceUnavailable, "unavailable", "service temporarily unavailable") + default: + h.log.Error("unexpected error", "request_id", w.Header().Get(headerRequestID), + "method", r.Method, "path", r.URL.Path, "err", err) + writeError(w, http.StatusInternalServerError, "internal_error", "internal server error") + } +} diff --git a/internal/handler/handler.go b/internal/handler/handler.go new file mode 100644 index 00000000..a970a5f2 --- /dev/null +++ b/internal/handler/handler.go @@ -0,0 +1,42 @@ +package handler + +import ( + "context" + "log/slog" + "net/http" + "sync/atomic" + + "messenger/internal/service" +) + +type Pinger func(ctx context.Context) error + +type Handler struct { + users *service.UserService + auth *service.AuthService + chats *service.ChatService + messages *service.MessageService + attachments *service.AttachmentService + deps []Pinger + log *slog.Logger + draining atomic.Bool +} + +func New(users *service.UserService, auth *service.AuthService, chats *service.ChatService, + messages *service.MessageService, attachments *service.AttachmentService, + deps []Pinger, log *slog.Logger) *Handler { + return &Handler{users: users, auth: auth, chats: chats, messages: messages, + attachments: attachments, deps: deps, log: log} +} + +func (h *Handler) StartDraining() { + h.draining.Store(true) +} + +func (h *Handler) NotFound(w http.ResponseWriter, _ *http.Request) { + writeError(w, http.StatusNotFound, "not_found", "resource not found") +} + +func (h *Handler) MethodNotAllowed(w http.ResponseWriter, _ *http.Request) { + writeError(w, http.StatusMethodNotAllowed, "invalid_request", "method not allowed") +} diff --git a/internal/handler/handler_test.go b/internal/handler/handler_test.go new file mode 100644 index 00000000..c51af2df --- /dev/null +++ b/internal/handler/handler_test.go @@ -0,0 +1,359 @@ +package handler_test + +import ( + "context" + "encoding/base64" + "encoding/json" + "fmt" + "io" + "log/slog" + "net/http" + "net/http/httptest" + "os" + "strings" + "sync" + "testing" + "time" + "uuid" + + "messenger/internal/domain" + "messenger/internal/handler" + "messenger/internal/repository/postgres" + "messenger/internal/repository/redis" + "messenger/internal/router" + "messenger/internal/service" +) + +type stubObjectStore struct { + objects map[string][]byte +} + +func newStubObjectStore() *stubObjectStore { + return &stubObjectStore{objects: map[string][]byte{}} +} + +func (s *stubObjectStore) Put(_ context.Context, key string, r io.Reader, _ int64, _ string) error { + data, err := io.ReadAll(r) + if err != nil { + return err + } + s.objects[key] = data + return nil +} + +func (s *stubObjectStore) Get(_ context.Context, key string) (io.ReadCloser, error) { + data, ok := s.objects[key] + if !ok { + return nil, domain.ErrNotFound + } + return io.NopCloser(strings.NewReader(string(data))), nil +} + +func (s *stubObjectStore) Delete(_ context.Context, key string) error { + delete(s.objects, key) + return nil +} + +func (s *stubObjectStore) Ping(context.Context) error { return nil } + +func testURLs(t *testing.T) (string, string) { + t.Helper() + dbURL, redisURL := os.Getenv("TEST_DATABASE_URL"), os.Getenv("TEST_REDIS_URL") + if dbURL == "" || redisURL == "" { + t.Skip("TEST_DATABASE_URL and TEST_REDIS_URL are required") + } + return dbURL, redisURL +} + +func newServer(t *testing.T) *httptest.Server { + t.Helper() + dbURL, redisURL := testURLs(t) + return newStack(t, dbURL, redisURL, time.Hour) +} + +func newStack(t *testing.T, dbURL, redisURL string, ttl time.Duration) *httptest.Server { + t.Helper() + pool, err := postgres.NewPool(context.Background(), dbURL) + if err != nil { + t.Fatal(err) + } + t.Cleanup(pool.Close) + store := postgres.New(pool) + client, err := redis.NewClient(redisURL) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { client.Close() }) + sessions := redis.NewSessionStore(client) + + users := service.NewUserService(store) + auth := service.NewAuthService(store, sessions, ttl) + chats := service.NewChatService(store) + messages := service.NewMessageService(chats, store) + attachments := service.NewAttachmentService(chats, store, newStubObjectStore(), 10485760, 40000000, 8, 2) + h := handler.New(users, auth, chats, messages, attachments, []handler.Pinger{store.Ping, sessions.Ping}, slog.New(slog.DiscardHandler)) + srv := httptest.NewServer(router.New(h, "test")) + t.Cleanup(srv.Close) + return srv +} + +type testUser struct { + ID string + Username string + Password string + Token string +} + +func request(t *testing.T, srv *httptest.Server, method, path, token, body string) *http.Response { + t.Helper() + req, err := http.NewRequest(method, srv.URL+path, strings.NewReader(body)) + if err != nil { + t.Fatal(err) + } + if body != "" { + req.Header.Set("Content-Type", "application/json") + } + if token != "" { + req.Header.Set("Authorization", "Bearer "+token) + } + if method == http.MethodPost && strings.HasSuffix(path, "/messages") { + req.Header.Set("Idempotency-Key", uuid.New().String()) + } + resp, err := srv.Client().Do(req) + if err != nil { + t.Fatal(err) + } + return resp +} + +func do(t *testing.T, srv *httptest.Server, method, path, token, body string) (int, map[string]any) { + t.Helper() + resp := request(t, srv, method, path, token, body) + defer resp.Body.Close() + var out map[string]any + if err := json.NewDecoder(resp.Body).Decode(&out); err != nil { + t.Fatalf("%s %s: invalid JSON response: %v", method, path, err) + } + return resp.StatusCode, out +} + +func errorCode(body map[string]any) string { + e, _ := body["error"].(map[string]any) + code, _ := e["code"].(string) + return code +} + +func basic(username, password string) string { + return "Basic " + base64.StdEncoding.EncodeToString([]byte(username+":"+password)) +} + +func login(t *testing.T, srv *httptest.Server, username, password string) *http.Response { + t.Helper() + req, err := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/auth/sessions", nil) + if err != nil { + t.Fatal(err) + } + req.Header.Set("Authorization", basic(username, password)) + resp, err := srv.Client().Do(req) + if err != nil { + t.Fatal(err) + } + return resp +} + +func createUser(t *testing.T, srv *httptest.Server, label string) testUser { + t.Helper() + u := testUser{ + Username: label + "_" + strings.ReplaceAll(uuid.New().String(), "-", "")[:12], + Password: "Test-password-" + label, + } + status, body := do(t, srv, http.MethodPost, "/api/v1/users", "", + fmt.Sprintf(`{"username":%q,"display_name":"Test","password":%q}`, u.Username, u.Password)) + if status != http.StatusCreated { + t.Fatalf("create user %s: status %d", u.Username, status) + } + u.ID = body["id"].(string) + + resp := login(t, srv, u.Username, u.Password) + defer resp.Body.Close() + var session map[string]any + if err := json.NewDecoder(resp.Body).Decode(&session); err != nil || resp.StatusCode != http.StatusCreated { + t.Fatalf("login %s: status %d", u.Username, resp.StatusCode) + } + u.Token = session["token"].(string) + return u +} + +func createChat(t *testing.T, srv *httptest.Server, owner testUser, members ...testUser) string { + t.Helper() + ids := make([]string, len(members)) + for i, m := range members { + ids[i] = m.ID + } + raw, _ := json.Marshal(ids) + status, body := do(t, srv, http.MethodPost, "/api/v1/chats", owner.Token, + fmt.Sprintf(`{"title":"Test","member_ids":%s}`, raw)) + if status != http.StatusCreated { + t.Fatalf("create chat: status %d", status) + } + return body["id"].(string) +} + +func TestInvalidJSON(t *testing.T) { + srv := newServer(t) + for _, body := range []string{`{"username":`, `not json`, `{"username":5,"display_name":"x","password":"long-enough-pass"}`} { + status, resp := do(t, srv, http.MethodPost, "/api/v1/users", "", body) + if status != http.StatusBadRequest || errorCode(resp) != "invalid_request" { + t.Errorf("body %q: got %d %q, want 400 invalid_request", body, status, errorCode(resp)) + } + } +} + +func TestForeignChat(t *testing.T) { + srv := newServer(t) + alice := createUser(t, srv, "alice") + bob := createUser(t, srv, "bob") + eve := createUser(t, srv, "eve") + chat := createChat(t, srv, alice, alice, bob) + + cases := []struct{ method, path, body string }{ + {http.MethodGet, "/api/v1/chats/" + chat, ""}, + {http.MethodGet, "/api/v1/chats/" + chat + "/messages", ""}, + {http.MethodPost, "/api/v1/chats/" + chat + "/messages", `{"text":"hi"}`}, + } + for _, c := range cases { + status, resp := do(t, srv, c.method, c.path, eve.Token, c.body) + if status != http.StatusNotFound || errorCode(resp) != "not_found" { + t.Errorf("%s %s by outsider: got %d, want 404", c.method, c.path, status) + } + } + + status, resp := do(t, srv, http.MethodGet, "/api/v1/chats", eve.Token, "") + if status != http.StatusOK || len(resp["items"].([]any)) != 0 { + t.Errorf("outsider chat list: got %d %v, want 200 with no items", status, resp["items"]) + } +} + +func TestEmptyMessage(t *testing.T) { + srv := newServer(t) + alice := createUser(t, srv, "alice") + chat := createChat(t, srv, alice, alice) + + for _, text := range []string{"", " ", "\n\t"} { + body, _ := json.Marshal(map[string]string{"text": text}) + status, resp := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", alice.Token, string(body)) + if status != http.StatusBadRequest || errorCode(resp) != "invalid_request" { + t.Errorf("text %q: got %d, want 400", text, status) + } + } +} + +func TestDuplicateUsername(t *testing.T) { + srv := newServer(t) + alice := createUser(t, srv, "alice") + status, resp := do(t, srv, http.MethodPost, "/api/v1/users", "", + fmt.Sprintf(`{"username":%q,"display_name":"Other","password":"another-password"}`, alice.Username)) + if status != http.StatusConflict || errorCode(resp) != "conflict" { + t.Errorf("got %d %q, want 409 conflict", status, errorCode(resp)) + } +} + +func TestPaginationMultiplePages(t *testing.T) { + srv := newServer(t) + alice := createUser(t, srv, "alice") + chat := createChat(t, srv, alice, alice) + + const total, limit = 7, 3 + for i := range total { + status, _ := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", alice.Token, fmt.Sprintf(`{"text":"msg %d"}`, i)) + if status != http.StatusCreated { + t.Fatalf("send message %d: status %d", i, status) + } + } + + seen := map[string]bool{} + pages := 0 + prevCreatedAt := "" + cursor := "" + for { + path := fmt.Sprintf("/api/v1/chats/%s/messages?limit=%d", chat, limit) + if cursor != "" { + path += "&cursor=" + cursor + } + status, resp := do(t, srv, http.MethodGet, path, alice.Token, "") + if status != http.StatusOK { + t.Fatalf("page %d: status %d", pages+1, status) + } + pages++ + for _, it := range resp["items"].([]any) { + m := it.(map[string]any) + id, createdAt := m["id"].(string), m["created_at"].(string) + if seen[id] { + t.Errorf("message %s returned twice", id) + } + if createdAt < prevCreatedAt { + t.Errorf("messages out of order: %s after %s", createdAt, prevCreatedAt) + } + seen[id] = true + prevCreatedAt = createdAt + } + next, ok := resp["next_cursor"].(string) + if !ok { + break + } + cursor = next + } + + if len(seen) != total { + t.Errorf("got %d messages, want %d", len(seen), total) + } + if want := (total + limit - 1) / limit; pages != want { + t.Errorf("got %d pages, want %d", pages, want) + } +} + +func TestConcurrentMessages(t *testing.T) { + srv := newServer(t) + const clients, perClient = 10, 10 + + users := make([]testUser, clients) + for i := range users { + users[i] = createUser(t, srv, fmt.Sprintf("client_%d", i)) + } + chat := createChat(t, srv, users[0], users...) + + var wg sync.WaitGroup + errs := make(chan error, clients*perClient) + for c, user := range users { + wg.Go(func() { + for i := range perClient { + status, _ := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", user.Token, + fmt.Sprintf(`{"text":"client %d msg %d"}`, c, i)) + if status != http.StatusCreated { + errs <- fmt.Errorf("client %d msg %d: status %d", c, i, status) + } + } + }) + } + wg.Wait() + close(errs) + for err := range errs { + t.Error(err) + } + + status, resp := do(t, srv, http.MethodGet, "/api/v1/chats/"+chat+"/messages?limit=100", users[0].Token, "") + if status != http.StatusOK { + t.Fatalf("read history: status %d", status) + } + items := resp["items"].([]any) + ids := map[string]bool{} + for _, it := range items { + ids[it.(map[string]any)["id"].(string)] = true + } + if len(items) != clients*perClient || len(ids) != clients*perClient { + t.Errorf("got %d messages (%d unique), want %d", len(items), len(ids), clients*perClient) + } + if resp["next_cursor"] != nil { + t.Errorf("next_cursor = %v, want null", resp["next_cursor"]) + } +} diff --git a/internal/handler/health.go b/internal/handler/health.go new file mode 100644 index 00000000..375ee0b8 --- /dev/null +++ b/internal/handler/health.go @@ -0,0 +1,32 @@ +package handler + +import ( + "context" + "fmt" + "net/http" + "time" + + "messenger/internal/domain" +) + +const readyTimeout = time.Second + +func (h *Handler) Live(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, healthResponse{Status: "ok"}) +} + +func (h *Handler) Ready(w http.ResponseWriter, r *http.Request) { + if h.draining.Load() { + h.fail(w, r, fmt.Errorf("%w: draining", domain.ErrUnavailable)) + return + } + ctx, cancel := context.WithTimeout(r.Context(), readyTimeout) + defer cancel() + for _, dep := range h.deps { + if err := dep(ctx); err != nil { + h.fail(w, r, fmt.Errorf("%w: %v", domain.ErrUnavailable, err)) + return + } + } + writeJSON(w, http.StatusOK, healthResponse{Status: "ok"}) +} diff --git a/internal/handler/json.go b/internal/handler/json.go new file mode 100644 index 00000000..54674c25 --- /dev/null +++ b/internal/handler/json.go @@ -0,0 +1,86 @@ +package handler + +import ( + "bytes" + "encoding/json" + "errors" + "io" + "mime" + "net/http" + "reflect" + "strings" + "unicode/utf8" +) + +const maxBodyBytes = 1 << 20 + +func writeJSON(w http.ResponseWriter, status int, v any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(v) +} + +func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) error { + mt, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil || mt != "application/json" { + return &apiError{http.StatusUnsupportedMediaType, "unsupported_media_type", "Content-Type must be application/json"} + } + + raw, err := io.ReadAll(http.MaxBytesReader(w, r.Body, maxBodyBytes)) + if err != nil { + var tooLarge *http.MaxBytesError + if errors.As(err, &tooLarge) { + return &apiError{http.StatusRequestEntityTooLarge, "payload_too_large", "request body is too large"} + } + return badRequest("failed to read request body") + } + if !utf8.Valid(raw) { + return badRequest("request body must be valid UTF-8") + } + if err := checkKeys(raw, dst); err != nil { + return err + } + + dec := json.NewDecoder(bytes.NewReader(raw)) + dec.DisallowUnknownFields() + if err := dec.Decode(dst); err != nil { + return badRequest("request body must be a valid JSON object matching the schema") + } + if err := dec.Decode(&struct{}{}); !errors.Is(err, io.EOF) { + return badRequest("request body must contain a single JSON object") + } + return nil +} + +func checkKeys(raw []byte, dst any) error { + allowed := jsonFields(dst) + dec := json.NewDecoder(bytes.NewReader(raw)) + if tok, err := dec.Token(); err != nil || tok != json.Delim('{') { + return badRequest("request body must be a JSON object") + } + for dec.More() { + tok, err := dec.Token() + if err != nil { + return badRequest("request body must be a valid JSON object matching the schema") + } + key, _ := tok.(string) + if !allowed[key] { + return badRequest("request body contains unknown field") + } + var value json.RawMessage + if err := dec.Decode(&value); err != nil { + return badRequest("request body must be a valid JSON object matching the schema") + } + } + return nil +} + +func jsonFields(dst any) map[string]bool { + t := reflect.TypeOf(dst).Elem() + fields := make(map[string]bool, t.NumField()) + for i := range t.NumField() { + name, _, _ := strings.Cut(t.Field(i).Tag.Get("json"), ",") + fields[name] = true + } + return fields +} diff --git a/internal/handler/messages.go b/internal/handler/messages.go new file mode 100644 index 00000000..0cc4039e --- /dev/null +++ b/internal/handler/messages.go @@ -0,0 +1,81 @@ +package handler + +import ( + "bytes" + "encoding/json" + "net/http" + "regexp" + "uuid" +) + +const headerIdempotencyKey = "Idempotency-Key" + +var idempotencyKeyRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + +func (h *Handler) SendMessage(w http.ResponseWriter, r *http.Request) { + chatID, err := chatIDParam(r) + if err != nil { + h.fail(w, r, err) + return + } + key := r.Header.Get(headerIdempotencyKey) + if !idempotencyKeyRe.MatchString(key) { + h.fail(w, r, badRequest("Idempotency-Key header must match [A-Za-z0-9._:-]{1,128}")) + return + } + var req createMessageRequest + if err := decodeJSON(w, r, &req); err != nil { + h.fail(w, r, err) + return + } + if req.Text == nil { + h.fail(w, r, badRequest("text is required")) + return + } + var attachmentIDs []uuid.UUID + if len(req.AttachmentIDs) > 0 { + if bytes.Equal(bytes.TrimSpace(req.AttachmentIDs), []byte("null")) { + h.fail(w, r, badRequest("attachment_ids must be an array of UUIDs")) + return + } + var raw []string + if err := json.Unmarshal(req.AttachmentIDs, &raw); err != nil { + h.fail(w, r, badRequest("attachment_ids must be an array of UUIDs")) + return + } + attachmentIDs = make([]uuid.UUID, len(raw)) + for i, value := range raw { + id, ok := parseUUID(value) + if !ok { + h.fail(w, r, badRequest("attachment_ids must contain UUIDs")) + return + } + attachmentIDs[i] = id + } + } + msg, err := h.messages.Send(r.Context(), actor(r), chatID, key, *req.Text, attachmentIDs) + if err != nil { + h.fail(w, r, err) + return + } + writeJSON(w, http.StatusCreated, toMessageResponse(msg)) +} + +func (h *Handler) ListMessages(w http.ResponseWriter, r *http.Request) { + chatID, err := chatIDParam(r) + if err != nil { + h.fail(w, r, err) + return + } + limit, cursor, err := pageParams(r) + if err != nil { + h.fail(w, r, err) + return + } + page, err := h.messages.History(r.Context(), actor(r), chatID, cursor, limit) + if err != nil { + h.fail(w, r, err) + return + } + writeJSON(w, http.StatusOK, toPageResponse(page, toMessageResponse)) +} diff --git a/internal/handler/middleware.go b/internal/handler/middleware.go new file mode 100644 index 00000000..1deafcc9 --- /dev/null +++ b/internal/handler/middleware.go @@ -0,0 +1,122 @@ +package handler + +import ( + "context" + "errors" + "net/http" + "runtime/debug" + "strings" + "time" + "uuid" + + "github.com/go-chi/chi/v5" + "github.com/go-chi/chi/v5/middleware" + + "messenger/internal/domain" +) + +const ( + headerRequestID = "X-Request-Id" + headerInstanceID = "X-Instance-Id" + headerWWWAuthenticate = "WWW-Authenticate" + bearerChallenge = `Bearer realm="messenger"` + basicChallenge = `Basic realm="messenger", charset="UTF-8"` +) + +func InstanceID(id string) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set(headerInstanceID, id) + next.ServeHTTP(w, r) + }) + } +} + +func RequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set(headerRequestID, uuid.New().String()) + next.ServeHTTP(w, r) + }) +} + +func (h *Handler) AccessLog(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor) + next.ServeHTTP(ww, r) + + route := r.URL.Path + if rc := chi.RouteContext(r.Context()); rc != nil && rc.RoutePattern() != "" { + route = rc.RoutePattern() + } + h.log.Info("request", + "request_id", w.Header().Get(headerRequestID), + "method", r.Method, + "route", route, + "status", ww.Status(), + "duration_ms", time.Since(start).Milliseconds(), + ) + }) +} + +func (h *Handler) Recoverer(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + defer func() { + rec := recover() + if rec == nil { + return + } + if rec == http.ErrAbortHandler { + panic(rec) + } + h.log.Error("panic", "request_id", w.Header().Get(headerRequestID), + "method", r.Method, "path", r.URL.Path, "panic", rec, "stack", string(debug.Stack())) + writeError(w, http.StatusInternalServerError, "internal_error", "internal server error") + }() + next.ServeHTTP(w, r) + }) +} + +type ctxKey struct{} + +type principal struct { + user domain.User + token string +} + +func (h *Handler) Authenticate(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + token, ok := authCredentials(r, "Bearer") + if !ok || token == "" { + h.fail(w, r, domain.ErrUnauthorized) + return + } + user, err := h.auth.Authenticate(r.Context(), token) + if err != nil { + h.fail(w, r, err) + return + } + ctx := context.WithValue(r.Context(), ctxKey{}, principal{user: user, token: token}) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func authCredentials(r *http.Request, scheme string) (string, bool) { + gotScheme, credentials, ok := strings.Cut(r.Header.Get("Authorization"), " ") + if !ok || !strings.EqualFold(gotScheme, scheme) { + return "", false + } + return credentials, true +} + +func current(r *http.Request) principal { + p, ok := r.Context().Value(ctxKey{}).(principal) + if !ok { + panic(errors.New("handler: actor requested on unauthenticated route")) + } + return p +} + +func actor(r *http.Request) domain.User { + return current(r).user +} diff --git a/internal/handler/users.go b/internal/handler/users.go new file mode 100644 index 00000000..c427ca4e --- /dev/null +++ b/internal/handler/users.go @@ -0,0 +1,25 @@ +package handler + +import "net/http" + +func (h *Handler) RegisterUser(w http.ResponseWriter, r *http.Request) { + var req createUserRequest + if err := decodeJSON(w, r, &req); err != nil { + h.fail(w, r, err) + return + } + if req.Username == nil || req.DisplayName == nil || req.Password == nil { + h.fail(w, r, badRequest("username, display_name and password are required strings")) + return + } + user, err := h.users.Register(r.Context(), *req.Username, *req.DisplayName, *req.Password) + if err != nil { + h.fail(w, r, err) + return + } + writeJSON(w, http.StatusCreated, toUserResponse(user)) +} + +func (h *Handler) CurrentUser(w http.ResponseWriter, r *http.Request) { + writeJSON(w, http.StatusOK, toUserResponse(actor(r))) +} diff --git a/internal/reconcile/reconcile.go b/internal/reconcile/reconcile.go new file mode 100644 index 00000000..847f0953 --- /dev/null +++ b/internal/reconcile/reconcile.go @@ -0,0 +1,107 @@ +package reconcile + +import ( + "sort" + "strings" + "time" + "uuid" +) + +type Object struct { + Key string + Size int64 + LastModified time.Time +} + +type Metadata struct { + ID uuid.UUID + ObjectKey string + ChatID uuid.UUID + CreatedAt time.Time +} + +type Orphan struct { + Key string `json:"key"` + SizeBytes int64 `json:"size_bytes"` + LastModified string `json:"last_modified"` + AgeSeconds int64 `json:"age_seconds"` +} + +type Missing struct { + ID string `json:"id"` + ObjectKey string `json:"object_key"` + ChatID string `json:"chat_id"` + CreatedAt string `json:"created_at"` + Referenced bool `json:"referenced_by_message"` +} + +type Report struct { + Prefix string `json:"prefix"` + GraceSeconds int64 `json:"grace_seconds"` + DryRun bool `json:"dry_run"` + ScannedObjects int `json:"scanned_objects"` + ScannedRows int `json:"scanned_rows"` + Truncated bool `json:"truncated"` + Orphans []Orphan `json:"orphans"` + Missing []Missing `json:"missing"` + DeletedObjects int `json:"deleted_objects"` + DeletedMetadata int `json:"deleted_metadata"` + RetainedMissing int `json:"retained_missing"` + DeleteFailures int `json:"delete_failures"` + S3Requests int64 `json:"s3_requests"` + DBQueries int `json:"db_queries"` + DurationMS int64 `json:"duration_ms"` + ObjectsPerSecond float64 `json:"objects_per_second"` +} + +func Plan(objects []Object, rows []Metadata, referenced map[uuid.UUID]bool, prefix string, now time.Time, grace time.Duration) ([]Orphan, []Missing) { + known := make(map[string]struct{}, len(rows)) + existing := make(map[string]struct{}, len(objects)) + for _, row := range rows { + known[row.ObjectKey] = struct{}{} + } + for _, object := range objects { + existing[object.Key] = struct{}{} + } + + orphans := make([]Orphan, 0) + for _, object := range objects { + if !strings.HasPrefix(object.Key, prefix) { + continue + } + if _, ok := known[object.Key]; ok { + continue + } + age := now.Sub(object.LastModified) + if age < grace { + continue + } + orphans = append(orphans, Orphan{ + Key: object.Key, + SizeBytes: object.Size, + LastModified: object.LastModified.UTC().Format(time.RFC3339), + AgeSeconds: int64(age.Seconds()), + }) + } + + missing := make([]Missing, 0) + for _, row := range rows { + if !strings.HasPrefix(row.ObjectKey, prefix) { + continue + } + if _, ok := existing[row.ObjectKey]; ok { + continue + } + missing = append(missing, Missing{ + ID: row.ID.String(), + ObjectKey: row.ObjectKey, + ChatID: row.ChatID.String(), + CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339), + Referenced: referenced[row.ID], + }) + } + + sort.Slice(orphans, func(i, j int) bool { return orphans[i].Key < orphans[j].Key }) + sort.Slice(missing, func(i, j int) bool { return missing[i].ObjectKey < missing[j].ObjectKey }) + return orphans, missing +} diff --git a/internal/reconcile/reconcile_test.go b/internal/reconcile/reconcile_test.go new file mode 100644 index 00000000..bbd101ba --- /dev/null +++ b/internal/reconcile/reconcile_test.go @@ -0,0 +1,99 @@ +package reconcile + +import ( + "testing" + "time" + "uuid" +) + +func TestPlanDetectsOrphansAndMissing(t *testing.T) { + now := time.Date(2026, 11, 20, 12, 0, 0, 0, time.UTC) + usedID, missingID, unreferencedID := uuid.New(), uuid.New(), uuid.New() + objects := []Object{ + {Key: "chats/a/used", Size: 10, LastModified: now.Add(-2 * time.Hour)}, + {Key: "chats/a/orphan-old", Size: 20, LastModified: now.Add(-2 * time.Hour)}, + {Key: "chats/a/orphan-fresh", Size: 30, LastModified: now.Add(-1 * time.Minute)}, + {Key: "other/prefix/ignored", Size: 40, LastModified: now.Add(-2 * time.Hour)}, + } + rows := []Metadata{ + {ID: usedID, ObjectKey: "chats/a/used", ChatID: uuid.New(), CreatedAt: now.Add(-2 * time.Hour)}, + {ID: missingID, ObjectKey: "chats/a/missing-referenced", ChatID: uuid.New(), CreatedAt: now.Add(-2 * time.Hour)}, + {ID: unreferencedID, ObjectKey: "chats/a/missing-orphan-row", ChatID: uuid.New(), CreatedAt: now.Add(-2 * time.Hour)}, + } + referenced := map[uuid.UUID]bool{missingID: true} + + orphans, missing := Plan(objects, rows, referenced, "chats/", now, time.Hour) + + if len(orphans) != 1 || orphans[0].Key != "chats/a/orphan-old" { + t.Fatalf("orphans = %+v, want only chats/a/orphan-old", orphans) + } + if len(missing) != 2 { + t.Fatalf("missing = %+v, want two rows", missing) + } + byKey := map[string]Missing{} + for _, item := range missing { + byKey[item.ObjectKey] = item + } + if !byKey["chats/a/missing-referenced"].Referenced { + t.Error("referenced missing row must be flagged") + } + if byKey["chats/a/missing-orphan-row"].Referenced { + t.Error("unreferenced missing row must not be flagged") + } +} + +func TestPlanHonoursGraceAndPrefix(t *testing.T) { + now := time.Date(2026, 11, 20, 12, 0, 0, 0, time.UTC) + objects := []Object{ + {Key: "chats/a/fresh", Size: 1, LastModified: now.Add(-30 * time.Second)}, + {Key: "outside/key", Size: 1, LastModified: now.Add(-48 * time.Hour)}, + } + orphans, _ := Plan(objects, nil, nil, "chats/", now, time.Hour) + if len(orphans) != 0 { + t.Fatalf("orphans = %+v, want none", orphans) + } + + orphans, _ = Plan(objects, nil, nil, "chats/", now, 0) + if len(orphans) != 1 || orphans[0].Key != "chats/a/fresh" { + t.Fatalf("orphans with zero grace = %+v, want chats/a/fresh", orphans) + } +} + +func TestPlanNeverDeletesReferencedObjects(t *testing.T) { + now := time.Date(2026, 11, 20, 12, 0, 0, 0, time.UTC) + objects := []Object{{Key: "chats/a/used", Size: 1, LastModified: now.Add(-100 * time.Hour)}} + rows := []Metadata{{ID: uuid.New(), ObjectKey: "chats/a/used", ChatID: uuid.New(), CreatedAt: now.Add(-100 * time.Hour)}} + + orphans, missing := Plan(objects, rows, nil, "chats/", now, 0) + if len(orphans) != 0 { + t.Fatalf("orphans = %+v, want none for referenced object", orphans) + } + if len(missing) != 0 { + t.Fatalf("missing = %+v, want none", missing) + } +} + +func TestPlanOnlyReportsRowsInsidePrefix(t *testing.T) { + now := time.Date(2026, 11, 20, 12, 0, 0, 0, time.UTC) + rows := []Metadata{ + {ID: uuid.New(), ObjectKey: "chats/a/inside", ChatID: uuid.New(), CreatedAt: now}, + {ID: uuid.New(), ObjectKey: "bench/outside", ChatID: uuid.New(), CreatedAt: now}, + } + _, missing := Plan(nil, rows, nil, "chats/", now, 0) + if len(missing) != 1 || missing[0].ObjectKey != "chats/a/inside" { + t.Fatalf("missing = %+v, want only rows under the scanned prefix", missing) + } +} + +func TestPlanOutputIsSorted(t *testing.T) { + now := time.Date(2026, 11, 20, 12, 0, 0, 0, time.UTC) + objects := []Object{ + {Key: "chats/a/z", LastModified: now.Add(-time.Hour)}, + {Key: "chats/a/b", LastModified: now.Add(-time.Hour)}, + {Key: "chats/a/m", LastModified: now.Add(-time.Hour)}, + } + orphans, _ := Plan(objects, nil, nil, "chats/", now, 0) + if len(orphans) != 3 || orphans[0].Key != "chats/a/b" || orphans[2].Key != "chats/a/z" { + t.Fatalf("orphans are not sorted: %+v", orphans) + } +} diff --git a/internal/repository/postgres/migrations/000001_init.down.sql b/internal/repository/postgres/migrations/000001_init.down.sql new file mode 100644 index 00000000..1ba630fa --- /dev/null +++ b/internal/repository/postgres/migrations/000001_init.down.sql @@ -0,0 +1,4 @@ +DROP TABLE IF EXISTS messages; +DROP TABLE IF EXISTS chat_members; +DROP TABLE IF EXISTS chats; +DROP TABLE IF EXISTS users; diff --git a/internal/repository/postgres/migrations/000001_init.up.sql b/internal/repository/postgres/migrations/000001_init.up.sql new file mode 100644 index 00000000..694ae232 --- /dev/null +++ b/internal/repository/postgres/migrations/000001_init.up.sql @@ -0,0 +1,32 @@ +CREATE TABLE 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 +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id), + position int NOT NULL, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_id_idx ON chat_members (user_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL, + created_at timestamptz NOT NULL +); + +CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); diff --git a/internal/repository/postgres/migrations/000002_message_idempotency.down.sql b/internal/repository/postgres/migrations/000002_message_idempotency.down.sql new file mode 100644 index 00000000..64acde88 --- /dev/null +++ b/internal/repository/postgres/migrations/000002_message_idempotency.down.sql @@ -0,0 +1 @@ +DROP TABLE message_idempotency; diff --git a/internal/repository/postgres/migrations/000002_message_idempotency.up.sql b/internal/repository/postgres/migrations/000002_message_idempotency.up.sql new file mode 100644 index 00000000..d10b7a91 --- /dev/null +++ b/internal/repository/postgres/migrations/000002_message_idempotency.up.sql @@ -0,0 +1,9 @@ +CREATE TABLE message_idempotency ( + user_id uuid NOT NULL REFERENCES users (id), + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + key text NOT NULL, + request_hash text NOT NULL, + message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, + created_at timestamptz NOT NULL, + PRIMARY KEY (user_id, chat_id, key) +); diff --git a/internal/repository/postgres/migrations/000003_attachments.down.sql b/internal/repository/postgres/migrations/000003_attachments.down.sql new file mode 100644 index 00000000..aa89863e --- /dev/null +++ b/internal/repository/postgres/migrations/000003_attachments.down.sql @@ -0,0 +1,2 @@ +DROP TABLE IF EXISTS message_attachments; +DROP TABLE IF EXISTS attachments; \ No newline at end of file diff --git a/internal/repository/postgres/migrations/000003_attachments.up.sql b/internal/repository/postgres/migrations/000003_attachments.up.sql new file mode 100644 index 00000000..f6c0661b --- /dev/null +++ b/internal/repository/postgres/migrations/000003_attachments.up.sql @@ -0,0 +1,25 @@ +CREATE TABLE attachments ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + owner_id uuid NOT NULL REFERENCES users (id), + filename text NOT NULL, + content_type text NOT NULL, + size_bytes bigint NOT NULL, + sha256 text NOT NULL, + object_key text NOT NULL UNIQUE, + status text NOT NULL, + error_code text, + created_at timestamptz NOT NULL, + updated_at timestamptz NOT NULL +); + +CREATE INDEX attachments_chat_created_id_idx ON attachments (chat_id, created_at, id); + +CREATE TABLE message_attachments ( + message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE, + attachment_id uuid NOT NULL REFERENCES attachments (id), + position int NOT NULL, + PRIMARY KEY (message_id, attachment_id) +); + +CREATE INDEX message_attachments_attachment_id_idx ON message_attachments (attachment_id); \ No newline at end of file diff --git a/internal/repository/postgres/postgres_test.go b/internal/repository/postgres/postgres_test.go new file mode 100644 index 00000000..412fb9d8 --- /dev/null +++ b/internal/repository/postgres/postgres_test.go @@ -0,0 +1,103 @@ +package postgres_test + +import ( + "context" + "errors" + "os" + "sync" + "testing" + "time" + "uuid" + + "github.com/jackc/pgx/v5/pgxpool" + + "messenger/internal/domain" + "messenger/internal/repository/postgres" +) + +func newStore(t *testing.T) (*postgres.Store, *pgxpool.Pool) { + t.Helper() + dbURL := os.Getenv("TEST_DATABASE_URL") + if dbURL == "" { + t.Skip("TEST_DATABASE_URL is required") + } + pool, err := postgres.NewPool(context.Background(), dbURL) + if err != nil { + t.Fatal(err) + } + t.Cleanup(pool.Close) + return postgres.New(pool), pool +} + +func newUser(username string) domain.User { + return domain.User{ID: uuid.New(), Username: username, DisplayName: "Test", CreatedAt: time.Now().UTC()} +} + +func TestRegisterUsernameRace(t *testing.T) { + store, pool := newStore(t) + ctx := context.Background() + username := "race_" + uuid.New().String()[:8] + + const workers = 20 + var wg sync.WaitGroup + errs := make([]error, workers) + start := make(chan struct{}) + for i := range workers { + wg.Go(func() { + <-start + errs[i] = store.CreateUser(ctx, newUser(username), "hash") + }) + } + close(start) + wg.Wait() + + created := 0 + for _, err := range errs { + switch { + case err == nil: + created++ + case !errors.Is(err, domain.ErrConflict): + t.Errorf("unexpected error: %v", err) + } + } + if created != 1 { + t.Errorf("created %d users, want exactly 1", created) + } + var rows int + if err := pool.QueryRow(ctx, `SELECT count(*) FROM users WHERE username = $1`, username).Scan(&rows); err != nil { + t.Fatal(err) + } + if rows != 1 { + t.Errorf("users rows = %d, want 1", rows) + } +} + +func TestCreateChatRollback(t *testing.T) { + store, pool := newStore(t) + ctx := context.Background() + alice := newUser("rb_" + uuid.New().String()[:8]) + if err := store.CreateUser(ctx, alice, "hash"); err != nil { + t.Fatal(err) + } + + chat := domain.Chat{ + ID: uuid.New(), + Title: "rollback", + MemberIDs: []uuid.UUID{alice.ID, uuid.New()}, + CreatedAt: time.Now().UTC(), + } + if err := store.CreateChat(ctx, chat); !errors.Is(err, domain.ErrNotFound) { + t.Fatalf("CreateChat with unknown member: got %v, want ErrNotFound", err) + } + + var chats, members int + if err := pool.QueryRow(ctx, `SELECT count(*) FROM chats WHERE id = $1`, chat.ID).Scan(&chats); err != nil { + t.Fatal(err) + } + if err := pool.QueryRow(ctx, `SELECT count(*) FROM chat_members WHERE chat_id = $1`, chat.ID).Scan(&members); err != nil { + t.Fatal(err) + } + if chats != 0 || members != 0 { + t.Errorf("after rollback: chats=%d chat_members=%d, want 0 and 0", chats, members) + } +} diff --git a/internal/repository/postgres/store.go b/internal/repository/postgres/store.go new file mode 100644 index 00000000..7a91e04e --- /dev/null +++ b/internal/repository/postgres/store.go @@ -0,0 +1,355 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + "time" + "uuid" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "messenger/internal/domain" +) + +const ( + maxConns = 10 + connectTimeout = 3 * time.Second + statementTimeout = "5000" +) + +type Store struct { + pool *pgxpool.Pool +} + +func NewPool(ctx context.Context, databaseURL string) (*pgxpool.Pool, error) { + cfg, err := pgxpool.ParseConfig(databaseURL) + if err != nil { + return nil, err + } + cfg.MaxConns = maxConns + cfg.ConnConfig.ConnectTimeout = connectTimeout + cfg.ConnConfig.RuntimeParams["statement_timeout"] = statementTimeout + return pgxpool.NewWithConfig(ctx, cfg) +} + +func New(pool *pgxpool.Pool) *Store { + return &Store{pool: pool} +} + +func (s *Store) Ping(ctx context.Context) error { + return dbErr(s.pool.Ping(ctx)) +} + +func (s *Store) CreateUser(ctx context.Context, u domain.User, passwordHash string) error { + _, err := s.pool.Exec(ctx, + `INSERT INTO users (id, username, display_name, password_hash, created_at) VALUES ($1, $2, $3, $4, $5)`, + u.ID, u.Username, u.DisplayName, passwordHash, u.CreatedAt) + return dbErr(err) +} + +func (s *Store) GetUser(ctx context.Context, id uuid.UUID) (domain.User, error) { + var u domain.User + err := s.pool.QueryRow(ctx, + `SELECT id, username, display_name, created_at FROM users WHERE id = $1`, id, + ).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + return u, dbErr(err) +} + +func (s *Store) GetUserByUsername(ctx context.Context, username string) (domain.User, string, error) { + var u domain.User + var hash string + err := s.pool.QueryRow(ctx, + `SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1`, username, + ).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash) + return u, hash, dbErr(err) +} + +func (s *Store) CreateChat(ctx context.Context, c domain.Chat) error { + tx, err := s.pool.Begin(ctx) + if err != nil { + return dbErr(err) + } + defer tx.Rollback(ctx) + + if _, err := tx.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`, + c.ID, c.Title, c.CreatedAt); err != nil { + return dbErr(err) + } + for i, userID := range c.MemberIDs { + if _, err := tx.Exec(ctx, `INSERT INTO chat_members (chat_id, user_id, position) VALUES ($1, $2, $3)`, + c.ID, userID, i); err != nil { + return dbErr(err) + } + } + return dbErr(tx.Commit(ctx)) +} + +func (s *Store) GetChat(ctx context.Context, id uuid.UUID) (domain.Chat, error) { + var c domain.Chat + err := s.pool.QueryRow(ctx, `SELECT id, title, created_at FROM chats WHERE id = $1`, id). + Scan(&c.ID, &c.Title, &c.CreatedAt) + if err != nil { + return domain.Chat{}, dbErr(err) + } + chats := []domain.Chat{c} + if err := s.loadMembers(ctx, chats); err != nil { + return domain.Chat{}, err + } + return chats[0], nil +} + +func (s *Store) ListUserChats(ctx context.Context, userID uuid.UUID, after *domain.Cursor, limit int) ([]domain.Chat, bool, error) { + var rows pgx.Rows + var err error + if after == nil { + rows, err = s.pool.Query(ctx, ` + 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 + ORDER BY c.created_at, c.id + LIMIT $2`, userID, limit+1) + } else { + rows, err = s.pool.Query(ctx, ` + 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 AND (c.created_at, c.id) > ($2, $3) + ORDER BY c.created_at, c.id + LIMIT $4`, userID, after.CreatedAt, after.ID, limit+1) + } + if err != nil { + return nil, false, dbErr(err) + } + chats, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (domain.Chat, error) { + var c domain.Chat + err := row.Scan(&c.ID, &c.Title, &c.CreatedAt) + return c, err + }) + if err != nil { + return nil, false, dbErr(err) + } + more := len(chats) > limit + if more { + chats = chats[:limit] + } + if err := s.loadMembers(ctx, chats); err != nil { + return nil, false, err + } + return chats, more, nil +} + +func (s *Store) loadMembers(ctx context.Context, chats []domain.Chat) error { + if len(chats) == 0 { + return nil + } + ids := make([]uuid.UUID, len(chats)) + index := make(map[uuid.UUID]int, len(chats)) + for i, c := range chats { + ids[i] = c.ID + index[c.ID] = i + } + rows, err := s.pool.Query(ctx, + `SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1) ORDER BY chat_id, position`, ids) + if err != nil { + return dbErr(err) + } + defer rows.Close() + for rows.Next() { + var chatID, userID uuid.UUID + if err := rows.Scan(&chatID, &userID); err != nil { + return dbErr(err) + } + i := index[chatID] + chats[i].MemberIDs = append(chats[i].MemberIDs, userID) + } + return dbErr(rows.Err()) +} + +func (s *Store) CreateMessageIdempotent(ctx context.Context, m domain.Message, key, requestHash string) (domain.Message, error) { + tx, err := s.pool.Begin(ctx) + if err != nil { + return domain.Message{}, dbErr(err) + } + defer tx.Rollback(ctx) + + tag, err := tx.Exec(ctx, ` + INSERT INTO message_idempotency (user_id, chat_id, key, request_hash, message_id, created_at) + VALUES ($1, $2, $3, $4, $5, $6) + ON CONFLICT DO NOTHING`, + m.SenderID, m.ChatID, key, requestHash, m.ID, m.CreatedAt) + if err != nil { + return domain.Message{}, dbErr(err) + } + if tag.RowsAffected() == 0 { + var storedHash string + var stored domain.Message + err := tx.QueryRow(ctx, ` + SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at + FROM message_idempotency k + JOIN messages m ON m.id = k.message_id + WHERE k.user_id = $1 AND k.chat_id = $2 AND k.key = $3`, + m.SenderID, m.ChatID, key, + ).Scan(&storedHash, &stored.ID, &stored.ChatID, &stored.SenderID, &stored.Text, &stored.CreatedAt) + if err != nil { + return domain.Message{}, dbErr(err) + } + if storedHash != requestHash { + return domain.Message{}, domain.ErrConflict + } + rows, err := tx.Query(ctx, + `SELECT attachment_id FROM message_attachments WHERE message_id = $1 ORDER BY position`, stored.ID) + if err != nil { + return domain.Message{}, dbErr(err) + } + stored.AttachmentIDs, err = pgx.CollectRows(rows, func(row pgx.CollectableRow) (uuid.UUID, error) { + var id uuid.UUID + err := row.Scan(&id) + return id, err + }) + if err != nil { + return domain.Message{}, dbErr(err) + } + if stored.AttachmentIDs == nil { + stored.AttachmentIDs = []uuid.UUID{} + } + return stored, nil + } + + if _, err := tx.Exec(ctx, + `INSERT INTO messages (id, chat_id, sender_id, text, created_at) VALUES ($1, $2, $3, $4, $5)`, + m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt); err != nil { + return domain.Message{}, dbErr(err) + } + if len(m.AttachmentIDs) > 0 { + tag, err := tx.Exec(ctx, ` + INSERT INTO message_attachments (message_id, attachment_id, position) + SELECT $1, a.id, u.ord::int + FROM unnest($2::uuid[]) WITH ORDINALITY AS u(id, ord) + JOIN attachments a ON a.id = u.id AND a.chat_id = $3 AND a.status = $4`, + m.ID, m.AttachmentIDs, m.ChatID, domain.AttachmentReady) + if err != nil { + return domain.Message{}, dbErr(err) + } + if int(tag.RowsAffected()) != len(m.AttachmentIDs) { + return domain.Message{}, domain.ErrNotFound + } + } + if err := tx.Commit(ctx); err != nil { + return domain.Message{}, dbErr(err) + } + return m, nil +} + +func (s *Store) ListMessages(ctx context.Context, chatID uuid.UUID, after *domain.Cursor, limit int) ([]domain.Message, bool, error) { + var rows pgx.Rows + var err error + if after == nil { + rows, err = s.pool.Query(ctx, ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + ORDER BY created_at, id + LIMIT $2`, chatID, limit+1) + } else { + rows, err = s.pool.Query(ctx, ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 AND (created_at, id) > ($2, $3) + ORDER BY created_at, id + LIMIT $4`, chatID, after.CreatedAt, after.ID, limit+1) + } + if err != nil { + return nil, false, dbErr(err) + } + msgs, err := pgx.CollectRows(rows, func(row pgx.CollectableRow) (domain.Message, error) { + var m domain.Message + err := row.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt) + return m, err + }) + if err != nil { + return nil, false, dbErr(err) + } + more := len(msgs) > limit + if more { + msgs = msgs[:limit] + } + if err := s.loadMessageAttachments(ctx, msgs); err != nil { + return nil, false, err + } + return msgs, more, nil +} + +func (s *Store) CreateAttachment(ctx context.Context, a domain.Attachment) error { + _, err := s.pool.Exec(ctx, ` + INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status, error_code, created_at, updated_at) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`, + a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes, a.SHA256, a.ObjectKey, a.Status, a.ErrorCode, a.CreatedAt, a.UpdatedAt) + return dbErr(err) +} + +func (s *Store) GetAttachment(ctx context.Context, id uuid.UUID) (domain.Attachment, error) { + var a domain.Attachment + err := s.pool.QueryRow(ctx, ` + SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status, error_code, created_at, updated_at + FROM attachments WHERE id = $1`, id, + ).Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256, &a.ObjectKey, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt) + return a, dbErr(err) +} + +func (s *Store) loadMessageAttachments(ctx context.Context, msgs []domain.Message) error { + for i := range msgs { + msgs[i].AttachmentIDs = []uuid.UUID{} + } + if len(msgs) == 0 { + return nil + } + ids := make([]uuid.UUID, len(msgs)) + index := make(map[uuid.UUID]int, len(msgs)) + for i, m := range msgs { + ids[i] = m.ID + index[m.ID] = i + } + rows, err := s.pool.Query(ctx, + `SELECT message_id, attachment_id FROM message_attachments WHERE message_id = ANY($1) ORDER BY message_id, position`, ids) + if err != nil { + return dbErr(err) + } + defer rows.Close() + for rows.Next() { + var messageID, attachmentID uuid.UUID + if err := rows.Scan(&messageID, &attachmentID); err != nil { + return dbErr(err) + } + i := index[messageID] + msgs[i].AttachmentIDs = append(msgs[i].AttachmentIDs, attachmentID) + } + return dbErr(rows.Err()) +} + +func dbErr(err error) error { + if err == nil { + return nil + } + if errors.Is(err, pgx.ErrNoRows) { + return domain.ErrNotFound + } + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) { + switch pgErr.Code { + case "23505": + return domain.ErrConflict + case "23503": + return domain.ErrNotFound + } + switch pgErr.Code[:2] { + case "08", "53", "57": + return fmt.Errorf("%w: %v", domain.ErrUnavailable, err) + } + return err + } + return fmt.Errorf("%w: %v", domain.ErrUnavailable, err) +} diff --git a/internal/repository/redis/sessions.go b/internal/repository/redis/sessions.go new file mode 100644 index 00000000..1c054cad --- /dev/null +++ b/internal/repository/redis/sessions.go @@ -0,0 +1,71 @@ +package redis + +import ( + "context" + "errors" + "fmt" + "time" + "uuid" + + goredis "github.com/redis/go-redis/v9" + + "messenger/internal/domain" +) + +const keyPrefix = "session:" + +type SessionStore struct { + client *goredis.Client +} + +func NewClient(url string) (*goredis.Client, error) { + opts, err := goredis.ParseURL(url) + if err != nil { + return nil, err + } + opts.PoolSize = 10 + opts.DialTimeout = 2 * time.Second + opts.ReadTimeout = time.Second + opts.WriteTimeout = time.Second + opts.MaxRetries = 0 + return goredis.NewClient(opts), nil +} + +func NewSessionStore(client *goredis.Client) *SessionStore { + return &SessionStore{client: client} +} + +func (s *SessionStore) Ping(ctx context.Context) error { + return cacheErr(s.client.Ping(ctx).Err()) +} + +func (s *SessionStore) Create(ctx context.Context, tokenHash string, userID uuid.UUID, expiresAt time.Time) error { + return cacheErr(s.client.SetArgs(ctx, keyPrefix+tokenHash, userID.String(), + goredis.SetArgs{ExpireAt: expiresAt}).Err()) +} + +func (s *SessionStore) Get(ctx context.Context, tokenHash string) (uuid.UUID, error) { + v, err := s.client.Get(ctx, keyPrefix+tokenHash).Result() + if errors.Is(err, goredis.Nil) { + return uuid.UUID{}, domain.ErrUnauthorized + } + if err != nil { + return uuid.UUID{}, cacheErr(err) + } + id, err := uuid.Parse(v) + if err != nil { + return uuid.UUID{}, domain.ErrUnauthorized + } + return id, nil +} + +func (s *SessionStore) Delete(ctx context.Context, tokenHash string) error { + return cacheErr(s.client.Del(ctx, keyPrefix+tokenHash).Err()) +} + +func cacheErr(err error) error { + if err == nil { + return nil + } + return fmt.Errorf("%w: %v", domain.ErrUnavailable, err) +} diff --git a/internal/repository/s3/store.go b/internal/repository/s3/store.go new file mode 100644 index 00000000..08f1bc12 --- /dev/null +++ b/internal/repository/s3/store.go @@ -0,0 +1,152 @@ +package s3 + +import ( + "context" + "fmt" + "io" + "net/http" + "net/url" + "strings" + "time" + + "github.com/minio/minio-go/v7" + "github.com/minio/minio-go/v7/pkg/credentials" + + "messenger/internal/domain" +) + +type ObjectInfo struct { + Key string + Size int64 + LastModified time.Time +} + +type Store struct { + client *minio.Client + bucket string + region string +} + +func EndpointHost(endpoint string) (string, bool) { + host, secure := endpoint, false + if parsed, err := url.Parse(endpoint); err == nil && parsed.Host != "" { + host = parsed.Host + secure = parsed.Scheme == "https" + } + return strings.TrimRight(host, "/"), secure +} + +func New(endpoint, region, accessKeyID, secretAccessKey, bucket string) (*Store, error) { + return NewWithTransport(endpoint, region, accessKeyID, secretAccessKey, bucket, nil) +} + +func NewWithTransport(endpoint, region, accessKeyID, secretAccessKey, bucket string, transport http.RoundTripper) (*Store, error) { + host, secure := EndpointHost(endpoint) + client, err := minio.New(host, &minio.Options{ + Creds: credentials.NewStaticV4(accessKeyID, secretAccessKey, ""), + Region: region, + Secure: secure, + Transport: transport, + }) + if err != nil { + return nil, err + } + return &Store{client: client, bucket: bucket, region: region}, nil +} + +func (s *Store) EnsureBucket(ctx context.Context) error { + exists, err := s.client.BucketExists(ctx, s.bucket) + if err != nil { + return s.wrap(err) + } + if exists { + return nil + } + if err := s.client.MakeBucket(ctx, s.bucket, minio.MakeBucketOptions{Region: s.region}); err != nil { + switch minio.ToErrorResponse(err).Code { + case "BucketAlreadyOwnedByYou", "BucketAlreadyExists": + return nil + } + return s.wrap(err) + } + return nil +} + +func (s *Store) Ping(ctx context.Context) error { + exists, err := s.client.BucketExists(ctx, s.bucket) + if err != nil { + return s.wrap(err) + } + if !exists { + return fmt.Errorf("%w: bucket is missing", domain.ErrUnavailable) + } + return nil +} + +func (s *Store) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error { + _, err := s.client.PutObject(ctx, s.bucket, key, r, size, minio.PutObjectOptions{ContentType: contentType}) + return s.wrap(err) +} + +func (s *Store) Get(ctx context.Context, key string) (io.ReadCloser, error) { + object, err := s.client.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{}) + if err != nil { + return nil, s.wrap(err) + } + if _, err := object.Stat(); err != nil { + object.Close() + return nil, s.wrap(err) + } + return object, nil +} + +func (s *Store) Delete(ctx context.Context, key string) error { + return s.wrap(s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{})) +} + +func (s *Store) List(ctx context.Context, prefix string, limit int) ([]ObjectInfo, bool, error) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + objects := make([]ObjectInfo, 0, 64) + for info := range s.client.ListObjects(ctx, s.bucket, minio.ListObjectsOptions{Prefix: prefix, Recursive: true}) { + if info.Err != nil { + return nil, false, s.wrap(info.Err) + } + if len(objects) >= limit { + return objects, true, nil + } + objects = append(objects, ObjectInfo{Key: info.Key, Size: info.Size, LastModified: info.LastModified}) + } + return objects, false, nil +} + +func (s *Store) Buckets(ctx context.Context) ([]string, error) { + buckets, err := s.client.ListBuckets(ctx) + if err != nil { + return nil, s.wrap(err) + } + names := make([]string, len(buckets)) + for i, bucket := range buckets { + names[i] = bucket.Name + } + return names, nil +} + +func (s *Store) RemoveBucket(ctx context.Context, bucket string) error { + return s.wrap(s.client.RemoveBucket(ctx, bucket)) +} + +func (s *Store) wrap(err error) error { + if err == nil { + return nil + } + response := minio.ToErrorResponse(err) + switch response.Code { + case "NoSuchKey", "NotFound": + return domain.ErrNotFound + } + if response.StatusCode == http.StatusNotFound { + return domain.ErrNotFound + } + return fmt.Errorf("%w: %v", domain.ErrUnavailable, err) +} diff --git a/internal/router/router.go b/internal/router/router.go new file mode 100644 index 00000000..5ed287c0 --- /dev/null +++ b/internal/router/router.go @@ -0,0 +1,40 @@ +package router + +import ( + "net/http" + + "github.com/go-chi/chi/v5" + + "messenger/internal/handler" +) + +func New(h *handler.Handler, instanceID string) http.Handler { + r := chi.NewRouter() + r.Use(handler.InstanceID(instanceID), handler.RequestID, h.AccessLog, h.Recoverer) + + r.NotFound(h.NotFound) + r.MethodNotAllowed(h.MethodNotAllowed) + + r.Get("/health/live", h.Live) + r.Get("/health/ready", h.Ready) + + r.Route("/api/v1", func(r chi.Router) { + r.Post("/users", h.RegisterUser) + r.Post("/auth/sessions", h.CreateSession) + + r.Group(func(r chi.Router) { + r.Use(h.Authenticate) + r.Delete("/auth/sessions/current", h.DeleteSession) + r.Get("/users/me", h.CurrentUser) + r.Post("/chats", h.CreateChat) + r.Get("/chats", h.ListChats) + r.Get("/chats/{chat_id}", h.GetChat) + r.Post("/chats/{chat_id}/messages", h.SendMessage) + r.Get("/chats/{chat_id}/messages", h.ListMessages) + r.Post("/chats/{chat_id}/attachments", h.UploadAttachment) + r.Get("/attachments/{attachment_id}", h.GetAttachment) + r.Get("/attachments/{attachment_id}/content", h.DownloadAttachment) + }) + }) + return r +} diff --git a/internal/service/attachments.go b/internal/service/attachments.go new file mode 100644 index 00000000..db694cbd --- /dev/null +++ b/internal/service/attachments.go @@ -0,0 +1,224 @@ +package service + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "fmt" + "image" + _ "image/jpeg" + _ "image/png" + "io" + "net/http" + "strings" + "time" + "unicode" + "unicode/utf8" + "uuid" + + "messenger/internal/domain" +) + +const ( + originalVariant = "original" + maxFilenameRunes = 255 + sniffBytes = 512 +) + +type AttachmentService struct { + chats *ChatService + repo AttachmentRepository + store ObjectStore + maxBytes int64 + maxPixels int64 + uploads chan struct{} + decodes chan struct{} +} + +func NewAttachmentService(chats *ChatService, repo AttachmentRepository, store ObjectStore, + maxBytes, maxPixels int64, maxConcurrentUploads, maxConcurrentDecodes int) *AttachmentService { + return &AttachmentService{ + chats: chats, + repo: repo, + store: store, + maxBytes: maxBytes, + maxPixels: maxPixels, + uploads: make(chan struct{}, maxConcurrentUploads), + decodes: make(chan struct{}, maxConcurrentDecodes), + } +} + +func (s *AttachmentService) Upload(ctx context.Context, actor domain.User, chatID uuid.UUID, filename, contentType string, body io.Reader) (domain.Attachment, error) { + if _, err := s.chats.Get(ctx, actor, chatID); err != nil { + return domain.Attachment{}, err + } + if err := checkFilename(filename); err != nil { + return domain.Attachment{}, err + } + if contentType != domain.ContentPNG && contentType != domain.ContentJPEG { + return domain.Attachment{}, fmt.Errorf("%w: content type must be image/png or image/jpeg", domain.ErrUnsupportedMedia) + } + if err := acquire(ctx, s.uploads); err != nil { + return domain.Attachment{}, err + } + defer release(s.uploads) + raw, err := readLimited(body, s.maxBytes) + if err != nil { + return domain.Attachment{}, err + } + if detected := detectImageType(raw); detected != contentType { + return domain.Attachment{}, fmt.Errorf("%w: body does not match the declared image type", domain.ErrUnsupportedMedia) + } + if err := checkPixels(raw, s.maxPixels); err != nil { + return domain.Attachment{}, err + } + if err := s.decode(ctx, raw); err != nil { + return domain.Attachment{}, err + } + + id := uuid.New() + sum := sha256.Sum256(raw) + createdAt := now() + attachment := domain.Attachment{ + ID: id, + ChatID: chatID, + OwnerID: actor.ID, + Filename: filename, + ContentType: contentType, + SizeBytes: int64(len(raw)), + SHA256: hex.EncodeToString(sum[:]), + ObjectKey: "chats/" + chatID.String() + "/" + id.String(), + Status: domain.AttachmentReady, + CreatedAt: createdAt, + UpdatedAt: createdAt, + } + if err := s.store.Put(ctx, attachment.ObjectKey, bytes.NewReader(raw), attachment.SizeBytes, contentType); err != nil { + return domain.Attachment{}, err + } + if err := s.repo.CreateAttachment(ctx, attachment); err != nil { + cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second) + defer cancel() + _ = s.store.Delete(cleanupCtx, attachment.ObjectKey) + return domain.Attachment{}, err + } + return attachment, nil +} + +func (s *AttachmentService) Get(ctx context.Context, actor domain.User, id uuid.UUID) (domain.Attachment, error) { + attachment, err := s.repo.GetAttachment(ctx, id) + if err != nil { + return domain.Attachment{}, err + } + if _, err := s.chats.Get(ctx, actor, attachment.ChatID); err != nil { + return domain.Attachment{}, err + } + return attachment, nil +} + +func (s *AttachmentService) Open(ctx context.Context, actor domain.User, id uuid.UUID, variant string) (domain.Attachment, io.ReadCloser, error) { + if variant == "" { + variant = originalVariant + } + if variant != originalVariant { + return domain.Attachment{}, nil, fmt.Errorf("%w: only the original variant is available", domain.ErrInvalidInput) + } + attachment, err := s.repo.GetAttachment(ctx, id) + if err != nil { + return domain.Attachment{}, nil, err + } + if _, err := s.chats.Get(ctx, actor, attachment.ChatID); err != nil { + return domain.Attachment{}, nil, err + } + if attachment.Status != domain.AttachmentReady { + return domain.Attachment{}, nil, fmt.Errorf("%w: attachment is not ready", domain.ErrConflict) + } + content, err := s.store.Get(ctx, attachment.ObjectKey) + if err != nil { + return domain.Attachment{}, nil, err + } + return attachment, content, nil +} + +func (s *AttachmentService) decode(ctx context.Context, raw []byte) error { + if err := acquire(ctx, s.decodes); err != nil { + return err + } + defer release(s.decodes) + return checkIntegrity(raw) +} + +func acquire(ctx context.Context, sem chan struct{}) error { + select { + case sem <- struct{}{}: + return nil + case <-ctx.Done(): + return fmt.Errorf("%w: request cancelled while waiting for capacity", domain.ErrUnavailable) + } +} + +func release(sem chan struct{}) { <-sem } + +func checkFilename(filename string) error { + if strings.TrimSpace(filename) == "" { + return fmt.Errorf("%w: filename must not be blank", domain.ErrInvalidInput) + } + if n := utf8.RuneCountInString(filename); n > maxFilenameRunes { + return fmt.Errorf("%w: filename must be 1 to 255 characters", domain.ErrInvalidInput) + } + for _, r := range filename { + if unicode.IsControl(r) || r == '/' || r == '\\' { + return fmt.Errorf("%w: filename contains forbidden characters", domain.ErrInvalidInput) + } + } + return nil +} + +func readLimited(body io.Reader, max int64) ([]byte, error) { + raw, err := io.ReadAll(io.LimitReader(body, max+1)) + if err != nil { + return nil, fmt.Errorf("%w: cannot read the upload body", domain.ErrInvalidInput) + } + if int64(len(raw)) > max { + return nil, fmt.Errorf("%w: upload exceeds %d bytes", domain.ErrTooLarge, max) + } + if len(raw) == 0 { + return nil, fmt.Errorf("%w: upload body is empty", domain.ErrUnsupportedMedia) + } + return raw, nil +} + +func detectImageType(raw []byte) string { + sniff := raw + if len(sniff) > sniffBytes { + sniff = sniff[:sniffBytes] + } + switch http.DetectContentType(sniff) { + case domain.ContentPNG: + return domain.ContentPNG + case domain.ContentJPEG: + return domain.ContentJPEG + } + return "" +} + +func checkPixels(raw []byte, max int64) error { + config, _, err := image.DecodeConfig(bytes.NewReader(raw)) + if err != nil { + return fmt.Errorf("%w: image header cannot be decoded", domain.ErrUnsupportedMedia) + } + if config.Width <= 0 || config.Height <= 0 { + return fmt.Errorf("%w: image has invalid dimensions", domain.ErrUnsupportedMedia) + } + if int64(config.Width) > max/int64(config.Height) { + return fmt.Errorf("%w: image exceeds %d pixels", domain.ErrTooLarge, max) + } + return nil +} + +func checkIntegrity(raw []byte) error { + if _, _, err := image.Decode(bytes.NewReader(raw)); err != nil { + return fmt.Errorf("%w: image is corrupted", domain.ErrUnsupportedMedia) + } + return nil +} diff --git a/internal/service/attachments_test.go b/internal/service/attachments_test.go new file mode 100644 index 00000000..5cd187a4 --- /dev/null +++ b/internal/service/attachments_test.go @@ -0,0 +1,157 @@ +package service + +import ( + "bytes" + "encoding/binary" + "errors" + "hash/crc32" + "image" + "image/png" + "strings" + "testing" + "uuid" + + "messenger/internal/domain" +) + +func TestCheckFilename(t *testing.T) { + valid := []string{"photo.png", "фото 1.jpg", strings.Repeat("a", 255)} + for _, name := range valid { + if err := checkFilename(name); err != nil { + t.Errorf("%q: unexpected error %v", name, err) + } + } + invalid := []string{"", strings.Repeat("a", 256), "dir/photo.png", `dir\photo.png`, "photo\x00.png", "photo\n.png", "photo\x7f.png"} + for _, name := range invalid { + if err := checkFilename(name); !errors.Is(err, domain.ErrInvalidInput) { + t.Errorf("%q: got %v, want ErrInvalidInput", name, err) + } + } +} + +func TestDetectImageType(t *testing.T) { + if got := detectImageType(encodePNG(t, 4, 4)); got != domain.ContentPNG { + t.Errorf("png: got %q", got) + } + if got := detectImageType([]byte("not an image at all")); got != "" { + t.Errorf("garbage: got %q", got) + } +} + +func TestCheckPixels(t *testing.T) { + if err := checkPixels(encodePNG(t, 320, 200), 40000000); err != nil { + t.Errorf("small image: unexpected error %v", err) + } + if err := checkPixels(pngHeader(8000, 5000), 40000000); err != nil { + t.Errorf("exact pixel limit: unexpected error %v", err) + } + if err := checkPixels(pngHeader(20000, 2001), 40000000); !errors.Is(err, domain.ErrTooLarge) { + t.Errorf("above pixel limit: got %v, want ErrTooLarge", err) + } + if err := checkPixels(pngHeader(65536, 65536), 40000000); !errors.Is(err, domain.ErrTooLarge) { + t.Errorf("huge dimensions: got %v, want ErrTooLarge", err) + } + if err := checkPixels([]byte("garbage"), 40000000); !errors.Is(err, domain.ErrUnsupportedMedia) { + t.Errorf("garbage: got %v, want ErrUnsupportedMedia", err) + } +} + +func TestCheckIntegrity(t *testing.T) { + if err := checkIntegrity(encodePNG(t, 8, 8)); err != nil { + t.Errorf("valid png: unexpected error %v", err) + } + corrupted := encodePNG(t, 8, 8) + corrupted = corrupted[:len(corrupted)-20] + if err := checkIntegrity(corrupted); !errors.Is(err, domain.ErrUnsupportedMedia) { + t.Errorf("truncated png: got %v, want ErrUnsupportedMedia", err) + } +} + +func TestCheckMessageText(t *testing.T) { + if err := checkMessageText("", false); !errors.Is(err, domain.ErrInvalidInput) { + t.Errorf("empty text without attachments: got %v", err) + } + if err := checkMessageText(" ", false); !errors.Is(err, domain.ErrInvalidInput) { + t.Errorf("blank text without attachments: got %v", err) + } + if err := checkMessageText("", true); err != nil { + t.Errorf("empty text with attachments: unexpected error %v", err) + } + if err := checkMessageText(strings.Repeat("я", 4000), true); err != nil { + t.Errorf("4000 characters: unexpected error %v", err) + } + if err := checkMessageText(strings.Repeat("я", 4001), true); !errors.Is(err, domain.ErrInvalidInput) { + t.Errorf("4001 characters: got %v", err) + } +} + +func TestCheckAttachmentIDs(t *testing.T) { + ids := make([]uuid.UUID, 10) + for i := range ids { + ids[i] = uuid.New() + } + if err := checkAttachmentIDs(ids); err != nil { + t.Errorf("ten unique ids: unexpected error %v", err) + } + if err := checkAttachmentIDs(append(ids, uuid.New())); !errors.Is(err, domain.ErrInvalidInput) { + t.Errorf("eleven ids: got %v", err) + } + if err := checkAttachmentIDs([]uuid.UUID{ids[0], ids[0]}); !errors.Is(err, domain.ErrInvalidInput) { + t.Errorf("duplicate ids: got %v", err) + } +} + +func TestMessageHash(t *testing.T) { + first, second := uuid.New(), uuid.New() + if messageHash("", nil) != messageHash("", []uuid.UUID{}) { + t.Error("absent attachment_ids must hash like an empty list") + } + if messageHash("hi", []uuid.UUID{first, second}) != messageHash("hi", []uuid.UUID{second, first}) { + t.Error("attachment order must not change the hash") + } + if messageHash("hi", nil) == messageHash("hi!", nil) { + t.Error("different text must change the hash") + } + if messageHash("hi", []uuid.UUID{first}) == messageHash("hi", []uuid.UUID{second}) { + t.Error("different attachments must change the hash") + } +} + +func TestReadLimited(t *testing.T) { + raw, err := readLimited(strings.NewReader("abcd"), 4) + if err != nil || string(raw) != "abcd" { + t.Fatalf("exact limit: got %q, %v", raw, err) + } + if _, err := readLimited(strings.NewReader("abcde"), 4); !errors.Is(err, domain.ErrTooLarge) { + t.Errorf("over limit: got %v, want ErrTooLarge", err) + } + if _, err := readLimited(strings.NewReader(""), 4); !errors.Is(err, domain.ErrUnsupportedMedia) { + t.Errorf("empty body: got %v, want ErrUnsupportedMedia", err) + } +} + +func encodePNG(t *testing.T, width, height int) []byte { + t.Helper() + var buffer bytes.Buffer + if err := png.Encode(&buffer, image.NewRGBA(image.Rect(0, 0, width, height))); err != nil { + t.Fatal(err) + } + return buffer.Bytes() +} + +func pngHeader(width, height uint32) []byte { + var buffer bytes.Buffer + buffer.WriteString("\x89PNG\r\n\x1a\n") + header := make([]byte, 13) + binary.BigEndian.PutUint32(header[0:4], width) + binary.BigEndian.PutUint32(header[4:8], height) + header[8], header[9] = 8, 2 + buffer.Write(binary.BigEndian.AppendUint32(nil, uint32(len(header)))) + buffer.WriteString("IHDR") + buffer.Write(header) + checksum := crc32.NewIEEE() + checksum.Write([]byte("IHDR")) + checksum.Write(header) + buffer.Write(binary.BigEndian.AppendUint32(nil, checksum.Sum32())) + return buffer.Bytes() +} diff --git a/internal/service/auth.go b/internal/service/auth.go new file mode 100644 index 00000000..698058af --- /dev/null +++ b/internal/service/auth.go @@ -0,0 +1,74 @@ +package service + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "errors" + "time" + + "messenger/internal/domain" +) + +const tokenBytes = 32 + +type AuthService struct { + users UserRepository + sessions SessionStore + ttl time.Duration +} + +func NewAuthService(users UserRepository, sessions SessionStore, ttl time.Duration) *AuthService { + return &AuthService{users: users, sessions: sessions, ttl: ttl} +} + +func (s *AuthService) Login(ctx context.Context, username, password string) (domain.Session, error) { + user, hash, err := s.users.GetUserByUsername(ctx, username) + if errors.Is(err, domain.ErrNotFound) { + return domain.Session{}, domain.ErrUnauthorized + } + if err != nil { + return domain.Session{}, err + } + ok, err := verifyPassword(password, hash) + if err != nil { + return domain.Session{}, err + } + if !ok { + return domain.Session{}, domain.ErrUnauthorized + } + + raw := make([]byte, tokenBytes) + if _, err := rand.Read(raw); err != nil { + return domain.Session{}, err + } + token := base64.RawURLEncoding.EncodeToString(raw) + expiresAt := now().Add(s.ttl) + if err := s.sessions.Create(ctx, HashToken(token), user.ID, expiresAt); err != nil { + return domain.Session{}, err + } + return domain.Session{Token: token, ExpiresAt: expiresAt, User: user}, nil +} + +func (s *AuthService) Authenticate(ctx context.Context, token string) (domain.User, error) { + userID, err := s.sessions.Get(ctx, HashToken(token)) + if err != nil { + return domain.User{}, err + } + u, err := s.users.GetUser(ctx, userID) + if errors.Is(err, domain.ErrNotFound) { + return domain.User{}, domain.ErrUnauthorized + } + return u, err +} + +func (s *AuthService) Logout(ctx context.Context, token string) error { + return s.sessions.Delete(ctx, HashToken(token)) +} + +func HashToken(token string) string { + sum := sha256.Sum256([]byte(token)) + return hex.EncodeToString(sum[:]) +} diff --git a/internal/service/chats.go b/internal/service/chats.go new file mode 100644 index 00000000..aafa7c56 --- /dev/null +++ b/internal/service/chats.go @@ -0,0 +1,81 @@ +package service + +import ( + "context" + "errors" + "fmt" + "uuid" + + "messenger/internal/domain" +) + +type ChatService struct { + repo ChatRepository +} + +func NewChatService(repo ChatRepository) *ChatService { + return &ChatService{repo: repo} +} + +func (s *ChatService) Create(ctx context.Context, actor domain.User, title string, memberIDs []uuid.UUID) (domain.Chat, error) { + if err := checkText("title", title, 100); err != nil { + return domain.Chat{}, err + } + if len(memberIDs) < 1 || len(memberIDs) > 100 { + return domain.Chat{}, fmt.Errorf("%w: member_ids must contain 1 to 100 users", domain.ErrInvalidInput) + } + seen := make(map[uuid.UUID]struct{}, len(memberIDs)) + for _, id := range memberIDs { + if _, dup := seen[id]; dup { + return domain.Chat{}, fmt.Errorf("%w: member_ids must not contain duplicates", domain.ErrInvalidInput) + } + seen[id] = struct{}{} + } + if _, ok := seen[actor.ID]; !ok { + return domain.Chat{}, fmt.Errorf("%w: member_ids must include the current user", domain.ErrInvalidInput) + } + + c := domain.Chat{ + ID: uuid.New(), + Title: title, + MemberIDs: memberIDs, + CreatedAt: now(), + } + if err := s.repo.CreateChat(ctx, c); err != nil { + if errors.Is(err, domain.ErrNotFound) { + return domain.Chat{}, fmt.Errorf("%w: member_ids contains unknown user", domain.ErrInvalidInput) + } + return domain.Chat{}, err + } + return c, nil +} + +func (s *ChatService) Get(ctx context.Context, actor domain.User, chatID uuid.UUID) (domain.Chat, error) { + c, err := s.repo.GetChat(ctx, chatID) + if err != nil { + return domain.Chat{}, err + } + if !c.HasMember(actor.ID) { + return domain.Chat{}, domain.ErrNotFound + } + return c, nil +} + +func (s *ChatService) List(ctx context.Context, actor domain.User, after *domain.Cursor, limit int) (domain.Page[domain.Chat], error) { + if err := checkLimit(limit); err != nil { + return domain.Page[domain.Chat]{}, err + } + if after != nil && after.Scope != actor.ID { + return domain.Page[domain.Chat]{}, fmt.Errorf("%w: cursor does not belong to this request", domain.ErrInvalidInput) + } + items, more, err := s.repo.ListUserChats(ctx, actor.ID, after, limit) + if err != nil { + return domain.Page[domain.Chat]{}, err + } + page := domain.Page[domain.Chat]{Items: items} + if more { + last := items[len(items)-1] + page.Next = &domain.Cursor{Scope: actor.ID, CreatedAt: last.CreatedAt, ID: last.ID} + } + return page, nil +} diff --git a/internal/service/messages.go b/internal/service/messages.go new file mode 100644 index 00000000..d986f2a6 --- /dev/null +++ b/internal/service/messages.go @@ -0,0 +1,107 @@ +package service + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "errors" + "fmt" + "sort" + "strings" + "unicode/utf8" + "uuid" + + "messenger/internal/domain" +) + +const maxMessageAttachments = 10 + +type MessageService struct { + chats *ChatService + messages MessageRepository +} + +func NewMessageService(chats *ChatService, messages MessageRepository) *MessageService { + return &MessageService{chats: chats, messages: messages} +} + +func (s *MessageService) Send(ctx context.Context, actor domain.User, chatID uuid.UUID, key, text string, attachmentIDs []uuid.UUID) (domain.Message, error) { + if _, err := s.chats.Get(ctx, actor, chatID); err != nil { + return domain.Message{}, err + } + if err := checkMessageText(text, len(attachmentIDs) > 0); err != nil { + return domain.Message{}, err + } + if err := checkAttachmentIDs(attachmentIDs); err != nil { + return domain.Message{}, err + } + m := domain.Message{ + ID: uuid.New(), + ChatID: chatID, + SenderID: actor.ID, + Text: text, + AttachmentIDs: attachmentIDs, + CreatedAt: now(), + } + stored, err := s.messages.CreateMessageIdempotent(ctx, m, key, messageHash(text, attachmentIDs)) + if errors.Is(err, domain.ErrConflict) { + return domain.Message{}, fmt.Errorf("%w: Idempotency-Key was already used with a different body", domain.ErrConflict) + } + return stored, err +} + +func (s *MessageService) History(ctx context.Context, actor domain.User, chatID uuid.UUID, after *domain.Cursor, limit int) (domain.Page[domain.Message], error) { + if _, err := s.chats.Get(ctx, actor, chatID); err != nil { + return domain.Page[domain.Message]{}, err + } + if err := checkLimit(limit); err != nil { + return domain.Page[domain.Message]{}, err + } + if after != nil && after.Scope != chatID { + return domain.Page[domain.Message]{}, fmt.Errorf("%w: cursor belongs to another chat", domain.ErrInvalidInput) + } + items, more, err := s.messages.ListMessages(ctx, chatID, after, limit) + if err != nil { + return domain.Page[domain.Message]{}, err + } + page := domain.Page[domain.Message]{Items: items} + if more { + last := items[len(items)-1] + page.Next = &domain.Cursor{Scope: chatID, CreatedAt: last.CreatedAt, ID: last.ID} + } + return page, nil +} + +func checkMessageText(text string, hasAttachments bool) error { + if utf8.RuneCountInString(text) > 4000 { + return fmt.Errorf("%w: text must be at most 4000 characters", domain.ErrInvalidInput) + } + if !hasAttachments && strings.TrimSpace(text) == "" { + return fmt.Errorf("%w: text must not be empty without attachments", domain.ErrInvalidInput) + } + return nil +} + +func checkAttachmentIDs(ids []uuid.UUID) error { + if len(ids) > maxMessageAttachments { + return fmt.Errorf("%w: attachment_ids must contain at most %d items", domain.ErrInvalidInput, maxMessageAttachments) + } + seen := make(map[uuid.UUID]struct{}, len(ids)) + for _, id := range ids { + if _, duplicate := seen[id]; duplicate { + return fmt.Errorf("%w: attachment_ids must not contain duplicates", domain.ErrInvalidInput) + } + seen[id] = struct{}{} + } + return nil +} + +func messageHash(text string, ids []uuid.UUID) string { + sorted := make([]string, len(ids)) + for i, id := range ids { + sorted[i] = id.String() + } + sort.Strings(sorted) + sum := sha256.Sum256([]byte(text + "\n" + strings.Join(sorted, ","))) + return hex.EncodeToString(sum[:]) +} diff --git a/internal/service/password.go b/internal/service/password.go new file mode 100644 index 00000000..a52c4700 --- /dev/null +++ b/internal/service/password.go @@ -0,0 +1,60 @@ +package service + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "errors" + "fmt" + "strings" + + "golang.org/x/crypto/argon2" +) + +const ( + argonMemory = 19 * 1024 + argonTime = 2 + argonThreads = 1 + argonSaltLen = 16 + argonKeyLen = 32 +) + +var errBadHash = errors.New("malformed password hash") + +func hashPassword(password string) (string, error) { + salt := make([]byte, argonSaltLen) + if _, err := rand.Read(salt); err != nil { + return "", err + } + key := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen) + b64 := base64.RawStdEncoding + return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, argonMemory, argonTime, argonThreads, b64.EncodeToString(salt), b64.EncodeToString(key)), nil +} + +func verifyPassword(password, encoded string) (bool, error) { + parts := strings.Split(encoded, "$") + if len(parts) != 6 || parts[1] != "argon2id" { + return false, errBadHash + } + var version int + var memory, time uint32 + var threads uint8 + if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || version != argon2.Version { + return false, errBadHash + } + if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &time, &threads); err != nil { + return false, errBadHash + } + b64 := base64.RawStdEncoding + salt, err := b64.DecodeString(parts[4]) + if err != nil { + return false, errBadHash + } + want, err := b64.DecodeString(parts[5]) + if err != nil { + return false, errBadHash + } + got := argon2.IDKey([]byte(password), salt, time, memory, threads, uint32(len(want))) + return subtle.ConstantTimeCompare(got, want) == 1, nil +} diff --git a/internal/service/ports.go b/internal/service/ports.go new file mode 100644 index 00000000..fa3229a7 --- /dev/null +++ b/internal/service/ports.go @@ -0,0 +1,49 @@ +package service + +import ( + "context" + "io" + "time" + "uuid" + + "messenger/internal/domain" +) + +type UserRepository interface { + CreateUser(ctx context.Context, u domain.User, passwordHash string) error + GetUser(ctx context.Context, id uuid.UUID) (domain.User, error) + GetUserByUsername(ctx context.Context, username string) (domain.User, string, error) +} + +type ChatRepository interface { + CreateChat(ctx context.Context, c domain.Chat) error + GetChat(ctx context.Context, id uuid.UUID) (domain.Chat, error) + ListUserChats(ctx context.Context, userID uuid.UUID, after *domain.Cursor, limit int) ([]domain.Chat, bool, error) +} + +type MessageRepository interface { + CreateMessageIdempotent(ctx context.Context, m domain.Message, key, requestHash string) (domain.Message, error) + ListMessages(ctx context.Context, chatID uuid.UUID, after *domain.Cursor, limit int) ([]domain.Message, bool, error) +} + +type AttachmentRepository interface { + CreateAttachment(ctx context.Context, a domain.Attachment) error + GetAttachment(ctx context.Context, id uuid.UUID) (domain.Attachment, error) +} + +type ObjectStore interface { + Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error + Get(ctx context.Context, key string) (io.ReadCloser, error) + Delete(ctx context.Context, key string) error + Ping(ctx context.Context) error +} + +type SessionStore interface { + Create(ctx context.Context, tokenHash string, userID uuid.UUID, expiresAt time.Time) error + Get(ctx context.Context, tokenHash string) (uuid.UUID, error) + Delete(ctx context.Context, tokenHash string) error +} + +func now() time.Time { + return time.Now().UTC().Truncate(time.Microsecond) +} diff --git a/internal/service/users.go b/internal/service/users.go new file mode 100644 index 00000000..9b387b4f --- /dev/null +++ b/internal/service/users.go @@ -0,0 +1,59 @@ +package service + +import ( + "context" + "errors" + "fmt" + "regexp" + "unicode/utf8" + "uuid" + + "messenger/internal/domain" +) + +var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +const ( + minPasswordLen = 12 + maxPasswordLen = 128 +) + +type UserService struct { + repo UserRepository +} + +func NewUserService(repo UserRepository) *UserService { + return &UserService{repo: repo} +} + +func (s *UserService) Register(ctx context.Context, username, displayName, password string) (domain.User, error) { + if !usernameRe.MatchString(username) { + return domain.User{}, fmt.Errorf("%w: username must match [a-z0-9_]{3,32}", domain.ErrInvalidInput) + } + if err := checkText("display_name", displayName, 100); err != nil { + return domain.User{}, err + } + if err := checkText("password", password, maxPasswordLen); err != nil { + return domain.User{}, err + } + if utf8.RuneCountInString(password) < minPasswordLen { + return domain.User{}, fmt.Errorf("%w: password must be at least %d characters", domain.ErrInvalidInput, minPasswordLen) + } + hash, err := hashPassword(password) + if err != nil { + return domain.User{}, err + } + u := domain.User{ + ID: uuid.New(), + Username: username, + DisplayName: displayName, + CreatedAt: now(), + } + if err := s.repo.CreateUser(ctx, u, hash); err != nil { + if errors.Is(err, domain.ErrConflict) { + return domain.User{}, fmt.Errorf("%w: username is already taken", domain.ErrConflict) + } + return domain.User{}, err + } + return u, nil +} diff --git a/internal/service/validate.go b/internal/service/validate.go new file mode 100644 index 00000000..68540bc8 --- /dev/null +++ b/internal/service/validate.go @@ -0,0 +1,31 @@ +package service + +import ( + "fmt" + "strings" + "unicode/utf8" + + "messenger/internal/domain" +) + +const ( + DefaultLimit = 50 + MaxLimit = 100 +) + +func checkText(field, value string, maxRunes int) error { + if strings.TrimSpace(value) == "" { + return fmt.Errorf("%w: %s must not be empty", domain.ErrInvalidInput, field) + } + if n := utf8.RuneCountInString(value); n > maxRunes { + return fmt.Errorf("%w: %s must be at most %d characters", domain.ErrInvalidInput, field, maxRunes) + } + return nil +} + +func checkLimit(limit int) error { + if limit < 1 || limit > MaxLimit { + return fmt.Errorf("%w: limit must be between 1 and %d", domain.ErrInvalidInput, MaxLimit) + } + return nil +} diff --git a/scripts/attachments-check.py b/scripts/attachments-check.py new file mode 100755 index 00000000..ca8d3973 --- /dev/null +++ b/scripts/attachments-check.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +"""Attachment contract checks beyond the public smoke; creates synthetic data.""" +import hashlib +import sys +import uuid +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, check, run + +ROOT = Path(__file__).resolve().parents[1] +PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes() + + +def upload(c, actor, chat, content=PNG, filename='sample.png', content_type='image/png', expected=201): + path = '/api/v1/chats/' + chat['id'] + '/attachments?filename=' + filename + return c.call('POST', path, expected, actor=actor, raw=content, headers={'Content-Type': content_type}, schema='Attachment') + + +def main(): + c = Client() + alice, bob, eve, chat = c.bootstrap() + other = c.call('POST', '/api/v1/chats', 201, actor=alice, + body={'title': 'Другой чат', 'member_ids': [alice['id'], bob['id']]}, schema='Chat')['json'] + notes = [] + + att = upload(c, alice, chat)['json'] + notes.append(f"upload 201 ready, sha256={att['sha256']}, size={att['size_bytes']}") + check(att['sha256'] == hashlib.sha256(PNG).hexdigest(), 'sha256 mismatch') + check(att['status'] == 'ready' and att['variants'] == [] and att['error_code'] is None, 'attachment shape') + + jpeg_path = ROOT / 'scripts/fixtures/sample.jpg' + if jpeg_path.is_file(): + jpeg = jpeg_path.read_bytes() + jatt = upload(c, alice, chat, content=jpeg, filename='sample.jpg', content_type='image/jpeg')['json'] + check(jatt['content_type'] == 'image/jpeg' and jatt['sha256'] == hashlib.sha256(jpeg).hexdigest(), + 'jpeg metadata mismatch') + got = c.call('GET', '/api/v1/attachments/' + jatt['id'] + '/content', 200, actor=bob) + check(got['bytes'] == jpeg and got['headers'].get_content_type() == 'image/jpeg', 'jpeg download mismatch') + upload(c, alice, chat, content=jpeg, filename='sample.jpg', content_type='image/png', expected=415) + notes.append('jpeg upload/download byte-identical; jpeg declared as png -> 415') + + large_path = ROOT / 'scripts/fixtures/large.png' + if large_path.is_file(): + large = large_path.read_bytes() + latt = upload(c, alice, chat, content=large, filename='large.png')['json'] + check(latt['size_bytes'] == len(large) and latt['status'] == 'ready', 'image at the pixel limit was rejected') + got = c.call('GET', '/api/v1/attachments/' + latt['id'] + '/content', 200, actor=bob) + check(got['bytes'] == large, 'large image download mismatch') + notes.append('png with 40,000,000 pixels accepted and downloaded byte-identical') + + upload(c, alice, chat, filename='bad/name.png', expected=400) + notes.append('filename with slash -> 400') + upload(c, alice, chat, filename='bad%00name.png', expected=400) + notes.append('filename with NUL -> 400') + upload(c, alice, chat, filename='', expected=400) + notes.append('empty filename -> 400') + upload(c, alice, chat, content_type='image/jpeg', expected=415) + notes.append('declared jpeg with png body -> 415') + upload(c, alice, chat, content=PNG[:-30], expected=415) + notes.append('truncated png -> 415') + upload(c, alice, chat, content=b'\x00' * (10485761), expected=413) + notes.append('10485761 bytes -> 413') + upload(c, alice, chat, content_type='text/plain', expected=415) + notes.append('text/plain -> 415') + + c.call('GET', '/api/v1/attachments/' + att['id'] + '/content?variant=thumbnail', 400, actor=bob) + notes.append('unknown variant -> 400') + c.call('GET', '/api/v1/attachments/' + att['id'] + '/content?variant=original', 200, actor=bob) + notes.append('variant=original -> 200') + c.call('GET', '/api/v1/attachments/' + str(uuid.uuid4()), 404, actor=bob) + notes.append('unknown attachment id -> 404') + c.call('POST', '/api/v1/chats/' + chat['id'] + '/attachments?filename=x.png', 404, actor=eve, + raw=PNG, headers={'Content-Type': 'image/png'}, schema='Attachment') + notes.append('upload by outsider -> 404') + + foreign = upload(c, alice, other)['json'] + key = uuid.uuid4().hex + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 404, actor=alice, + body={'text': '', 'attachment_ids': [foreign['id']]}, headers={'Idempotency-Key': key}) + notes.append('attachment from another chat -> 404') + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 404, actor=alice, + body={'text': '', 'attachment_ids': [str(uuid.uuid4())]}, headers={'Idempotency-Key': uuid.uuid4().hex}) + notes.append('unknown attachment id in message -> 404') + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 400, actor=alice, + body={'text': '', 'attachment_ids': [att['id']] * 2}, headers={'Idempotency-Key': uuid.uuid4().hex}) + notes.append('duplicate attachment_ids -> 400') + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 400, actor=alice, + body={'text': '', 'attachment_ids': [str(uuid.uuid4()) for _ in range(11)]}, + headers={'Idempotency-Key': uuid.uuid4().hex}) + notes.append('eleven attachment_ids -> 400') + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 400, actor=alice, + body={'text': ''}, headers={'Idempotency-Key': uuid.uuid4().hex}) + notes.append('empty text without attachments -> 400') + + key = uuid.uuid4().hex + first = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=alice, + body={'text': 'вложение', 'attachment_ids': [att['id']]}, headers={'Idempotency-Key': key}, schema='Message')['json'] + replay = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=alice, + body={'text': 'вложение', 'attachment_ids': [att['id']]}, headers={'Idempotency-Key': key}, schema='Message')['json'] + check(first == replay, 'idempotent replay with attachments differs') + check(first['attachment_ids'] == [att['id']], 'message lost attachment_ids') + notes.append('idempotent replay with same attachment set -> same message') + + empty_key = uuid.uuid4().hex + without = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=alice, + body={'text': 'без вложений'}, headers={'Idempotency-Key': empty_key}, schema='Message')['json'] + implicit = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=alice, + body={'text': 'без вложений', 'attachment_ids': []}, headers={'Idempotency-Key': empty_key}, schema='Message')['json'] + check(without == implicit, 'absent attachment_ids must equal an empty list') + notes.append('absent attachment_ids equals [] for idempotency') + + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, actor=alice, + body={'text': 'вложение', 'attachment_ids': []}, headers={'Idempotency-Key': key}) + notes.append('same key with a different attachment set -> 409') + + history = c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=100', 200, actor=bob, + schema='MessagePage')['json']['items'] + check(all(isinstance(m['attachment_ids'], list) for m in history), 'attachment_ids must always be an array') + check(any(m['id'] == first['id'] and m['attachment_ids'] == [att['id']] for m in history), + 'history lost attachments') + notes.append('history exposes attachment_ids on every message') + + for line in notes: + print('ok:', line) + print(f'PASS: {len(notes)} attachment contract checks') + + +if __name__ == '__main__': + run(main) \ No newline at end of file diff --git a/scripts/fixtures/large.png b/scripts/fixtures/large.png new file mode 100644 index 00000000..7d8d42fe Binary files /dev/null and b/scripts/fixtures/large.png differ diff --git a/scripts/fixtures/sample.jpg b/scripts/fixtures/sample.jpg new file mode 100644 index 00000000..24d15f69 Binary files /dev/null and b/scripts/fixtures/sample.jpg differ diff --git a/scripts/idempotency-race.py b/scripts/idempotency-race.py new file mode 100755 index 00000000..d33fa909 --- /dev/null +++ b/scripts/idempotency-race.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 +import sys +import threading +import uuid +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, check + +WORKERS = 20 + + +def main(): + c = Client() + alice, _, _, chat = c.bootstrap() + key = uuid.uuid4().hex + text = 'Одновременный повтор ' + key + barrier = threading.Barrier(WORKERS) + results, errors = [], [] + lock = threading.Lock() + + def send(): + barrier.wait() + try: + r = c.message(alice, chat, text, key=key) + with lock: + results.append((r['json'], r['headers']['X-Instance-Id'])) + except AssertionError as exc: + with lock: + errors.append(str(exc)) + + threads = [threading.Thread(target=send) for _ in range(WORKERS)] + for t in threads: + t.start() + for t in threads: + t.join() + + history = c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=100', actor=alice, schema='MessagePage')['json']['items'] + stored = [m for m in history if m['text'] == text] + instances = sorted({i for _, i in results}) + ids = {m['id'] for m, _ in results} + print('parallel requests with one key:', WORKERS) + print('successful responses (201):', len(results)) + print('failed requests:', len(errors), errors[:3]) + print('distinct message ids in responses:', len(ids)) + print('messages stored in history:', len(stored)) + print('instances that served requests:', instances) + check(not errors, 'some requests failed') + check(len(ids) == 1 and len(stored) == 1, 'duplicate message created') + check(all(m == results[0][0] for m, _ in results), 'replayed responses differ') + check(len(instances) >= 2, 'requests were not spread across replicas') + print('OK: exactly one message created') + + +if __name__ == '__main__': + main() diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 00000000..c595b688 --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,28 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +mkdir -p secrets +chmod 700 secrets + +if [ ! -f secrets/postgres_password ]; then + head -c 24 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/postgres_password +fi +password=$(cat secrets/postgres_password) + +[ -f secrets/database_url ] || + printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable\n' "$password" > secrets/database_url +[ -f secrets/cache_url ] || + printf 'redis://redis:6379/0\n' > secrets/cache_url +[ -f secrets/s3_root_access_key ] || + head -c 10 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/s3_root_access_key +[ -f secrets/s3_root_secret_key ] || + head -c 24 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/s3_root_secret_key +[ -f secrets/s3_access_key_id ] || + head -c 10 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/s3_access_key_id +[ -f secrets/s3_secret_access_key ] || + head -c 24 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/s3_secret_access_key + +chmod 644 secrets/postgres_password secrets/database_url secrets/cache_url \ + secrets/s3_root_access_key secrets/s3_root_secret_key \ + secrets/s3_access_key_id secrets/s3_secret_access_key +echo "secrets ready in ./secrets" \ No newline at end of file diff --git a/scripts/reconcile.sh b/scripts/reconcile.sh new file mode 100755 index 00000000..ecab5312 --- /dev/null +++ b/scripts/reconcile.sh @@ -0,0 +1,19 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +ENGINE=${ENGINE:-$(command -v podman >/dev/null 2>&1 && echo podman || echo docker)} +PROJECT=${PROJECT:-messenger-lab4} +IMAGE=${IMAGE:-localhost/messenger-api:lab4} + +$ENGINE run --rm --network "${PROJECT}_backend" \ + --entrypoint /usr/local/bin/reconcile \ + -v "$PWD/secrets/database_url:/run/secrets/database_url:ro" \ + -v "$PWD/secrets/s3_access_key_id:/run/secrets/s3_access_key_id:ro" \ + -v "$PWD/secrets/s3_secret_access_key:/run/secrets/s3_secret_access_key:ro" \ + -e S3_ENDPOINT="${S3_ENDPOINT:-http://s3:9000}" \ + -e S3_REGION="${S3_REGION:-us-east-1}" \ + -e S3_BUCKET="${S3_BUCKET:-messenger-attachments}" \ + -e DATABASE_URL_FILE=/run/secrets/database_url \ + -e S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id \ + -e S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key \ + "$IMAGE" "$@" \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..72c9df72 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,8 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +ENGINE=${ENGINE:-$(command -v podman >/dev/null 2>&1 && echo podman || echo docker)} +COMPOSE=${COMPOSE:-$([ "$ENGINE" = podman ] && echo podman-compose || echo "docker compose")} + +$COMPOSE stop lb api redis postgres s3 +$COMPOSE start postgres redis s3 api lb \ No newline at end of file diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..1fca5e9d --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,37 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +ENGINE=${ENGINE:-$(command -v podman >/dev/null 2>&1 && echo podman || echo docker)} +COMPOSE=${COMPOSE:-$([ "$ENGINE" = podman ] && echo podman-compose || echo "docker compose")} +PROJECT=${PROJECT:-messenger-lab4} + +replicas() { + $ENGINE ps -aq --no-trunc --filter "label=com.docker.compose.project=$PROJECT" --filter "label=com.docker.compose.service=api" | sort +} + +wait_healthy() { + for _ in $(seq 1 60); do + if [ "$($ENGINE inspect -f '{{.State.Health.Status}}' "$1" 2>/dev/null)" = "healthy" ]; then + return 0 + fi + sleep 1 + done + echo "replica $1 did not become healthy" >&2 + exit 1 +} + +$ENGINE build --build-arg "BUILD_ID=${BUILD_ID:-$(date +%s)}" -t localhost/messenger-api:lab4 . +$COMPOSE run --rm migrate + +for old in $(replicas); do + before=$(replicas) + $ENGINE stop -t 10 "$old" + $ENGINE rm "$old" + $COMPOSE up -d --no-deps --no-recreate api + for id in $(replicas); do + if ! echo "$before" | grep -q "$id"; then + wait_healthy "$id" + fi + done + sleep 2 +done diff --git a/scripts/s3tool.sh b/scripts/s3tool.sh new file mode 100755 index 00000000..7b6c8344 --- /dev/null +++ b/scripts/s3tool.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +ENGINE=${ENGINE:-$(command -v podman >/dev/null 2>&1 && echo podman || echo docker)} +PROJECT=${PROJECT:-messenger-lab4} +IMAGE=${IMAGE:-localhost/messenger-api:lab4} + +$ENGINE run --rm -i --network "${PROJECT}_backend" \ + --entrypoint /usr/local/bin/s3tool \ + -v "$PWD/secrets/s3_access_key_id:/run/secrets/s3_access_key_id:ro" \ + -v "$PWD/secrets/s3_secret_access_key:/run/secrets/s3_secret_access_key:ro" \ + -e S3_ENDPOINT="${S3_ENDPOINT:-http://s3:9000}" \ + -e S3_REGION="${S3_REGION:-us-east-1}" \ + -e S3_BUCKET="${S3_BUCKET:-messenger-attachments}" \ + -e S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id \ + -e S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key \ + "$IMAGE" "$@" \ No newline at end of file diff --git a/scripts/sql/inject-db-failure.sql b/scripts/sql/inject-db-failure.sql new file mode 100644 index 00000000..7ac75385 --- /dev/null +++ b/scripts/sql/inject-db-failure.sql @@ -0,0 +1,12 @@ +CREATE OR REPLACE FUNCTION inject_attachment_insert_failure() RETURNS trigger AS $$ +BEGIN + RAISE EXCEPTION 'injected attachment insert failure' USING ERRCODE = '57014'; +END; +$$ LANGUAGE plpgsql; + +DROP TRIGGER IF EXISTS inject_attachment_insert_failure ON attachments; + +CREATE TRIGGER inject_attachment_insert_failure + BEFORE INSERT ON attachments + FOR EACH ROW + EXECUTE FUNCTION inject_attachment_insert_failure(); \ No newline at end of file diff --git a/scripts/sql/reset-db-failure.sql b/scripts/sql/reset-db-failure.sql new file mode 100644 index 00000000..17bc22a1 --- /dev/null +++ b/scripts/sql/reset-db-failure.sql @@ -0,0 +1,2 @@ +DROP TRIGGER IF EXISTS inject_attachment_insert_failure ON attachments; +DROP FUNCTION IF EXISTS inject_attachment_insert_failure(); \ No newline at end of file diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..0827f9dd --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,13 @@ +#!/bin/sh +set -eu +ENGINE=${ENGINE:-$(command -v podman >/dev/null 2>&1 && echo podman || echo docker)} +PROJECT=${PROJECT:-messenger-lab4} +: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}" + +for id in $($ENGINE ps -q --filter "label=com.docker.compose.project=$PROJECT" --filter "label=com.docker.compose.service=api"); do + if [ "$($ENGINE inspect -f '{{.Config.Hostname}}' "$id")" = "$TARGET_INSTANCE_ID" ]; then + $ENGINE stop -t 10 "$id" >/dev/null + exit 0 + fi +done +exit 1 diff --git a/scripts/track2-cost.py b/scripts/track2-cost.py new file mode 100755 index 00000000..1e79a109 --- /dev/null +++ b/scripts/track2-cost.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +"""Reconciler traversal cost for several object counts; creates synthetic objects and removes them.""" +import json +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +S3TOOL = ROOT / 'scripts/s3tool.sh' +RECONCILE = ROOT / 'scripts/reconcile.sh' +PREFIX = 'chats/bench' +SIZES = (100, 1000, 5000) + + +def call(arguments): + return subprocess.run(arguments, capture_output=True, text=True, check=False) + + +def reconcile(*arguments): + result = call([str(RECONCILE), *arguments]) + try: + return json.loads(result.stdout) + except json.JSONDecodeError: + print(result.stdout[-500:], file=sys.stderr) + print(result.stderr[-500:], file=sys.stderr) + raise SystemExit('reconcile did not return JSON') + + +def main(): + measurements = [] + for count in SIZES: + seeded = call([str(S3TOOL), 'seed', PREFIX, str(count), '1024']) + if seeded.returncode != 0: + raise SystemExit('seed failed: ' + seeded.stderr[-400:]) + + scan = reconcile('-prefix', PREFIX + '/', '-grace', '0s') + if scan['scanned_objects'] != count: + raise SystemExit(f'expected {count} objects, scanned {scan["scanned_objects"]}') + if len(scan['orphans']) != count: + raise SystemExit(f'expected {count} orphans, got {len(scan["orphans"])}') + + repair = reconcile('-prefix', PREFIX + '/', '-grace', '0s', '-dry-run=false') + if repair['deleted_objects'] != count: + raise SystemExit(f'expected {count} deletions, got {repair["deleted_objects"]}') + + measurements.append({ + 'objects': count, + 'scan_ms': scan['duration_ms'], + 'scan_s3_requests': scan['s3_requests'], + 'scan_db_queries': scan['db_queries'], + 'scan_objects_per_second': round(scan['objects_per_second'], 1), + 'scan_ms_per_object': round(scan['duration_ms'] / count, 4), + 'repair_ms': repair['duration_ms'], + 'repair_s3_requests': repair['s3_requests'], + 'repair_deleted': repair['deleted_objects'], + }) + + print(json.dumps({'prefix': PREFIX, 'measurements': measurements}, indent=2)) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/scripts/upload-load.py b/scripts/upload-load.py new file mode 100755 index 00000000..d511bc1f --- /dev/null +++ b/scripts/upload-load.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +"""Concurrent upload experiment with API memory measurement; creates synthetic data.""" +import json +import math +import shutil +import subprocess +import sys +import threading +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, Failure, arguments, check, run + +ROOT = Path(__file__).resolve().parents[1] + + +def engine(): + return 'podman' if shutil.which('podman') else 'docker' + + +def api_containers(project): + result = subprocess.run( + [engine(), 'ps', + '--filter', 'label=com.docker.compose.project=' + project, + '--filter', 'label=com.docker.compose.service=api', + '--format', '{{.Names}}'], + capture_output=True, text=True, check=False) + check(result.returncode == 0, 'cannot list api containers: ' + result.stderr.strip()) + return sorted(line.strip() for line in result.stdout.splitlines() if line.strip()) + + +def peak_bytes(container): + for path in ('/sys/fs/cgroup/memory.peak', '/sys/fs/cgroup/memory/memory.max_usage_in_bytes'): + result = subprocess.run([engine(), 'exec', container, 'cat', path], capture_output=True, text=True, check=False) + if result.returncode == 0 and result.stdout.strip().isdigit(): + return int(result.stdout.strip()) + return None + + +def main(): + def configure(p): + p.add_argument('--concurrency', type=int, default=10) + p.add_argument('--file', default=str(ROOT / 'scripts/fixtures/large.png')) + p.add_argument('--project', default='messenger-lab4') + p.add_argument('--output', default=None) + + args = arguments('Concurrent attachment uploads with peak memory measurement', configure) + check(1 <= args.concurrency <= 64, 'concurrency must be 1..64') + source = Path(args.file) + check(source.is_file(), 'upload fixture not found: ' + str(source)) + content = source.read_bytes() + + containers = api_containers(args.project) + check(bool(containers), 'no api containers found for project ' + args.project) + baseline = {name: peak_bytes(name) for name in containers} + + c = Client() + alice, _, _, chat = c.bootstrap() + actor = {'id': alice['id'], 'token': alice['token']} + path = '/api/v1/chats/' + chat['id'] + '/attachments?filename=' + source.name + + barrier = threading.Barrier(args.concurrency) + lock = threading.Lock() + latencies, failures = [], [] + + def worker(index): + local = Client(timeout=120) + barrier.wait() + started = time.monotonic() + try: + response = local.call('POST', path, 201, actor=actor, raw=content, + headers={'Content-Type': 'image/png'}, schema='Attachment') + with lock: + latencies.append(time.monotonic() - started) + check(response['json']['size_bytes'] == len(content), 'uploaded size mismatch') + except Failure as exc: + with lock: + failures.append(str(exc)) + + started = time.monotonic() + threads = [threading.Thread(target=worker, args=(i,)) for i in range(args.concurrency)] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + elapsed = time.monotonic() - started + + peaks = {name: peak_bytes(name) for name in containers} + peak_delta = {} + for name in containers: + before = baseline[name] + after = peaks[name] + if before is None or after is None: + peak_delta[name] = None + else: + peak_delta[name] = after - before + + ordered = sorted(latencies) + def percentile(p): + return round(1000 * ordered[max(0, math.ceil(p * len(ordered)) - 1)], 1) if ordered else None + + report = { + 'concurrency': args.concurrency, + 'uploads': args.concurrency, + 'fixture': source.name, + 'fixture_bytes': len(content), + 'elapsed_seconds': round(elapsed, 3), + 'successful': len(latencies), + 'failed': len(failures), + 'failures': failures[:3], + 'latency_ms': {'p50': percentile(0.50), 'p95': percentile(0.95), 'p99': percentile(0.99)}, + 'api_containers': containers, + 'peak_bytes_before': baseline, + 'peak_bytes_after': peaks, + 'peak_delta_bytes': peak_delta, + 'peak_max_mb': round(max(v for v in peaks.values() if v is not None) / (1024 * 1024), 2) if any(v is not None for v in peaks.values()) else None, + } + text = json.dumps(report, indent=2) + if args.output: + destination = Path(args.output) + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_text(text + '\n') + print(text) + check(not failures, 'some uploads failed') + check(len(latencies) == args.concurrency, 'not all uploads succeeded') + + +if __name__ == '__main__': + run(main) \ No newline at end of file diff --git a/scripts/upload-once.py b/scripts/upload-once.py new file mode 100755 index 00000000..74be48dc --- /dev/null +++ b/scripts/upload-once.py @@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +"""Single binary upload for failure drills; asserts the expected status code.""" +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, arguments, check, run + +ROOT = Path(__file__).resolve().parents[1] + + +def main(): + def configure(p): + p.add_argument('--expect', type=int, default=201) + p.add_argument('--file', default=str(ROOT / 'scripts/fixtures/sample.jpg')) + p.add_argument('--content-type', default='image/jpeg') + p.add_argument('--attach', action='store_true', help='also attach the upload to a new message') + + args = arguments('Single upload used by compensation drills; creates synthetic data', configure) + source = Path(args.file) + check(source.is_file(), 'file not found: ' + str(source)) + content = source.read_bytes() + + c = Client() + alice, _, _, chat = c.bootstrap() + response = c.call('POST', '/api/v1/chats/' + chat['id'] + '/attachments?filename=' + source.name, + args.expect, actor=alice, raw=content, + headers={'Content-Type': args.content_type}, schema='Attachment') + print(f'status={response["status"]}') + if response['status'] == 201: + attachment = response['json'] + print(f"attachment={attachment['id']} size={attachment['size_bytes']}") + if args.attach: + message = c.message(alice, chat, '', attachments=[attachment['id']])['json'] + print(f"message={message['id']} attachment_ids={message['attachment_ids']}") + + +if __name__ == '__main__': + run(main) \ No newline at end of file