forked from mtusi2026/mtusi2026lab4
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f936985d59 | ||
|
|
79e94f9d2a |
+20
-11
@@ -1,20 +1,29 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
# Скопируйте в .env. Файл .env не коммитится.
|
||||
# Значения ниже — учебные заглушки локального стенда, не боевые секреты.
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=change-me
|
||||
POSTGRES_DB=messenger
|
||||
REDIS_PASSWORD=change-me
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
S3_ENDPOINT=http://s3:9000
|
||||
SHUTDOWN_TIMEOUT_SECONDS=8
|
||||
API_REPLICAS=2
|
||||
API_CPU_LIMIT=0.50
|
||||
API_MEM_LIMIT=384M
|
||||
DB_MAX_CONNS=8
|
||||
ARGON2_TIME=2
|
||||
ARGON2_MEMORY_KIB=19456
|
||||
ARGON2_THREADS=1
|
||||
MINIO_ROOT_USER=minio-root
|
||||
MINIO_ROOT_PASSWORD=change-me-root
|
||||
S3_ENDPOINT=http://minio:9000
|
||||
S3_REGION=us-east-1
|
||||
S3_BUCKET=messenger-attachments
|
||||
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
|
||||
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
|
||||
S3_ACCESS_KEY=messenger-api
|
||||
S3_SECRET_KEY=change-me-change-me
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
RECONCILE_GRACE_SECONDS=900
|
||||
|
||||
@@ -1,18 +1,22 @@
|
||||
## Лабораторная 4
|
||||
|
||||
Автор / группа: TODO
|
||||
Целевая оценка (3/4/5): TODO
|
||||
Трек 5, если заявлен: TODO
|
||||
Автор / группа: Колмычков Иван Сергеевич, БВТ2303
|
||||
Целевая оценка (3/4/5): 5
|
||||
Трек 5, если заявлен: 2 - согласованность PostgreSQL и приватного bucket MinIO
|
||||
|
||||
Что реализовано и что перенесено: TODO
|
||||
Команды запуска из чистого clone: TODO
|
||||
Результаты проверок и ссылка на REPORT.md: TODO
|
||||
Ограничения / известные ошибки: TODO
|
||||
Источники и использование ИИ: TODO
|
||||
Что реализовано и что перенесено: из lab3 перенесены PostgreSQL, сессии Redis, две реплики API, HAProxy и идемпотентность сообщений. Добавлены вложения PNG/JPEG: метаданные в PostgreSQL, байты в приватном bucket `messenger-attachments`. Ключ объекта назначает сервер. Загрузка и скачивание идут через API. `201` возвращается после записи в MinIO и в базу; при неудачном INSERT объект удаляется. Сверка `reconcile` убирает старых сирот и старые неприкреплённые строки, не трогая свежие и уже используемые вложения. У API отдельный ключ S3 без прав root. Консоль MinIO наружу не открыта.
|
||||
|
||||
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [ ] Контракт и публичные тесты не ослаблены.
|
||||
- [ ] make check и make test выполнены; приложен реальный вывод.
|
||||
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
|
||||
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
|
||||
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
|
||||
Команды запуска из чистого clone: `cp .env.example .env`, затем `docker compose --env-file .env up -d --build`. Дождаться `GET http://127.0.0.1:8080/health/ready`. Проверки: `make check`, `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`, `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, `python3 student-tests/grade45.py`. После failover реплика остаётся остановленной: `docker compose --env-file .env start api`. Остановка без удаления данных: `docker compose --env-file .env stop`. Volumes удаляются только явно: `docker compose --env-file .env down -v`.
|
||||
|
||||
Результаты проверок и ссылка на REPORT.md: подробности и таблица критериев — в REPORT.md, выводы команд — в evidence/. `make check` — PASS. `make test` — PASS (`evidence/smoke.txt`). Persistence — PASS, перезапущены API, PostgreSQL, Redis, MinIO и HAProxy (`evidence/persistence.txt`, `evidence/restart-after.txt`). Failover — PASS, 2 реплики, восстановление записи за 2.317 с, байты вложения совпали (`evidence/failover.txt`). Остановленный MinIO даёт 503 на `/health/ready` (`evidence/s3-down.txt`). Анонимный S3 GET — 403, консоль с хоста недоступна (`evidence/private-bucket.txt`). Чужой bucket прикладным ключом — AccessDenied (`evidence/s3-rights.txt`). Негативные загрузки, 10 параллельных загрузок (пик API 71.4 МиБ) и трек 2 — `evidence/grade45.txt`, `evidence/reconcile-apply.json`.
|
||||
|
||||
Ограничения / известные ошибки: один Docker-host не переживает потерю машины. Сверка не восстанавливает пропавшие байты: у используемого вложения без объекта скачивание даёт 404, строка остаётся. Полная распаковка изображения отключена выше 1 000 000 пикселей. Пик памяти измерен на десяти телах по 1 МиБ, не на десяти файлах по 10 МиБ. Образ `docker.io/minio/minio` на Docker Hub отсутствует, поэтому сервер — `alpine/minio:RELEASE.2025-10-15T17-29-55Z` с зафиксированным digest; `minio --version` у этой сборки печатает `DEVELOPMENT.GOGET`. Трек 1 (presigned upload) не делался.
|
||||
|
||||
Источники и использование ИИ: контракт репозитория, MinIO admin API (`madmin-go` v3) и S3 API (`minio-go` v7). Нейросеть помогала писать код, отчёт и прогоны. Секреты в PR нет: пароли только в локальном `.env`.
|
||||
|
||||
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [x] Контракт и публичные тесты не ослаблены.
|
||||
- [x] make check и make test выполнены; приложен реальный вывод.
|
||||
- [x] Сценарии отказов/безопасности своего уровня воспроизведены.
|
||||
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
|
||||
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
|
||||
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
FROM golang:1.26-bookworm AS build
|
||||
WORKDIR /src
|
||||
COPY go.mod go.sum ./
|
||||
RUN go mod download
|
||||
COPY messenger ./messenger
|
||||
COPY internal ./internal
|
||||
COPY migrations ./migrations
|
||||
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
|
||||
go build -trimpath -ldflags='-s -w' -o /out/messenger ./messenger \
|
||||
&& chmod 755 /out/messenger
|
||||
|
||||
FROM gcr.io/distroless/static-debian12:nonroot@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab
|
||||
COPY --from=build --chown=65532:65532 /out/messenger /messenger
|
||||
USER 65532:65532
|
||||
ENV APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080 \
|
||||
APP_ENV=lab \
|
||||
SHUTDOWN_TIMEOUT_SECONDS=8
|
||||
EXPOSE 8080
|
||||
HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=3 \
|
||||
CMD ["/messenger", "healthcheck"]
|
||||
ENTRYPOINT ["/messenger"]
|
||||
@@ -1,37 +1,118 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Колмычков Иван Сергеевич БВТ2303
|
||||
- Целевая оценка: **5**. Трек 5: **2, согласованность PostgreSQL и S3**.
|
||||
- Commit/PR: локальная ветка `solution/bvt2303-kolmychkov`, PR ещё не открыт.
|
||||
- Источники и помощь ИИ: контракт репозитория, MinIO admin API (`madmin-go` v3) и S3 API (`minio-go` v7). Нейросеть помогала писать код, отчёт и прогоны. Числа ниже сняты с этого компьютера.
|
||||
|
||||
Трек 1 (presigned upload) не выбран: он добавляет второй протокол загрузки, срок подписи и отдельный доступ клиента к bucket. Трек 2 остаётся внутри уже обязательного proxy-upload и проверяется своими командами `reconcile`.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Проверено 2026-11-13 на Linux 7.0.0-31-generic, x86_64, 8 логических CPU, 7.0 ГиБ RAM. Docker Engine 29.1.3, Compose v2.40.3, локальный Go 1.26, Python 3.14. Образы зафиксированы тегами, MinIO ещё и digest. `latest` нет.
|
||||
|
||||
| Роль | service | Образ | Лимит | Порт на хосте | Volume |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| API ×2 | api | сборка `messenger-api:lab4` из `Dockerfile` (`golang:1.26-bookworm`, runtime `gcr.io/distroless/static-debian12:nonroot@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab`) | 0.50 CPU / 384 МиБ на реплику | нет, только через HAProxy | нет |
|
||||
| PostgreSQL | postgres | `postgres:16.10-bookworm` | 1.00 CPU / 512 МиБ | `127.0.0.1:5432` | `pgdata` |
|
||||
| Redis | redis | `redis:7.4.6-alpine`, AOF `everysec` | 0.25 CPU / 128 МиБ | `127.0.0.1:6379` | `redisdata` |
|
||||
| MinIO | minio | `alpine/minio:RELEASE.2025-10-15T17-29-55Z@sha256:cf23643a6cf9ce159c57643ceb88279e431262282428c9e0bf3a7ef1a97e84b4` | 0.50 CPU / 512 МиБ | `127.0.0.1:9000` | `miniodata` |
|
||||
| Bootstrap | minio-init | тот же образ API, команда `bootstrap-s3` | — | нет | нет |
|
||||
| HAProxy | haproxy | `haproxy:2.8.14` | 0.25 CPU / 128 МиБ | `127.0.0.1:8080` | нет |
|
||||
|
||||
`docker.io/minio/minio` на эту дату отвечает 404, поэтому сервер взят из Alpine-сборки релиза `RELEASE.2025-10-15T17-29-55Z`. В логе старта виден исходный модуль `github.com/minio/minio@v0.0.0-20251015172955-9e49d5e7a648`. Строка `minio --version` у этой сборки — `DEVELOPMENT.GOGET`: в образ не передали release ldflags. Закреплены тег и digest. Консоль слушает `127.0.0.1:9001` внутри контейнера и на хост не проброшена. С хоста `curl http://127.0.0.1:9001/` дал код curl 7 (соединения нет).
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
# учебные пароли уже в примере; перед чужой машиной их меняют
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build
|
||||
# дождаться /health/ready через http://127.0.0.1:8080
|
||||
make test
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
# после failover реплика остаётся остановленной:
|
||||
docker compose --env-file .env start api
|
||||
```
|
||||
|
||||
Остановка без удаления данных: `docker compose --env-file .env stop`. Учебные данные удаляются только явно: `docker compose --env-file .env down -v`.
|
||||
|
||||
Секреты — переменные `.env`, файл не коммитится. Root MinIO есть только у `minio-init`. API получает `S3_ACCESS_KEY` / `S3_SECRET_KEY` и политику `messenger-app`: `ListBucket`, `GetBucketLocation`, `GetObject`, `PutObject`, `DeleteObject` на один bucket. Повтор `bootstrap-s3` не пересоздаёт bucket и не падает, если политика уже привязана.
|
||||
|
||||
Миграции: `001_init.sql`, `002_idempotency.sql`, `003_attachments.sql`. Их применяет одноразовый сервис `migrate`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Клиент → HAProxy → API ×2 → PostgreSQL (пользователи, чаты, сообщения, метаданные вложений) и Redis (сессии). Байты лежат в приватном bucket `messenger-attachments`. Локального файла оригинала на API нет: реплика читает объект по ключу из БД.
|
||||
|
||||
Ключ объекта — `o/` и 32 случайных байта. `filename` только для показа. В JSON ответа нет ключа, адреса bucket и учётных данных.
|
||||
|
||||
`201` возвращается после успешного `PutObject` и `INSERT`. Если `INSERT` не прошёл, процесс сразу вызывает `DeleteObject`. Если процесс умер между этими шагами, объект остаётся сиротой до сверки. Сверка не трогает его, пока не прошёл `RECONCILE_GRACE_SECONDS` (на стенде 900, в эксперименте 5).
|
||||
|
||||
Готовность `/health/ready` требует PostgreSQL, Redis и `BucketExists`. Остановка MinIO даёт 503 на балансировщике, потому что обе реплики перестают быть ready.
|
||||
|
||||
Загрузка читает не больше 10 МиБ + 1 байт. Тип определяется по сигнатуре, не по имени файла. Размеры берутся из IHDR/SOF. Полный `image.Decode` делается только если пикселей не больше 1 000 000. Выше этого порога и до 40 000 000 пикселей достаточно заголовка: растр `width*height*4` не выделяется. Повреждённый PNG/JPEG и подмена MIME дают 415, лишний байт сверх 10 МиБ и слишком большие размеры — 413. Эти ответы не превращаются в 500.
|
||||
|
||||
Пустой текст сообщения допустим только вместе с вложением. Пробельный текст отклоняется. Чужое вложение и вложение другого чата — 404, без сообщения о том, что объект существует.
|
||||
|
||||
Из lab3 перенесены сессии Redis, две реплики, HAProxy без retry POST и идемпотентность сообщения. Отпечаток ключа теперь включает текст и список `attachment_ids`; отсутствующий список равен `[]`.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
Каждая строка — отдельный пункт README. Наблюдение лежит в названном файле, без токенов и паролей.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Возможности lab3 сохранены: сессия, идемпотентность, две реплики, smoke lab4 | `make test`; failover видит число реплик до отказа | Smoke PASS. До отказа наблюдались 2 реплики | `evidence/smoke.txt`, `evidence/failover.txt` |
|
||||
| Метаданные в PostgreSQL, байты не на диске API | `docker inspect` mounts реплики API | `Mounts` пустой: у API нет volume с оригиналом | `evidence/layout.txt` |
|
||||
| POST 201 ready, скачивание побайтно, участник читает, посторонний получает 404 | `make test` | PASS: checksum оригинала и 404 для третьего пользователя входят в публичный smoke | `evidence/smoke.txt` |
|
||||
| Реальный JPEG принимается и скачивается теми же байтами | `go run student-tests/mkjpeg.go`, затем POST/GET через API | 201 `image/jpeg`, `status=ready`, download совпал, 613 байт | `evidence/jpeg.txt` |
|
||||
| PNG fixture, MIME по содержимому, опасное имя, лимит пикселей до распаковки | `go test ./internal/imagecheck`; `python3 student-tests/grade45.py` | Fixture 320×200 проходит. Имя с `/` и `\` — 400. Текст и подмена MIME — 415. Обрезанный PNG — 415. Файл 10 МиБ+1 и 20000×2001 — 413. Строк вложений на отказах не прибавилось | `evidence/imagecheck.txt`, `evidence/grade45.txt` |
|
||||
| Upload, остановка обслужившей реплики, download через другую тем же файлом | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | PASS. Тест сам сравнивает байты вложения после остановки реплики. 2 реплики, 120 успешных записей, 1 ошибка перехода, восстановление 2.317 с | `evidence/failover.txt` |
|
||||
| Restart с volumes сохраняет метаданные и оригинал | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS, включая повторное чтение файла. `StartedAt` сменился у api ×2, postgres, redis, minio, haproxy | `evidence/persistence.txt`, `evidence/restart-before.txt`, `evidence/restart-after.txt` |
|
||||
| Слишком большой файл, битое изображение, подмена MIME, чужой attachment_id, файл другого чата; не 500 | `python3 student-tests/grade45.py` | 413, 415, 415, 404, 404. В телах нет `internal_error` | `evidence/grade45.txt` |
|
||||
| Сбой между S3 и PostgreSQL не оставляет вечный мусор; grace | `grade45.py`: сирота и строка без объекта старше 5 с, затем `reconcile` dry-run и `--apply` | Сухой прогон удалил 0. Apply удалил 1 старый объект и 1 старую неприкреплённую строку. Повторный apply удалил 0 | `evidence/grade45.txt`, `evidence/reconcile-apply.json` |
|
||||
| ≥10 одновременных загрузок, пик памяти ограничен | 10 потоков по 1 МиБ, `docker stats` | 10 ответов 415, пик API 71.4 МиБ при лимите 384 МиБ, 8.43 с | `evidence/grade45.txt` |
|
||||
| Bootstrap bucket идемпотентен | повторный `docker compose run --rm --no-deps minio-init` | `bootstrap-s3 complete`, код 0, bucket не пересоздавался с ошибкой | `evidence/bootstrap-rerun.txt` |
|
||||
| Отдельные ограниченные S3 credentials | имена env API и `go run student-tests/s3_rights.go` | У API нет `MINIO_ROOT_*`. Свой bucket виден, `MakeBucket` чужого bucket — `AccessDenied` | `evidence/layout.txt`, `evidence/s3-rights.txt` |
|
||||
| Консоль не открыта в общей сети | `curl http://127.0.0.1:9001/` и список портов | Код curl 7, HTTP-кода нет. Порт 9001 не проброшен на хост | `evidence/private-bucket.txt`, `evidence/layout.txt` |
|
||||
| Приватный bucket вне API | `curl` без подписи на `127.0.0.1:9000/messenger-attachments/...` | 403 | `evidence/private-bucket.txt` |
|
||||
| Недоступность S3 | `docker compose stop minio`, затем `GET /health/ready`, затем `start` | Во время остановки 503 `unavailable`. После старта снова 200 | `evidence/s3-down.txt` |
|
||||
| Трек 2: ошибки на обеих сторонах, dry-run, повтор, свежие и используемые не удаляются, стоимость обхода | `python3 student-tests/grade45.py` | См. следующий раздел. Свежий сирота остался, метаданные используемого вложения — 200, его байты — 404, свежий файл скачался. Обход: 1 страница листинга, 2 мс и 4 мс | `evidence/grade45.txt`, `evidence/reconcile-apply.json` |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
## Эксперимент трека 2
|
||||
|
||||
## Эксперименты и отказы
|
||||
Гипотеза: один проход по множеству ключей bucket и множеству `object_key` в PostgreSQL отличает пару, свежего сироту, старого сироту, свежую строку без объекта, старую строку без объекта и строку, на которую уже ссылается сообщение. Сухой прогон ничего не удаляет. Повторный apply после исправления не удаляет ничего. Свежий сирота и используемое вложение переживают apply.
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Методика на том же стенде. Grace для одноразовой команды `reconcile` — 5 секунд, у долгоживущих API остаётся 900.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
1. Загрузить PNG и прикрепить его к сообщению (используемое).
|
||||
2. Загрузить второй PNG и не прикреплять (кандидат на удаление строки).
|
||||
3. Положить объект `o/orphan-old` командой `s3-put`.
|
||||
4. Подождать 6 секунд.
|
||||
5. Удалить из bucket объекты используемого и неприкреплённого вложений (`s3-rm`).
|
||||
6. Загрузить ещё один PNG (свежая пара) и положить `o/orphan-fresh`.
|
||||
7. Два сухих прогона, затем `--apply`, затем `--apply` ещё раз.
|
||||
8. Проверить HTTP.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
Наблюдение сухого прогона: 10 строк, 9 объектов, 1 страница листинга, 7 пар, 1 свежий сирота, 1 старый сирота, 2 отсутствующих объекта у используемых строк, 1 старая неприкреплённая строка без объекта. Удалено 0. Второй сухой прогон дал те же счётчики удаления. Две используемые строки — это вложение этого прогона и ещё одно, оставшееся от предыдущей инъекции в том же volume; оба сохранены.
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Apply удалил 1 объект и 1 строку за 4 мс. Повторный apply: `deleted_objects=0`, `deleted_rows=0`, старых сирот 0. Свежий сирота остался в классификации (`orphan_fresh=1`).
|
||||
|
||||
HTTP после apply:
|
||||
|
||||
- метаданные используемого вложения — 200;
|
||||
- его байты — 404, строка не удалена;
|
||||
- неприкреплённая старая строка — 404;
|
||||
- свежий файл скачивается побайтно, тело совпало с исходным PNG.
|
||||
|
||||
Стоимость обхода: один `ListObjects` (здесь 1 страница) и один `SELECT` по `attachments`, без `HEAD` на каждый ключ. На 9 объектах сухой прогон занял 2 мс, apply — 4 мс. Это не оценка большого каталога: набор маленький, время сопоставимо с задержкой одного запроса к MinIO на этой машине.
|
||||
|
||||
## Ограничения
|
||||
|
||||
- Один Docker-host. Падение хоста уносит и БД, и MinIO. Две реплики API не делают хранилища высокодоступными.
|
||||
- Сверка не восстанавливает потерянные байты. Если объект используемого вложения пропал, строка остаётся, скачивание даёт 404.
|
||||
- Grace защищает свежие сироты, но не вечный мусор: объект старше grace и без строки удаляется. На учебном стенде grace 900 секунд; эксперимент специально ставил 5.
|
||||
- Полная распаковка растра выключена выше 1 000 000 пикселей. Файл с верным заголовком и битым телом крупнее этого порога может пройти структурную проверку.
|
||||
- Пик 71.4 МиБ измерен для десяти тел по 1 МиБ. Верхняя оценка буфера — 10 МиБ на запрос, который ещё читается. Десять полных файлов по 10 МиБ в эксперименте не гонялись.
|
||||
- `alpine/minio` сообщает версию `DEVELOPMENT.GOGET`. Идентичность сборки подтверждается тегом, digest и commit в логе, не строкой `--version`.
|
||||
|
||||
+198
@@ -0,0 +1,198 @@
|
||||
# Локальный стенд лабораторной 4. Секреты только из .env, volumes не удаляются restart-скриптом.
|
||||
# Клиент ходит в haproxy:8080. Реплики api и консоль MinIO наружу не публикуются.
|
||||
name: messenger-lab4
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.10-bookworm
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
|
||||
POSTGRES_DB: ${POSTGRES_DB}
|
||||
command:
|
||||
- postgres
|
||||
- -c
|
||||
- synchronous_commit=on
|
||||
- -c
|
||||
- max_connections=50
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
ports:
|
||||
- "127.0.0.1:5432:5432"
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 12
|
||||
start_period: 5s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.00"
|
||||
memory: 512M
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.4.6-alpine
|
||||
environment:
|
||||
REDIS_PASSWORD: ${REDIS_PASSWORD}
|
||||
command:
|
||||
- sh
|
||||
- -c
|
||||
- exec redis-server --appendonly yes --appendfsync everysec --aof-use-rdb-preamble yes --dir /data --requirepass "$$REDIS_PASSWORD" --bind 0.0.0.0 --protected-mode yes
|
||||
volumes:
|
||||
- redisdata:/data
|
||||
ports:
|
||||
- "127.0.0.1:6379:6379"
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "redis-cli --no-auth-warning -a \"$$REDIS_PASSWORD\" ping | grep -q PONG"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 12
|
||||
start_period: 3s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.25"
|
||||
memory: 128M
|
||||
restart: unless-stopped
|
||||
|
||||
minio:
|
||||
# Официальный docker.io/minio/minio на Docker Hub к ноябрю 2026 отдаёт 404.
|
||||
# Это Alpine-сборка того же сервера, тег и digest зафиксированы.
|
||||
image: alpine/minio:RELEASE.2025-10-15T17-29-55Z@sha256:cf23643a6cf9ce159c57643ceb88279e431262282428c9e0bf3a7ef1a97e84b4
|
||||
# Том создаётся от root. Образ по умолчанию — user minio и не может инициализировать /data.
|
||||
user: "0:0"
|
||||
command: ["server", "/data", "--console-address", "127.0.0.1:9001"]
|
||||
environment:
|
||||
MINIO_ROOT_USER: ${MINIO_ROOT_USER}
|
||||
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD}
|
||||
volumes:
|
||||
- miniodata:/data
|
||||
ports:
|
||||
- "127.0.0.1:9000:9000"
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:9000/minio/health/live"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 12
|
||||
start_period: 5s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 512M
|
||||
restart: unless-stopped
|
||||
|
||||
minio-init:
|
||||
build: .
|
||||
image: messenger-api:lab4
|
||||
command: ["bootstrap-s3"]
|
||||
depends_on:
|
||||
minio:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
MINIO_ROOT_USER: ${MINIO_ROOT_USER}
|
||||
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD}
|
||||
S3_ENDPOINT: http://minio:9000
|
||||
S3_REGION: ${S3_REGION}
|
||||
S3_BUCKET: ${S3_BUCKET}
|
||||
S3_ACCESS_KEY: ${S3_ACCESS_KEY}
|
||||
S3_SECRET_KEY: ${S3_SECRET_KEY}
|
||||
restart: "no"
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
image: messenger-api:lab4
|
||||
command: ["migrate"]
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
DATABASE_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}?sslmode=disable
|
||||
healthcheck:
|
||||
disable: true
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 128M
|
||||
restart: "no"
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: messenger-api:lab4
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
minio-init:
|
||||
condition: service_completed_successfully
|
||||
minio:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: lab
|
||||
SHUTDOWN_TIMEOUT_SECONDS: ${SHUTDOWN_TIMEOUT_SECONDS:-8}
|
||||
DATABASE_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}?sslmode=disable
|
||||
REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379/0
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
DB_MAX_CONNS: ${DB_MAX_CONNS:-8}
|
||||
ARGON2_TIME: ${ARGON2_TIME:-2}
|
||||
ARGON2_MEMORY_KIB: ${ARGON2_MEMORY_KIB:-19456}
|
||||
ARGON2_THREADS: ${ARGON2_THREADS:-1}
|
||||
S3_ENDPOINT: ${S3_ENDPOINT}
|
||||
S3_REGION: ${S3_REGION}
|
||||
S3_BUCKET: ${S3_BUCKET}
|
||||
S3_ACCESS_KEY: ${S3_ACCESS_KEY}
|
||||
S3_SECRET_KEY: ${S3_SECRET_KEY}
|
||||
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
|
||||
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
|
||||
RECONCILE_GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-900}
|
||||
expose:
|
||||
- "8080"
|
||||
healthcheck:
|
||||
test: ["CMD", "/messenger", "healthcheck"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 12
|
||||
start_period: 10s
|
||||
deploy:
|
||||
replicas: ${API_REPLICAS:-2}
|
||||
resources:
|
||||
limits:
|
||||
cpus: "${API_CPU_LIMIT:-0.50}"
|
||||
memory: ${API_MEM_LIMIT:-384M}
|
||||
restart: unless-stopped
|
||||
|
||||
haproxy:
|
||||
image: haproxy:2.8.14
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_healthy
|
||||
volumes:
|
||||
- ./deploy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
healthcheck:
|
||||
test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 6
|
||||
start_period: 3s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.25"
|
||||
memory: 128M
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
redisdata:
|
||||
miniodata:
|
||||
@@ -0,0 +1,46 @@
|
||||
# Единая точка входа. Sticky session нет: сессия лежит в Redis, любая реплика её читает.
|
||||
# server-template берёт все A-записи DNS Compose (127.0.0.11) и сам выкидывает backend,
|
||||
# у которого /health/ready перестал отвечать 200.
|
||||
#
|
||||
# Обнаружение отказа: inter 1s, fall 2 → не больше 2 с после 503/обрыва.
|
||||
# hold valid 1s — как часто перечитываем адреса реплик после scale/stop.
|
||||
# retries 0: балансировщик не повторяет POST. Повтор сообщения делает клиент тем же ключом.
|
||||
# Создание пользователя и чата не идемпотентно, поэтому прозрачный retry на LB запрещён.
|
||||
|
||||
global
|
||||
maxconn 256
|
||||
|
||||
resolvers docker
|
||||
nameserver dns 127.0.0.11:53
|
||||
resolve_retries 3
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
hold valid 1s
|
||||
hold other 1s
|
||||
hold refused 1s
|
||||
hold nx 1s
|
||||
hold timeout 1s
|
||||
hold obsolete 1s
|
||||
accepted_payload_size 8192
|
||||
|
||||
defaults
|
||||
mode http
|
||||
timeout connect 2s
|
||||
timeout client 120s
|
||||
timeout server 120s
|
||||
timeout http-request 10s
|
||||
timeout check 2s
|
||||
timeout queue 2s
|
||||
retries 0
|
||||
|
||||
frontend http_in
|
||||
bind *:8080
|
||||
default_backend api
|
||||
|
||||
backend api
|
||||
balance roundrobin
|
||||
option httpchk
|
||||
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api
|
||||
http-check expect status 200
|
||||
default-server inter 1s fall 2 rise 1 maxconn 64
|
||||
server-template api 8 api:8080 check resolvers docker init-addr none resolve-prefer ipv4
|
||||
@@ -0,0 +1,2 @@
|
||||
2026/11/13 15:21:03 INFO bootstrap-s3 complete
|
||||
bootstrap_exit:0
|
||||
@@ -0,0 +1,6 @@
|
||||
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": 120, "failed_attempts": 1, "first_recovery_seconds": 2.317}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
failover_exit:0
|
||||
ready_after_restore 200
|
||||
@@ -0,0 +1,24 @@
|
||||
slash filename: HTTP 400 expected 400 PASS body=b'{"error":{"code":"invalid_request","message":"\xd0\x9d\xd0\xb5\xd0\xba\xd0\xbe\xd1\x80\xd1\x80\xd0\xb5\xd0\xba\xd1\x82\xd0\xbd\xd0\xbe\xd0\xb5 \xd0\xb8\xd0\xbc\xd1\x8f \xd1\x84\xd0\xb0\xd0\xb9\xd0\xbb\xd0\xb0","request_id":"f87e88bb3a77dfcd1954869b6bd7cd1f"}}\n'
|
||||
backslash filename: HTTP 400 expected 400 PASS body=b'{"error":{"code":"invalid_request","message":"\xd0\x9d\xd0\xb5\xd0\xba\xd0\xbe\xd1\x80\xd1\x80\xd0\xb5\xd0\xba\xd1\x82\xd0\xbd\xd0\xbe\xd0\xb5 \xd0\xb8\xd0\xbc\xd1\x8f \xd1\x84\xd0\xb0\xd0\xb9\xd0\xbb\xd0\xb0","request_id":"7331f9440909ae6caf0fb44ee96e9f32"}}\n'
|
||||
text as png: HTTP 415 expected 415 PASS body=b'{"error":{"code":"unsupported_media_type","message":"\xd0\xa4\xd0\xb0\xd0\xb9\xd0\xbb \xd0\xbd\xd0\xb5 \xd1\x8f\xd0\xb2\xd0\xbb\xd1\x8f\xd0\xb5\xd1\x82\xd1\x81\xd1\x8f PNG \xd0\xb8\xd0\xbb\xd0\xb8 JPEG","request_id":"0dce761035b9400dd19b242221eb8481"}}\n'
|
||||
mime swap: HTTP 415 expected 415 PASS body=b'{"error":{"code":"unsupported_media_type","message":"\xd0\xa4\xd0\xb0\xd0\xb9\xd0\xbb \xd0\xbd\xd0\xb5 \xd1\x8f\xd0\xb2\xd0\xbb\xd1\x8f\xd0\xb5\xd1\x82\xd1\x81\xd1\x8f PNG \xd0\xb8\xd0\xbb\xd0\xb8 JPEG","request_id":"89eae50ae499ffa84222ea1b9fd09a18"}}\n'
|
||||
truncated png: HTTP 415 expected 415 PASS body=b'{"error":{"code":"unsupported_media_type","message":"\xd0\xa4\xd0\xb0\xd0\xb9\xd0\xbb \xd0\xbd\xd0\xb5 \xd1\x8f\xd0\xb2\xd0\xbb\xd1\x8f\xd0\xb5\xd1\x82\xd1\x81\xd1\x8f PNG \xd0\xb8\xd0\xbb\xd0\xb8 JPEG","request_id":"2cb180557a19a4a557ed8df5b1da7308"}}\n'
|
||||
over 10MiB: HTTP 413 expected 413 PASS body=b'{"error":{"code":"payload_too_large","message":"\xd0\xa4\xd0\xb0\xd0\xb9\xd0\xbb \xd0\xb1\xd0\xbe\xd0\xbb\xd1\x8c\xd1\x88\xd0\xb5 10 \xd0\x9c\xd0\xb8\xd0\x91","request_id":"c157c5c1d8ec893fbb5d1f173765ec58"}}\n'
|
||||
pixel bomb: HTTP 413 expected 413 PASS body=b'{"error":{"code":"payload_too_large","message":"\xd0\xa1\xd0\xbb\xd0\xb8\xd1\x88\xd0\xba\xd0\xbe\xd0\xbc \xd0\xbc\xd0\xbd\xd0\xbe\xd0\xb3\xd0\xbe \xd0\xbf\xd0\xb8\xd0\xba\xd1\x81\xd0\xb5\xd0\xbb\xd0\xb5\xd0\xb9","request_id":"83373190a90631c1480641d4a50fce7c"}}\n'
|
||||
rejected uploads left attachment rows 5->5 PASS
|
||||
good upload: HTTP 201 expected 201 PASS body=b'{"id":"3c272598-75cc-417b-9277-3049201482be","chat_id":"429de0c2-a4a9-4187-a741-967924abe036","owner_id":"7fc52156-5f47-4166-8326-20e277d73026","filename":"ok.png","content_type":"'
|
||||
unknown attachment: HTTP 404 expected 404 PASS body=b'{"error":{"code":"not_found","message":"\xd0\x9e\xd0\xb1\xd1\x8a\xd0\xb5\xd0\xba\xd1\x82 \xd0\xbd\xd0\xb5 \xd0\xbd\xd0\xb0\xd0\xb9\xd0\xb4\xd0\xb5\xd0\xbd","request_id":"f77f64b8660f9bb0a953e7e11edfc927"}}\n'
|
||||
other chat upload: HTTP 201 expected 201 PASS body=b'{"id":"f1cb80e3-3359-43e9-8f9a-b94aeef3aa62","chat_id":"f5e6ff73-8216-4083-b669-c70d9114b9ec","owner_id":"7fc52156-5f47-4166-8326-20e277d73026","filename":"foreign.png","content_ty'
|
||||
attachment from other chat: HTTP 404 expected 404 PASS body=b'{"error":{"code":"not_found","message":"\xd0\x9e\xd0\xb1\xd1\x8a\xd0\xb5\xd0\xba\xd1\x82 \xd0\xbd\xd0\xb5 \xd0\xbd\xd0\xb0\xd0\xb9\xd0\xb4\xd0\xb5\xd0\xbd","request_id":"e0c7125bce6ab391a87be26308fbe587"}}\n'
|
||||
outsider download: HTTP 404 expected 404 PASS body=b'{"error":{"code":"not_found","message":"\xd0\x9e\xd0\xb1\xd1\x8a\xd0\xb5\xd0\xba\xd1\x82 \xd0\xbd\xd0\xb5 \xd0\xbd\xd0\xb0\xd0\xb9\xd0\xb4\xd0\xb5\xd0\xbd","request_id":"f5d96f39fe154172be91ef72756666ec"}}\n'
|
||||
anonymous S3 GET 403 PASS
|
||||
console on host http_code=000 err=7
|
||||
10 parallel 1MiB uploads statuses=[415, 415, 415, 415, 415, 415, 415, 415, 415, 415] seconds=8.43 peak_api_MiB=71.4
|
||||
dry-run-1 {"mode": "dry-run", "grace_seconds": 5, "cutoff": "2026-11-13T13:56:30Z", "db_rows": 10, "s3_objects": 9, "list_pages": 1, "pairs": 7, "orphan_fresh": 1, "orphan_stale": 1, "missing_fresh": 0, "missing_referenced": 2, "missing_stale_unreferenced": 1, "deleted_objects": 0, "deleted_rows": 0, "duration_ms": 2}
|
||||
dry-run-2 same=True
|
||||
apply {"mode": "apply", "grace_seconds": 5, "cutoff": "2026-11-13T13:56:31Z", "db_rows": 10, "s3_objects": 9, "list_pages": 1, "pairs": 7, "orphan_fresh": 1, "orphan_stale": 1, "missing_fresh": 0, "missing_referenced": 2, "missing_stale_unreferenced": 1, "deleted_objects": 1, "deleted_rows": 1, "duration_ms": 4}
|
||||
apply-again {"deleted_objects": 0, "deleted_rows": 0, "orphan_stale": 0, "missing_stale_unreferenced": 0}
|
||||
referenced metadata after apply HTTP 200
|
||||
referenced bytes missing HTTP 404
|
||||
stale unreferenced metadata HTTP 404
|
||||
fresh download HTTP 200 same_bytes=True
|
||||
@@ -0,0 +1,2 @@
|
||||
ok messenger/internal/imagecheck 0.008s
|
||||
imagecheck_exit:0
|
||||
@@ -0,0 +1,2 @@
|
||||
upload HTTP 201 status=ready content_type=image/jpeg size=613 sha256=c4667e8441372971150fbd56d2eed48347fa033801754f1f6c563bf4f45b99da
|
||||
download HTTP 200 content_type=image/jpeg same_bytes=True len=613
|
||||
@@ -0,0 +1,48 @@
|
||||
api env names:
|
||||
|
||||
APP_ENV
|
||||
APP_HOST
|
||||
APP_PORT
|
||||
ARGON2_MEMORY_KIB
|
||||
ARGON2_THREADS
|
||||
ARGON2_TIME
|
||||
DATABASE_URL
|
||||
DB_MAX_CONNS
|
||||
IDEMPOTENCY_TTL_SECONDS
|
||||
MAX_IMAGE_PIXELS
|
||||
MAX_UPLOAD_BYTES
|
||||
PATH
|
||||
RECONCILE_GRACE_SECONDS
|
||||
REDIS_URL
|
||||
S3_ACCESS_KEY
|
||||
S3_BUCKET
|
||||
S3_ENDPOINT
|
||||
S3_REGION
|
||||
S3_SECRET_KEY
|
||||
SESSION_TTL_SECONDS
|
||||
SHUTDOWN_TIMEOUT_SECONDS
|
||||
SSL_CERT_FILE
|
||||
api mounts:
|
||||
[]
|
||||
minio-init env names:
|
||||
|
||||
APP_ENV
|
||||
APP_HOST
|
||||
APP_PORT
|
||||
MINIO_ROOT_PASSWORD
|
||||
MINIO_ROOT_USER
|
||||
PATH
|
||||
S3_ACCESS_KEY
|
||||
S3_BUCKET
|
||||
S3_ENDPOINT
|
||||
S3_REGION
|
||||
S3_SECRET_KEY
|
||||
SHUTDOWN_TIMEOUT_SECONDS
|
||||
SSL_CERT_FILE
|
||||
published ports:
|
||||
api 8080/tcp
|
||||
api 8080/tcp
|
||||
haproxy 127.0.0.1:8080->8080/tcp
|
||||
minio 127.0.0.1:9000->9000/tcp, 9001/tcp
|
||||
postgres 127.0.0.1:5432->5432/tcp
|
||||
redis 127.0.0.1:6379->6379/tcp
|
||||
@@ -0,0 +1,4 @@
|
||||
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.
|
||||
persistence_exit:0
|
||||
@@ -0,0 +1,4 @@
|
||||
console host:
|
||||
http_code=000 exit=7
|
||||
anonymous object:
|
||||
http_code=403
|
||||
@@ -0,0 +1,53 @@
|
||||
{
|
||||
"dry": {
|
||||
"mode": "dry-run",
|
||||
"grace_seconds": 5,
|
||||
"cutoff": "2026-11-13T13:56:30Z",
|
||||
"db_rows": 10,
|
||||
"s3_objects": 9,
|
||||
"list_pages": 1,
|
||||
"pairs": 7,
|
||||
"orphan_fresh": 1,
|
||||
"orphan_stale": 1,
|
||||
"missing_fresh": 0,
|
||||
"missing_referenced": 2,
|
||||
"missing_stale_unreferenced": 1,
|
||||
"deleted_objects": 0,
|
||||
"deleted_rows": 0,
|
||||
"duration_ms": 2
|
||||
},
|
||||
"apply": {
|
||||
"mode": "apply",
|
||||
"grace_seconds": 5,
|
||||
"cutoff": "2026-11-13T13:56:31Z",
|
||||
"db_rows": 10,
|
||||
"s3_objects": 9,
|
||||
"list_pages": 1,
|
||||
"pairs": 7,
|
||||
"orphan_fresh": 1,
|
||||
"orphan_stale": 1,
|
||||
"missing_fresh": 0,
|
||||
"missing_referenced": 2,
|
||||
"missing_stale_unreferenced": 1,
|
||||
"deleted_objects": 1,
|
||||
"deleted_rows": 1,
|
||||
"duration_ms": 4
|
||||
},
|
||||
"again": {
|
||||
"mode": "apply",
|
||||
"grace_seconds": 5,
|
||||
"cutoff": "2026-11-13T13:56:31Z",
|
||||
"db_rows": 9,
|
||||
"s3_objects": 8,
|
||||
"list_pages": 1,
|
||||
"pairs": 7,
|
||||
"orphan_fresh": 1,
|
||||
"orphan_stale": 0,
|
||||
"missing_fresh": 0,
|
||||
"missing_referenced": 2,
|
||||
"missing_stale_unreferenced": 0,
|
||||
"deleted_objects": 0,
|
||||
"deleted_rows": 0,
|
||||
"duration_ms": 2
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
/messenger-lab4-api-1 2026-11-13T15:21:24.371344153Z changed=True
|
||||
/messenger-lab4-api-2 2026-11-13T15:21:24.097492187Z changed=True
|
||||
/messenger-lab4-haproxy-1 2026-11-13T15:21:23.853867151Z changed=True
|
||||
/messenger-lab4-minio-1 2026-11-13T15:21:23.912731663Z changed=True
|
||||
/messenger-lab4-postgres-1 2026-11-13T15:21:23.929193078Z changed=True
|
||||
/messenger-lab4-redis-1 2026-11-13T15:21:23.798144563Z changed=True
|
||||
@@ -0,0 +1,6 @@
|
||||
/messenger-lab4-api-1 2026-11-13T13:57:38.601482122Z
|
||||
/messenger-lab4-api-2 2026-11-13T13:57:12.678628253Z
|
||||
/messenger-lab4-haproxy-1 2026-11-13T13:57:12.296072145Z
|
||||
/messenger-lab4-minio-1 2026-11-13T13:57:12.399188879Z
|
||||
/messenger-lab4-postgres-1 2026-11-13T13:57:12.441137115Z
|
||||
/messenger-lab4-redis-1 2026-11-13T13:57:12.342361107Z
|
||||
@@ -0,0 +1,8 @@
|
||||
Container messenger-lab4-minio-1 Stopping
|
||||
Container messenger-lab4-minio-1 Stopped
|
||||
ready_while_stopped {"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"ee574af75872b15d575a895357e5bd95"}}
|
||||
http=503
|
||||
Container messenger-lab4-minio-1 Starting
|
||||
Container messenger-lab4-minio-1 Started
|
||||
ready_after_start 503
|
||||
ready_after_start 200
|
||||
@@ -0,0 +1,3 @@
|
||||
BucketExists messenger-attachments: ok=true no_error=true
|
||||
MakeBucket messenger-other-bucket: AccessDenied
|
||||
rights_exit:0
|
||||
@@ -0,0 +1,3 @@
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
|
||||
smoke_exit:0
|
||||
@@ -0,0 +1,54 @@
|
||||
module messenger
|
||||
|
||||
go 1.26.0
|
||||
|
||||
require (
|
||||
github.com/jackc/pgx/v5 v5.11.0
|
||||
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-ini/ini v1.67.0 // indirect
|
||||
github.com/go-ole/go-ole v1.3.0 // indirect
|
||||
github.com/goccy/go-json v0.10.5 // 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.18.0 // indirect
|
||||
github.com/klauspost/cpuid/v2 v2.4.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.0.2 // indirect
|
||||
github.com/minio/madmin-go/v3 v3.0.110 // indirect
|
||||
github.com/minio/md5-simd v1.1.2 // indirect
|
||||
github.com/minio/minio-go/v7 v7.0.95 // 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.3.0 // 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
|
||||
go.uber.org/atomic v1.12.0 // 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.6 // indirect
|
||||
)
|
||||
@@ -0,0 +1,122 @@
|
||||
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/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-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
|
||||
github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
|
||||
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/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
|
||||
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
|
||||
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/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.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
|
||||
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
|
||||
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/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.0.2 h1:6uO1UxGAD+kwqWWp7mBFsi5gAse66C4NXO8cmcVculg=
|
||||
github.com/minio/crc64nvme v1.0.2/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.0.95 h1:ywOUPg+PebTMTzn9VDsoFJy32ZuARN9zhB+K3IYEvYU=
|
||||
github.com/minio/minio-go/v7 v7.0.95/go.mod h1:wOOX3uxS334vImCNRVyIDdXX9OsXDm89ToynKgqUKlo=
|
||||
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/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
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.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
|
||||
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
|
||||
github.com/tinylib/msgp v1.3.0 h1:ULuf7GPooDaIlbyvgAxBV/FI7ynli6LZ1/nVUNu+0ww=
|
||||
github.com/tinylib/msgp v1.3.0/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0=
|
||||
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/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.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
|
||||
google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
+14
-3
@@ -1,7 +1,18 @@
|
||||
# Инфраструктура студента
|
||||
|
||||
Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли.
|
||||
Стенд — корневой `compose.yaml`. `compose.example.yaml` не запускается.
|
||||
|
||||
В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд.
|
||||
| Роль | service | Образ |
|
||||
| --- | --- | --- |
|
||||
| PostgreSQL | postgres | postgres:16.10-bookworm |
|
||||
| Redis | redis | redis:7.4.6-alpine |
|
||||
| S3 | minio | alpine/minio:RELEASE.2025-10-15T17-29-55Z, digest sha256:cf23643a6cf9ce159c57643ceb88279e431262282428c9e0bf3a7ef1a97e84b4 |
|
||||
| Bootstrap bucket | minio-init | тот же образ API, команда `bootstrap-s3` |
|
||||
| Балансировщик | haproxy | haproxy:2.8.14 |
|
||||
| API | api | сборка из Dockerfile, тег messenger-api:lab4 |
|
||||
|
||||
Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику.
|
||||
Сервер MinIO берётся из Alpine-сборки релиза `RELEASE.2025-10-15T17-29-55Z`. У бинарника в этой сборке строка версии `DEVELOPMENT.GOGET`: в образ не передали release ldflags. Закреплены тег и digest.
|
||||
|
||||
Bucket `messenger-attachments` приватный. Консоль слушает `127.0.0.1:9001` внутри контейнера и на хост не проброшена. Порт S3 на хосте — `127.0.0.1:9000`. Root нужен только `minio-init`. API использует `S3_ACCESS_KEY` с политикой `messenger-app` на один bucket.
|
||||
|
||||
Повтор bootstrap: `docker compose --env-file .env up -d minio-init` после healthy MinIO. Команда создаёт bucket, политику и пользователя, если их ещё нет, и проверяет, что прикладной ключ видит bucket.
|
||||
|
||||
@@ -0,0 +1,277 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
|
||||
"messenger/internal/blob"
|
||||
"messenger/internal/imagecheck"
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
type attachmentJSON 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 []struct{} `json:"variants"`
|
||||
ErrorCode *string `json:"error_code"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
UpdatedAt string `json:"updated_at"`
|
||||
}
|
||||
|
||||
func (a *API) routeAttachment(w http.ResponseWriter, r *http.Request, rest string) {
|
||||
if _, ok := a.authenticate(w, r); !ok {
|
||||
return
|
||||
}
|
||||
rest = strings.Trim(rest, "/")
|
||||
if rest == "" || strings.Count(rest, "/") > 1 {
|
||||
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
|
||||
return
|
||||
}
|
||||
id, content, hasContent := strings.Cut(rest, "/")
|
||||
if hasContent && content != "content" {
|
||||
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
|
||||
return
|
||||
}
|
||||
if _, ok := canonicalUUID(id); !ok {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный идентификатор", 0)
|
||||
return
|
||||
}
|
||||
if r.Method != http.MethodGet {
|
||||
a.fail(w, r, http.StatusMethodNotAllowed, "invalid_request", "Метод не поддерживается", 0)
|
||||
return
|
||||
}
|
||||
if hasContent {
|
||||
a.downloadAttachment(w, r, id)
|
||||
return
|
||||
}
|
||||
a.getAttachment(w, r, id)
|
||||
}
|
||||
|
||||
func (a *API) uploadAttachment(w http.ResponseWriter, r *http.Request, rawChatID string) {
|
||||
user, ok := a.authenticate(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if a.blobs == nil {
|
||||
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1)
|
||||
return
|
||||
}
|
||||
chatID, ok := a.chatID(w, r, rawChatID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if _, err := a.store.ChatFor(r.Context(), chatID, user.ID); a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
filename := r.URL.Query().Get("filename")
|
||||
if !validFilename(filename) {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректное имя файла", 0)
|
||||
return
|
||||
}
|
||||
media := ""
|
||||
if ct := r.Header.Get("Content-Type"); ct != "" {
|
||||
media = strings.ToLower(strings.TrimSpace(strings.Split(ct, ";")[0]))
|
||||
}
|
||||
if media != "image/png" && media != "image/jpeg" {
|
||||
a.fail(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "Нужен PNG или JPEG", 0)
|
||||
return
|
||||
}
|
||||
// Не отвечаем до чтения: иначе клиент ещё шлёт тело и видит обрыв вместо 413.
|
||||
// Читаем не больше лимита плюс один байт. Лишний байт - отказ, без записи в bucket.
|
||||
body, err := io.ReadAll(io.LimitReader(r.Body, a.maxUpload+1))
|
||||
if err != nil {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Загрузка прервана", 0)
|
||||
return
|
||||
}
|
||||
if int64(len(body)) > a.maxUpload {
|
||||
a.fail(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "Файл больше 10 МиБ", 0)
|
||||
return
|
||||
}
|
||||
if len(body) == 0 {
|
||||
a.fail(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "Пустое изображение", 0)
|
||||
return
|
||||
}
|
||||
width, height, err := imagecheck.Inspect(media, body, a.maxPixels)
|
||||
if err != nil {
|
||||
if errors.Is(err, imagecheck.ErrPixels) {
|
||||
a.fail(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "Слишком много пикселей", 0)
|
||||
return
|
||||
}
|
||||
a.fail(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "Файл не является PNG или JPEG", 0)
|
||||
return
|
||||
}
|
||||
sum := sha256.Sum256(body)
|
||||
key, err := newObjectKey()
|
||||
if err != nil {
|
||||
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
|
||||
return
|
||||
}
|
||||
if err := a.blobs.Put(r.Context(), key, media, body); err != nil {
|
||||
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1)
|
||||
return
|
||||
}
|
||||
row, err := a.store.InsertAttachment(r.Context(), store.Attachment{
|
||||
ChatID: chatID,
|
||||
OwnerID: user.ID,
|
||||
Filename: filename,
|
||||
ContentType: media,
|
||||
SizeBytes: int64(len(body)),
|
||||
SHA256: hex.EncodeToString(sum[:]),
|
||||
ObjectKey: key,
|
||||
Width: width,
|
||||
Height: height,
|
||||
})
|
||||
if err != nil {
|
||||
// PUT уже прошёл, COMMIT нет: сразу убираем объект. Если удаление не удалось,
|
||||
// ключ останется сиротой до сверки и не попадёт в ответ 201.
|
||||
if delErr := a.blobs.Delete(r.Context(), key); delErr != nil {
|
||||
a.log.Error("orphan object", "request_id", requestIDFrom(r))
|
||||
}
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, asAttachment(row))
|
||||
}
|
||||
|
||||
func (a *API) getAttachment(w http.ResponseWriter, r *http.Request, rawID string) {
|
||||
row, ok := a.visibleAttachment(w, r, rawID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, asAttachment(row))
|
||||
}
|
||||
|
||||
func (a *API) downloadAttachment(w http.ResponseWriter, r *http.Request, rawID string) {
|
||||
row, ok := a.visibleAttachment(w, r, rawID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
variant := "original"
|
||||
if r.URL.Query().Has("variant") {
|
||||
variant = r.URL.Query().Get("variant")
|
||||
}
|
||||
switch variant {
|
||||
case "original":
|
||||
case "thumbnail", "crop", "optimized":
|
||||
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
|
||||
return
|
||||
default:
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный вариант", 0)
|
||||
return
|
||||
}
|
||||
if a.blobs == nil {
|
||||
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1)
|
||||
return
|
||||
}
|
||||
rc, err := a.blobs.Get(r.Context(), row.ObjectKey)
|
||||
if err != nil {
|
||||
if errors.Is(err, blob.ErrNotFound) {
|
||||
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
|
||||
return
|
||||
}
|
||||
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1)
|
||||
return
|
||||
}
|
||||
defer rc.Close()
|
||||
w.Header().Set("Content-Type", row.ContentType)
|
||||
w.Header().Set("Content-Length", strconv.FormatInt(row.SizeBytes, 10))
|
||||
w.WriteHeader(http.StatusOK)
|
||||
if _, err := io.Copy(w, rc); err != nil {
|
||||
a.log.Error("download", "request_id", requestIDFrom(r))
|
||||
}
|
||||
}
|
||||
|
||||
func (a *API) visibleAttachment(w http.ResponseWriter, r *http.Request, rawID string) (store.Attachment, bool) {
|
||||
user, ok := a.authenticate(w, r)
|
||||
if !ok {
|
||||
return store.Attachment{}, false
|
||||
}
|
||||
id, ok := canonicalUUID(rawID)
|
||||
if !ok {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный идентификатор", 0)
|
||||
return store.Attachment{}, false
|
||||
}
|
||||
row, err := a.store.AttachmentVisible(r.Context(), id, user.ID)
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return store.Attachment{}, false
|
||||
}
|
||||
return row, true
|
||||
}
|
||||
|
||||
func (a *API) attachmentIDList(w http.ResponseWriter, r *http.Request, raw []string) ([]string, bool) {
|
||||
if len(raw) > 10 {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Слишком много вложений", 0)
|
||||
return nil, false
|
||||
}
|
||||
seen := make(map[string]struct{}, len(raw))
|
||||
out := make([]string, 0, len(raw))
|
||||
for _, item := range raw {
|
||||
id, ok := canonicalUUID(item)
|
||||
if !ok {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный идентификатор вложения", 0)
|
||||
return nil, false
|
||||
}
|
||||
if _, dup := seen[id]; dup {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Повторяющееся вложение", 0)
|
||||
return nil, false
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
out = append(out, id)
|
||||
}
|
||||
return out, true
|
||||
}
|
||||
|
||||
func asAttachment(row store.Attachment) attachmentJSON {
|
||||
return attachmentJSON{
|
||||
ID: row.ID,
|
||||
ChatID: row.ChatID,
|
||||
OwnerID: row.OwnerID,
|
||||
Filename: row.Filename,
|
||||
ContentType: row.ContentType,
|
||||
SizeBytes: row.SizeBytes,
|
||||
SHA256: row.SHA256,
|
||||
Status: row.Status,
|
||||
Variants: []struct{}{},
|
||||
ErrorCode: nil,
|
||||
CreatedAt: formatTime(row.CreatedAt),
|
||||
UpdatedAt: formatTime(row.UpdatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func validFilename(name string) bool {
|
||||
if !utf8.ValidString(name) {
|
||||
return false
|
||||
}
|
||||
n := utf8.RuneCountInString(name)
|
||||
if n < 1 || n > 255 {
|
||||
return false
|
||||
}
|
||||
for _, r := range name {
|
||||
if r < 0x20 || r == 0x7f || r == '/' || r == '\\' {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func newObjectKey() (string, error) {
|
||||
var b [32]byte
|
||||
if _, err := rand.Read(b[:]); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return "o/" + hex.EncodeToString(b[:]), nil
|
||||
}
|
||||
@@ -0,0 +1,182 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"messenger/internal/password"
|
||||
"messenger/internal/session"
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
const (
|
||||
basicChallenge = `Basic realm="messenger", charset="UTF-8"`
|
||||
bearerChallenge = `Bearer realm="messenger"`
|
||||
)
|
||||
|
||||
func (a *API) createSession(w http.ResponseWriter, r *http.Request) {
|
||||
if !emptyBody(r) {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "У входа не должно быть тела", 0)
|
||||
return
|
||||
}
|
||||
username, plain, ok := parseBasic(r)
|
||||
if !ok || !usernameRe.MatchString(username) || !validPassword(plain) {
|
||||
a.unauthorized(w, r, basicChallenge)
|
||||
return
|
||||
}
|
||||
user, hash, err := a.store.UserByUsername(r.Context(), username)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
password.Verify(plain, a.dummyHash)
|
||||
a.unauthorized(w, r, basicChallenge)
|
||||
return
|
||||
}
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
if !password.Verify(plain, hash) {
|
||||
a.unauthorized(w, r, basicChallenge)
|
||||
return
|
||||
}
|
||||
token, err := newToken()
|
||||
if err != nil {
|
||||
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
|
||||
return
|
||||
}
|
||||
expires := time.Now().UTC().Add(a.sessionTTL).Truncate(time.Microsecond)
|
||||
if err := a.sessions.Create(r.Context(), token, user.ID, expires); a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, map[string]any{
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": formatTime(expires),
|
||||
"user": asUser(user),
|
||||
})
|
||||
}
|
||||
|
||||
func (a *API) revokeSession(w http.ResponseWriter, r *http.Request) {
|
||||
token, ok := a.bearerToken(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if _, _, err := a.sessions.Lookup(r.Context(), token); err != nil {
|
||||
if errors.Is(err, session.ErrNotFound) {
|
||||
a.unauthorized(w, r, bearerChallenge)
|
||||
return
|
||||
}
|
||||
a.writeStoreErr(w, r, err)
|
||||
return
|
||||
}
|
||||
if err := a.sessions.Revoke(r.Context(), token); err != nil {
|
||||
if errors.Is(err, session.ErrNotFound) {
|
||||
a.unauthorized(w, r, bearerChallenge)
|
||||
return
|
||||
}
|
||||
a.writeStoreErr(w, r, err)
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
|
||||
func (a *API) authenticate(w http.ResponseWriter, r *http.Request) (store.User, bool) {
|
||||
token, ok := a.bearerToken(w, r)
|
||||
if !ok {
|
||||
return store.User{}, false
|
||||
}
|
||||
userID, expires, err := a.sessions.Lookup(r.Context(), token)
|
||||
if errors.Is(err, session.ErrNotFound) || (err == nil && !time.Now().Before(expires)) {
|
||||
if err == nil {
|
||||
_ = a.sessions.Revoke(r.Context(), token)
|
||||
}
|
||||
a.unauthorized(w, r, bearerChallenge)
|
||||
return store.User{}, false
|
||||
}
|
||||
if err != nil {
|
||||
a.writeStoreErr(w, r, err)
|
||||
return store.User{}, false
|
||||
}
|
||||
user, err := a.store.User(r.Context(), userID)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
a.unauthorized(w, r, bearerChallenge)
|
||||
return store.User{}, false
|
||||
}
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return store.User{}, false
|
||||
}
|
||||
return user, true
|
||||
}
|
||||
|
||||
func (a *API) bearerToken(w http.ResponseWriter, r *http.Request) (string, bool) {
|
||||
scheme, param, ok := splitAuth(r.Header.Get("Authorization"))
|
||||
if !ok || !strings.EqualFold(scheme, "Bearer") || param == "" || len(param) > 512 || strings.Contains(param, " ") {
|
||||
a.unauthorized(w, r, bearerChallenge)
|
||||
return "", false
|
||||
}
|
||||
return param, true
|
||||
}
|
||||
|
||||
func (a *API) unauthorized(w http.ResponseWriter, r *http.Request, challenge string) {
|
||||
w.Header().Set("WWW-Authenticate", challenge)
|
||||
a.fail(w, r, http.StatusUnauthorized, "unauthorized", "Нет действительной идентификации", 0)
|
||||
}
|
||||
|
||||
func parseBasic(r *http.Request) (string, string, bool) {
|
||||
scheme, param, ok := splitAuth(r.Header.Get("Authorization"))
|
||||
if !ok || !strings.EqualFold(scheme, "Basic") || param == "" {
|
||||
return "", "", false
|
||||
}
|
||||
raw, err := base64.StdEncoding.DecodeString(param)
|
||||
if err != nil {
|
||||
raw, err = base64.RawStdEncoding.DecodeString(param)
|
||||
if err != nil {
|
||||
return "", "", false
|
||||
}
|
||||
}
|
||||
if !utf8.Valid(raw) {
|
||||
return "", "", false
|
||||
}
|
||||
username, plain, ok := strings.Cut(string(raw), ":")
|
||||
if !ok || username == "" {
|
||||
return "", "", false
|
||||
}
|
||||
return username, plain, true
|
||||
}
|
||||
|
||||
func splitAuth(header string) (string, string, bool) {
|
||||
scheme, param, ok := strings.Cut(strings.TrimSpace(header), " ")
|
||||
if !ok {
|
||||
return "", "", false
|
||||
}
|
||||
param = strings.TrimSpace(param)
|
||||
if scheme == "" || param == "" {
|
||||
return "", "", false
|
||||
}
|
||||
return scheme, param, true
|
||||
}
|
||||
|
||||
func emptyBody(r *http.Request) bool {
|
||||
if r.Body == nil || r.ContentLength == 0 {
|
||||
return true
|
||||
}
|
||||
buf := make([]byte, 1)
|
||||
n, err := r.Body.Read(buf)
|
||||
if n > 0 {
|
||||
return false
|
||||
}
|
||||
return err == io.EOF || err == nil
|
||||
}
|
||||
|
||||
func newToken() (string, error) {
|
||||
var b [32]byte
|
||||
if _, err := rand.Read(b[:]); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return hex.EncodeToString(b[:]), nil
|
||||
}
|
||||
@@ -0,0 +1,365 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"messenger/internal/session"
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
func (a *API) live(w http.ResponseWriter, _ *http.Request) {
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (a *API) ready(w http.ResponseWriter, r *http.Request) {
|
||||
if a.shutting.Load() {
|
||||
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервер останавливается", 1)
|
||||
return
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 800*time.Millisecond)
|
||||
defer cancel()
|
||||
if err := a.store.Ping(ctx); err != nil || a.sessions.Ping(ctx) != nil {
|
||||
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1)
|
||||
return
|
||||
}
|
||||
if a.blobs != nil {
|
||||
if err := a.blobs.Ping(ctx); err != nil {
|
||||
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1)
|
||||
return
|
||||
}
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (a *API) route(w http.ResponseWriter, r *http.Request) {
|
||||
path := r.URL.Path
|
||||
switch {
|
||||
case path == "/api/v1/users" && r.Method == http.MethodPost:
|
||||
a.createUser(w, r)
|
||||
case path == "/api/v1/users/me" && r.Method == http.MethodGet:
|
||||
a.currentUser(w, r)
|
||||
case path == "/api/v1/auth/sessions" && r.Method == http.MethodPost:
|
||||
a.createSession(w, r)
|
||||
case path == "/api/v1/auth/sessions/current" && r.Method == http.MethodDelete:
|
||||
a.revokeSession(w, r)
|
||||
case path == "/api/v1/chats" && r.Method == http.MethodPost:
|
||||
a.createChat(w, r)
|
||||
case path == "/api/v1/chats" && r.Method == http.MethodGet:
|
||||
a.listChats(w, r)
|
||||
default:
|
||||
if strings.HasPrefix(path, "/api/v1/attachments/") {
|
||||
a.routeAttachment(w, r, strings.TrimPrefix(path, "/api/v1/attachments/"))
|
||||
return
|
||||
}
|
||||
chatID, kind, ok := splitChatPath(path)
|
||||
if !ok {
|
||||
if knownWrongMethod(path) {
|
||||
a.fail(w, r, http.StatusMethodNotAllowed, "invalid_request", "Метод не поддерживается", 0)
|
||||
return
|
||||
}
|
||||
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
|
||||
return
|
||||
}
|
||||
switch kind {
|
||||
case "":
|
||||
if r.Method == http.MethodGet {
|
||||
a.getChat(w, r, chatID)
|
||||
return
|
||||
}
|
||||
case "messages":
|
||||
switch r.Method {
|
||||
case http.MethodPost:
|
||||
a.createMessage(w, r, chatID)
|
||||
return
|
||||
case http.MethodGet:
|
||||
a.listMessages(w, r, chatID)
|
||||
return
|
||||
}
|
||||
case "attachments":
|
||||
if r.Method == http.MethodPost {
|
||||
a.uploadAttachment(w, r, chatID)
|
||||
return
|
||||
}
|
||||
}
|
||||
a.fail(w, r, http.StatusMethodNotAllowed, "invalid_request", "Метод не поддерживается", 0)
|
||||
}
|
||||
}
|
||||
|
||||
func knownWrongMethod(path string) bool {
|
||||
switch path {
|
||||
case "/api/v1/users", "/api/v1/users/me", "/api/v1/chats",
|
||||
"/api/v1/auth/sessions", "/api/v1/auth/sessions/current":
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func (a *API) createUser(w http.ResponseWriter, r *http.Request) {
|
||||
var body struct {
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
if !a.readJSON(w, r, &body) {
|
||||
return
|
||||
}
|
||||
if !usernameRe.MatchString(body.Username) || !validText(body.DisplayName, 1, 100) || !validPassword(body.Password) {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректные поля пользователя", 0)
|
||||
return
|
||||
}
|
||||
hash, err := a.hasher.Hash(body.Password)
|
||||
if err != nil {
|
||||
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
|
||||
return
|
||||
}
|
||||
user, err := a.store.CreateUser(r.Context(), body.Username, body.DisplayName, hash)
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, asUser(user))
|
||||
}
|
||||
|
||||
func (a *API) currentUser(w http.ResponseWriter, r *http.Request) {
|
||||
user, ok := a.authenticate(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, asUser(user))
|
||||
}
|
||||
|
||||
func (a *API) createChat(w http.ResponseWriter, r *http.Request) {
|
||||
caller, ok := a.authenticate(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var body struct {
|
||||
Title string `json:"title"`
|
||||
MemberIDs []string `json:"member_ids"`
|
||||
}
|
||||
if !a.readJSON(w, r, &body) {
|
||||
return
|
||||
}
|
||||
if !validText(body.Title, 1, 100) || len(body.MemberIDs) < 1 || len(body.MemberIDs) > 100 {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректные поля чата", 0)
|
||||
return
|
||||
}
|
||||
ids := make([]string, len(body.MemberIDs))
|
||||
seen := make(map[string]struct{}, len(body.MemberIDs))
|
||||
callerIn := false
|
||||
for i, raw := range body.MemberIDs {
|
||||
id, ok := canonicalUUID(raw)
|
||||
if !ok {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
|
||||
return
|
||||
}
|
||||
if _, dup := seen[id]; dup {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
|
||||
return
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
_, err := a.store.User(r.Context(), id)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
|
||||
return
|
||||
}
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
if id == caller.ID {
|
||||
callerIn = true
|
||||
}
|
||||
ids[i] = id
|
||||
}
|
||||
if !callerIn {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
|
||||
return
|
||||
}
|
||||
chat, err := a.store.CreateChat(r.Context(), body.Title, ids, caller.ID)
|
||||
if errors.Is(err, store.ErrInvalid) {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0)
|
||||
return
|
||||
}
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, asChat(chat))
|
||||
}
|
||||
|
||||
func (a *API) listChats(w http.ResponseWriter, r *http.Request) {
|
||||
user, ok := a.authenticate(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
limit, cur, ok := a.pageQuery(w, r, "chats:"+user.ID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
items, hasMore, err := a.store.ListChats(r.Context(), user.ID, cur, limit)
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
out := make([]chatJSON, 0, len(items))
|
||||
for _, c := range items {
|
||||
out = append(out, asChat(c))
|
||||
}
|
||||
var next *string
|
||||
if hasMore && len(items) > 0 {
|
||||
last := items[len(items)-1]
|
||||
encoded := encodeCursor(cursorPayload{Scope: "chats:" + user.ID, ID: last.ID, At: formatTime(last.CreatedAt)})
|
||||
next = &encoded
|
||||
}
|
||||
writeJSON(w, http.StatusOK, chatPage{Items: out, NextCursor: next})
|
||||
}
|
||||
|
||||
func (a *API) getChat(w http.ResponseWriter, r *http.Request, rawID string) {
|
||||
user, ok := a.authenticate(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
id, ok := a.chatID(w, r, rawID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
chat, err := a.store.ChatFor(r.Context(), id, user.ID)
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, asChat(chat))
|
||||
}
|
||||
|
||||
func (a *API) createMessage(w http.ResponseWriter, r *http.Request, rawID string) {
|
||||
user, ok := a.authenticate(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
id, ok := a.chatID(w, r, rawID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if _, err := a.store.ChatFor(r.Context(), id, user.ID); a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
idemKey := r.Header.Get("Idempotency-Key")
|
||||
if !idemKeyRe.MatchString(idemKey) {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Нужен заголовок Idempotency-Key", 0)
|
||||
return
|
||||
}
|
||||
var body struct {
|
||||
Text string `json:"text"`
|
||||
AttachmentIDs []string `json:"attachment_ids"`
|
||||
}
|
||||
if !a.readJSON(w, r, &body) {
|
||||
return
|
||||
}
|
||||
ids, ok := a.attachmentIDList(w, r, body.AttachmentIDs)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if !validMessageText(body.Text, len(ids)) {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный текст сообщения", 0)
|
||||
return
|
||||
}
|
||||
// Отпечаток — разобранные поля, не сырые байты: порядок ключей JSON и отсутствующий attachment_ids равны пустому списку.
|
||||
msg, err := a.store.AddMessage(r.Context(), id, user.ID, body.Text, ids, idemKey, messageFingerprint(body.Text, ids))
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, asMessage(msg))
|
||||
}
|
||||
|
||||
func (a *API) listMessages(w http.ResponseWriter, r *http.Request, rawID string) {
|
||||
user, ok := a.authenticate(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
id, ok := a.chatID(w, r, rawID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if _, err := a.store.ChatFor(r.Context(), id, user.ID); a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
limit, cur, ok := a.pageQuery(w, r, "msg:"+id)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
items, hasMore, err := a.store.ListMessages(r.Context(), id, user.ID, cur, limit)
|
||||
if a.writeStoreErr(w, r, err) {
|
||||
return
|
||||
}
|
||||
out := make([]messageJSON, 0, len(items))
|
||||
for _, m := range items {
|
||||
out = append(out, asMessage(m))
|
||||
}
|
||||
var next *string
|
||||
if hasMore && len(items) > 0 {
|
||||
last := items[len(items)-1]
|
||||
encoded := encodeCursor(cursorPayload{Scope: "msg:" + id, ID: last.ID, At: formatTime(last.CreatedAt)})
|
||||
next = &encoded
|
||||
}
|
||||
writeJSON(w, http.StatusOK, messagePage{Items: out, NextCursor: next})
|
||||
}
|
||||
|
||||
func (a *API) chatID(w http.ResponseWriter, r *http.Request, raw string) (string, bool) {
|
||||
id, ok := canonicalUUID(raw)
|
||||
if !ok {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный идентификатор", 0)
|
||||
return "", false
|
||||
}
|
||||
return id, true
|
||||
}
|
||||
|
||||
func (a *API) writeStoreErr(w http.ResponseWriter, r *http.Request, err error) bool {
|
||||
if err == nil {
|
||||
return false
|
||||
}
|
||||
switch {
|
||||
case errors.Is(err, store.ErrUnavailable), errors.Is(err, session.ErrUnavailable):
|
||||
a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1)
|
||||
case errors.Is(err, store.ErrIdempotencyMismatch):
|
||||
a.fail(w, r, http.StatusConflict, "conflict", "Этот ключ уже использован для другого сообщения", 0)
|
||||
case errors.Is(err, store.ErrConflict):
|
||||
a.fail(w, r, http.StatusConflict, "conflict", "Имя пользователя уже занято", 0)
|
||||
case errors.Is(err, store.ErrNotFound):
|
||||
a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0)
|
||||
case errors.Is(err, store.ErrNotReady):
|
||||
a.fail(w, r, http.StatusConflict, "conflict", "Вложение нельзя прикрепить", 0)
|
||||
case errors.Is(err, store.ErrInvalid):
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректные данные", 0)
|
||||
case errors.Is(err, store.ErrBadCursor):
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
|
||||
default:
|
||||
a.log.Error("store", "request_id", requestIDFrom(r))
|
||||
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func splitChatPath(path string) (id, kind string, ok bool) {
|
||||
const prefix = "/api/v1/chats/"
|
||||
if !strings.HasPrefix(path, prefix) {
|
||||
return "", "", false
|
||||
}
|
||||
rest := strings.TrimPrefix(path, prefix)
|
||||
if rest == "" {
|
||||
return "", "", false
|
||||
}
|
||||
for _, suffix := range []string{"/messages", "/attachments"} {
|
||||
if strings.HasSuffix(rest, suffix) {
|
||||
id = strings.TrimSuffix(rest, suffix)
|
||||
if id == "" || strings.Contains(id, "/") {
|
||||
return "", "", false
|
||||
}
|
||||
return id, strings.TrimPrefix(suffix, "/"), true
|
||||
}
|
||||
}
|
||||
if strings.Contains(rest, "/") {
|
||||
return "", "", false
|
||||
}
|
||||
return rest, "", true
|
||||
}
|
||||
@@ -0,0 +1,338 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"io"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
|
||||
var uuidRe = regexp.MustCompile(`(?i)^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`)
|
||||
var limitRe = regexp.MustCompile(`^[0-9]{1,3}$`)
|
||||
var requestIDRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,64}$`)
|
||||
var idemKeyRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
|
||||
|
||||
type errorEnvelope struct {
|
||||
Error errorObject `json:"error"`
|
||||
}
|
||||
|
||||
type errorObject struct {
|
||||
Code string `json:"code"`
|
||||
Message string `json:"message"`
|
||||
RequestID string `json:"request_id"`
|
||||
}
|
||||
|
||||
type userJSON struct {
|
||||
ID string `json:"id"`
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
type chatJSON struct {
|
||||
ID string `json:"id"`
|
||||
Title string `json:"title"`
|
||||
MemberIDs []string `json:"member_ids"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
type messageJSON 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 chatPage struct {
|
||||
Items []chatJSON `json:"items"`
|
||||
NextCursor *string `json:"next_cursor"`
|
||||
}
|
||||
|
||||
type messagePage struct {
|
||||
Items []messageJSON `json:"items"`
|
||||
NextCursor *string `json:"next_cursor"`
|
||||
}
|
||||
|
||||
type cursorPayload struct {
|
||||
Scope string `json:"scope"`
|
||||
ID string `json:"id"`
|
||||
At string `json:"at"`
|
||||
}
|
||||
|
||||
type statusWriter struct {
|
||||
http.ResponseWriter
|
||||
status int
|
||||
wrote bool
|
||||
}
|
||||
|
||||
func (s *statusWriter) WriteHeader(code int) {
|
||||
if s.wrote {
|
||||
return
|
||||
}
|
||||
s.status = code
|
||||
s.wrote = true
|
||||
s.ResponseWriter.WriteHeader(code)
|
||||
}
|
||||
|
||||
func (s *statusWriter) Write(b []byte) (int, error) {
|
||||
if !s.wrote {
|
||||
s.WriteHeader(http.StatusOK)
|
||||
}
|
||||
return s.ResponseWriter.Write(b)
|
||||
}
|
||||
|
||||
func (a *API) fail(w http.ResponseWriter, r *http.Request, status int, code, message string, retryAfter int) {
|
||||
if retryAfter > 0 {
|
||||
w.Header().Set("Retry-After", strconv.Itoa(retryAfter))
|
||||
}
|
||||
writeJSON(w, status, errorEnvelope{Error: errorObject{
|
||||
Code: code,
|
||||
Message: message,
|
||||
RequestID: requestIDFrom(r),
|
||||
}})
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
w.WriteHeader(status)
|
||||
enc := json.NewEncoder(w)
|
||||
enc.SetEscapeHTML(false)
|
||||
_ = enc.Encode(v)
|
||||
}
|
||||
|
||||
func (a *API) readJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
|
||||
media := ""
|
||||
if ct := r.Header.Get("Content-Type"); ct != "" {
|
||||
media = strings.TrimSpace(strings.Split(ct, ";")[0])
|
||||
}
|
||||
if !strings.EqualFold(media, "application/json") {
|
||||
a.fail(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "Нужен Content-Type application/json", 0)
|
||||
return false
|
||||
}
|
||||
body, err := io.ReadAll(r.Body)
|
||||
if err != nil || !utf8.Valid(body) || !decodeExactJSON(body, dst) {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный JSON", 0)
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// decodeExactJSON принимает один JSON-объект: точные имена полей, без хвоста и без замены битого UTF-8.
|
||||
func decodeExactJSON(body []byte, dst any) bool {
|
||||
dec := json.NewDecoder(bytes.NewReader(body))
|
||||
var fields map[string]json.RawMessage
|
||||
if err := dec.Decode(&fields); err != nil || fields == nil {
|
||||
return false
|
||||
}
|
||||
var trailing json.RawMessage
|
||||
if err := dec.Decode(&trailing); err != io.EOF {
|
||||
return false
|
||||
}
|
||||
allowed, ok := jsonFieldNames(dst)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
for name := range fields {
|
||||
if _, ok := allowed[name]; !ok {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return json.Unmarshal(body, dst) == nil
|
||||
}
|
||||
|
||||
func jsonFieldNames(dst any) (map[string]struct{}, bool) {
|
||||
t := reflect.TypeOf(dst)
|
||||
if t == nil || t.Kind() != reflect.Pointer {
|
||||
return nil, false
|
||||
}
|
||||
t = t.Elem()
|
||||
if t.Kind() != reflect.Struct {
|
||||
return nil, false
|
||||
}
|
||||
names := make(map[string]struct{}, t.NumField())
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
name, _, _ := strings.Cut(t.Field(i).Tag.Get("json"), ",")
|
||||
if name == "" || name == "-" {
|
||||
return nil, false
|
||||
}
|
||||
names[name] = struct{}{}
|
||||
}
|
||||
return names, true
|
||||
}
|
||||
|
||||
func validPassword(s string) bool {
|
||||
if !utf8.ValidString(s) {
|
||||
return false
|
||||
}
|
||||
n := utf8.RuneCountInString(s)
|
||||
return n >= 12 && n <= 128 && strings.TrimSpace(s) != ""
|
||||
}
|
||||
|
||||
func (a *API) pageQuery(w http.ResponseWriter, r *http.Request, scope string) (int, *store.Cursor, bool) {
|
||||
q := r.URL.Query()
|
||||
limit := 50
|
||||
if q.Has("limit") {
|
||||
raw := q.Get("limit")
|
||||
n, err := strconv.Atoi(raw)
|
||||
if err != nil || !limitRe.MatchString(raw) || n < 1 || n > 100 {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный limit", 0)
|
||||
return 0, nil, false
|
||||
}
|
||||
limit = n
|
||||
}
|
||||
if !q.Has("cursor") {
|
||||
return limit, nil, true
|
||||
}
|
||||
raw := q.Get("cursor")
|
||||
if raw == "" || len(raw) > 512 {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
|
||||
return 0, nil, false
|
||||
}
|
||||
payload, err := decodeCursor(raw)
|
||||
if err != nil || payload.Scope != scope || payload.ID == "" || payload.At == "" {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
|
||||
return 0, nil, false
|
||||
}
|
||||
at, err := time.Parse("2006-01-02T15:04:05.000000Z", payload.At)
|
||||
if err != nil {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
|
||||
return 0, nil, false
|
||||
}
|
||||
id, ok := canonicalUUID(payload.ID)
|
||||
if !ok {
|
||||
a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0)
|
||||
return 0, nil, false
|
||||
}
|
||||
return limit, &store.Cursor{ID: id, At: at}, true
|
||||
}
|
||||
|
||||
func asUser(u store.User) userJSON {
|
||||
return userJSON{
|
||||
ID: u.ID,
|
||||
Username: u.Username,
|
||||
DisplayName: u.DisplayName,
|
||||
CreatedAt: formatTime(u.CreatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func asChat(c store.Chat) chatJSON {
|
||||
ids := c.MemberIDs
|
||||
if ids == nil {
|
||||
ids = []string{}
|
||||
}
|
||||
return chatJSON{
|
||||
ID: c.ID,
|
||||
Title: c.Title,
|
||||
MemberIDs: ids,
|
||||
CreatedAt: formatTime(c.CreatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func asMessage(m store.Message) messageJSON {
|
||||
ids := m.AttachmentIDs
|
||||
if ids == nil {
|
||||
ids = []string{}
|
||||
}
|
||||
return messageJSON{
|
||||
ID: m.ID,
|
||||
ChatID: m.ChatID,
|
||||
SenderID: m.SenderID,
|
||||
Text: m.Text,
|
||||
CreatedAt: formatTime(m.CreatedAt),
|
||||
AttachmentIDs: ids,
|
||||
}
|
||||
}
|
||||
|
||||
func messageFingerprint(text string, ids []string) string {
|
||||
if len(ids) == 0 {
|
||||
return text + "\n"
|
||||
}
|
||||
return text + "\n" + strings.Join(ids, ",")
|
||||
}
|
||||
|
||||
func validMessageText(text string, attachments int) bool {
|
||||
if utf8.RuneCountInString(text) > 4000 {
|
||||
return false
|
||||
}
|
||||
if strings.TrimSpace(text) == "" {
|
||||
return text == "" && attachments > 0
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func formatTime(t time.Time) string {
|
||||
return t.UTC().Format("2006-01-02T15:04:05.000000Z")
|
||||
}
|
||||
|
||||
func canonicalUUID(s string) (string, bool) {
|
||||
if !uuidRe.MatchString(s) {
|
||||
return "", false
|
||||
}
|
||||
return strings.ToLower(s), true
|
||||
}
|
||||
|
||||
func validText(s string, min, max int) bool {
|
||||
if strings.TrimSpace(s) == "" {
|
||||
return false
|
||||
}
|
||||
n := utf8.RuneCountInString(s)
|
||||
return n >= min && n <= max
|
||||
}
|
||||
|
||||
func requestID(r *http.Request) string {
|
||||
incoming := strings.TrimSpace(r.Header.Get("X-Request-Id"))
|
||||
if requestIDRe.MatchString(incoming) {
|
||||
return incoming
|
||||
}
|
||||
var b [16]byte
|
||||
if _, err := rand.Read(b[:]); err != nil {
|
||||
return strconv.FormatInt(time.Now().UnixNano(), 36)
|
||||
}
|
||||
return hex.EncodeToString(b[:])
|
||||
}
|
||||
|
||||
func encodeCursor(p cursorPayload) string {
|
||||
raw, err := json.Marshal(p)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return base64.RawURLEncoding.EncodeToString(raw)
|
||||
}
|
||||
|
||||
func decodeCursor(s string) (cursorPayload, error) {
|
||||
b, err := base64.RawURLEncoding.DecodeString(s)
|
||||
if err != nil {
|
||||
b, err = base64.URLEncoding.DecodeString(s)
|
||||
if err != nil {
|
||||
return cursorPayload{}, err
|
||||
}
|
||||
}
|
||||
dec := json.NewDecoder(bytes.NewReader(b))
|
||||
dec.DisallowUnknownFields()
|
||||
var p cursorPayload
|
||||
if err := dec.Decode(&p); err != nil {
|
||||
return cursorPayload{}, err
|
||||
}
|
||||
var trailing json.RawMessage
|
||||
if err := dec.Decode(&trailing); err != io.EOF {
|
||||
if err == nil {
|
||||
err = io.ErrUnexpectedEOF
|
||||
}
|
||||
return cursorPayload{}, err
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"messenger/internal/blob"
|
||||
"messenger/internal/password"
|
||||
"messenger/internal/session"
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
type ctxKey struct{}
|
||||
|
||||
type API struct {
|
||||
store store.Repository
|
||||
sessions session.Store
|
||||
hasher password.Params
|
||||
dummyHash string
|
||||
sessionTTL time.Duration
|
||||
instanceID string
|
||||
log *slog.Logger
|
||||
shutting atomic.Bool
|
||||
blobs blob.Store
|
||||
maxUpload int64
|
||||
maxPixels int
|
||||
}
|
||||
|
||||
// New связывает HTTP с хранилищем и сессиями.
|
||||
// dummyHash нужен, чтобы несуществующий username тратил столько же KDF, сколько существующий.
|
||||
func New(st store.Repository, sessions session.Store, hasher password.Params, sessionTTL time.Duration, instanceID string, log *slog.Logger) *API {
|
||||
if log == nil {
|
||||
log = slog.Default()
|
||||
}
|
||||
if sessionTTL <= 0 {
|
||||
sessionTTL = time.Hour
|
||||
}
|
||||
if instanceID == "" {
|
||||
instanceID = "api"
|
||||
}
|
||||
dummy, err := hasher.Hash("dummy-password-not-a-login")
|
||||
if err != nil {
|
||||
// Параметры KDF проверяются на старте. Пустая строка заставит Verify сразу вернуть false.
|
||||
dummy = ""
|
||||
}
|
||||
return &API{
|
||||
store: st,
|
||||
sessions: sessions,
|
||||
hasher: hasher,
|
||||
dummyHash: dummy,
|
||||
sessionTTL: sessionTTL,
|
||||
instanceID: instanceID,
|
||||
log: log,
|
||||
}
|
||||
}
|
||||
|
||||
// EnableAttachments подключает приватный bucket и жёсткие лимиты загрузки.
|
||||
// maxUpload не может превысить 10 МиБ контракта.
|
||||
func (a *API) EnableAttachments(objects blob.Store, maxUpload int64, maxPixels int) {
|
||||
const contractMax = 10 * 1024 * 1024
|
||||
if maxUpload <= 0 || maxUpload > contractMax {
|
||||
maxUpload = contractMax
|
||||
}
|
||||
if maxPixels <= 0 || maxPixels > 40_000_000 {
|
||||
maxPixels = 40_000_000
|
||||
}
|
||||
a.blobs = objects
|
||||
a.maxUpload = maxUpload
|
||||
a.maxPixels = maxPixels
|
||||
}
|
||||
|
||||
// BeginShutdown переводит /health/ready в 503 и говорит новым бизнес-запросам
|
||||
// отказать до закрытия слушателя. Уже принятые обработчики дорабатывают.
|
||||
func (a *API) BeginShutdown() {
|
||||
a.shutting.Store(true)
|
||||
a.log.Info("shutdown started")
|
||||
}
|
||||
|
||||
// Точка входа
|
||||
func (a *API) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
sw := &statusWriter{ResponseWriter: w, status: http.StatusOK}
|
||||
start := time.Now()
|
||||
id := requestID(r)
|
||||
sw.Header().Set("X-Request-Id", id)
|
||||
sw.Header().Set("X-Instance-Id", a.instanceID)
|
||||
r = r.WithContext(context.WithValue(r.Context(), ctxKey{}, id))
|
||||
|
||||
defer func() {
|
||||
if p := recover(); p != nil {
|
||||
a.log.Error("panic", "request_id", id)
|
||||
if !sw.wrote {
|
||||
a.fail(sw, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
|
||||
}
|
||||
}
|
||||
a.log.Info("request",
|
||||
"request_id", id,
|
||||
"method", r.Method,
|
||||
"path", r.URL.Path,
|
||||
"status", sw.status,
|
||||
"duration_ms", time.Since(start).Milliseconds(),
|
||||
"bytes_in", r.ContentLength,
|
||||
)
|
||||
}()
|
||||
|
||||
switch {
|
||||
case r.Method == http.MethodGet && r.URL.Path == "/health/live":
|
||||
a.live(sw, r)
|
||||
return
|
||||
case r.Method == http.MethodGet && r.URL.Path == "/health/ready":
|
||||
a.ready(sw, r)
|
||||
return
|
||||
}
|
||||
|
||||
if a.shutting.Load() {
|
||||
a.fail(sw, r, http.StatusServiceUnavailable, "unavailable", "Сервер останавливается", 1)
|
||||
return
|
||||
}
|
||||
a.route(sw, r)
|
||||
}
|
||||
|
||||
func requestIDFrom(r *http.Request) string {
|
||||
id, _ := r.Context().Value(ctxKey{}).(string)
|
||||
if id == "" {
|
||||
return "unknown"
|
||||
}
|
||||
return id
|
||||
}
|
||||
@@ -0,0 +1,842 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"image"
|
||||
"image/png"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"messenger/internal/blob"
|
||||
"messenger/internal/password"
|
||||
"messenger/internal/session"
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
const testPassword = "correct-horse-1"
|
||||
|
||||
type labServer struct {
|
||||
URL string
|
||||
tokens map[string]string
|
||||
api *API
|
||||
store store.Repository
|
||||
sess session.Store
|
||||
}
|
||||
|
||||
func newServer(t *testing.T) *labServer {
|
||||
return newServerTTL(t, time.Hour)
|
||||
}
|
||||
|
||||
func newServerTTL(t *testing.T, ttl time.Duration) *labServer {
|
||||
t.Helper()
|
||||
st := store.New()
|
||||
sess := session.NewMemory()
|
||||
application := New(st, sess, password.Params{Time: 1, Memory: 8, Threads: 1}, ttl, "test-instance", slog.New(slog.NewJSONHandler(io.Discard, nil)))
|
||||
srv := httptest.NewServer(application)
|
||||
t.Cleanup(srv.Close)
|
||||
return &labServer{URL: srv.URL, tokens: map[string]string{}, api: application, store: st, sess: sess}
|
||||
}
|
||||
|
||||
func (e *labServer) bearer(user string) string {
|
||||
if user == "" {
|
||||
return ""
|
||||
}
|
||||
if tok, ok := e.tokens[user]; ok {
|
||||
return tok
|
||||
}
|
||||
return "unknown-session-token"
|
||||
}
|
||||
|
||||
var keySeq atomic.Uint64
|
||||
|
||||
func nextIdemKey() string {
|
||||
return "k" + strconv.FormatUint(keySeq.Add(1), 36)
|
||||
}
|
||||
|
||||
func do(t *testing.T, env *labServer, method, url, user string, body any, raw []byte, contentType string, extra ...map[string]string) (int, http.Header, []byte) {
|
||||
t.Helper()
|
||||
var rdr io.Reader
|
||||
if raw != nil {
|
||||
rdr = bytes.NewReader(raw)
|
||||
} else if body != nil {
|
||||
b, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rdr = bytes.NewReader(b)
|
||||
}
|
||||
req, err := http.NewRequest(method, url, rdr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if body != nil || raw != nil {
|
||||
if contentType == "" {
|
||||
contentType = "application/json"
|
||||
}
|
||||
req.Header.Set("Content-Type", contentType)
|
||||
}
|
||||
if tok := env.bearer(user); tok != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+tok)
|
||||
}
|
||||
if len(extra) > 0 {
|
||||
for k, v := range extra[0] {
|
||||
req.Header.Set(k, v)
|
||||
}
|
||||
}
|
||||
if method == http.MethodPost && strings.Contains(url, "/messages") && req.Header.Get("Idempotency-Key") == "" {
|
||||
req.Header.Set("Idempotency-Key", nextIdemKey())
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
data, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if resp.Header.Get("X-Request-Id") == "" {
|
||||
t.Fatalf("%s %s: missing X-Request-Id", method, url)
|
||||
}
|
||||
if resp.Header.Get("X-Instance-Id") != "test-instance" {
|
||||
t.Fatalf("%s %s: X-Instance-Id = %q", method, url, resp.Header.Get("X-Instance-Id"))
|
||||
}
|
||||
if resp.StatusCode >= 400 {
|
||||
var env errorEnvelope
|
||||
if err := json.Unmarshal(data, &env); err != nil {
|
||||
t.Fatalf("error json: %v body %s", err, data)
|
||||
}
|
||||
if env.Error.RequestID != resp.Header.Get("X-Request-Id") || env.Error.Code == "" || env.Error.Message == "" {
|
||||
t.Fatalf("bad error envelope: %+v", env)
|
||||
}
|
||||
}
|
||||
return resp.StatusCode, resp.Header, data
|
||||
}
|
||||
|
||||
func createUser(t *testing.T, env *labServer, username, display string) userJSON {
|
||||
t.Helper()
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", map[string]string{
|
||||
"username": username, "display_name": display, "password": testPassword,
|
||||
}, nil, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("create user %s: %d %s", username, status, body)
|
||||
}
|
||||
if bytes.Contains(body, []byte("password")) || bytes.Contains(body, []byte("argon2")) {
|
||||
t.Fatalf("user response leaked a secret: %s", body)
|
||||
}
|
||||
var u userJSON
|
||||
if err := json.Unmarshal(body, &u); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
req, err := http.NewRequest(http.MethodPost, env.URL+"/api/v1/auth/sessions", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
req.SetBasicAuth(username, testPassword)
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
raw, _ := io.ReadAll(resp.Body)
|
||||
if resp.StatusCode != http.StatusCreated {
|
||||
t.Fatalf("login %s: %d %s", username, resp.StatusCode, raw)
|
||||
}
|
||||
var sess struct {
|
||||
Token string `json:"token"`
|
||||
}
|
||||
if err := json.Unmarshal(raw, &sess); err != nil || len(sess.Token) < 32 {
|
||||
t.Fatalf("session: %s", raw)
|
||||
}
|
||||
env.tokens[u.ID] = sess.Token
|
||||
return u
|
||||
}
|
||||
|
||||
func createChat(t *testing.T, env *labServer, caller, title string, members ...string) chatJSON {
|
||||
t.Helper()
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats", caller, map[string]any{
|
||||
"title": title, "member_ids": members,
|
||||
}, nil, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("create chat: %d %s", status, body)
|
||||
}
|
||||
var c chatJSON
|
||||
if err := json.Unmarshal(body, &c); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
func TestInvalidJSONExtraFieldAndTypes(t *testing.T) {
|
||||
env := newServer(t)
|
||||
cases := [][]byte{
|
||||
[]byte(`{`),
|
||||
[]byte(`{"username":"abc","display_name":"Алиса","extra":1}`),
|
||||
[]byte(`{"username":1,"display_name":"Алиса"}`),
|
||||
[]byte(`null`),
|
||||
}
|
||||
for _, raw := range cases {
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", nil, raw, "application/json")
|
||||
if status != http.StatusBadRequest || !bytes.Contains(body, []byte(`"invalid_request"`)) {
|
||||
t.Fatalf("body %s: %d %s", raw, status, body)
|
||||
}
|
||||
}
|
||||
status, _, _ := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", nil, []byte(`{"username":"abc","display_name":"Алиса"}`), "text/plain")
|
||||
if status != http.StatusUnsupportedMediaType {
|
||||
t.Fatalf("content type: %d", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStrictJSONNamesUTF8AndCursorTail(t *testing.T) {
|
||||
env := newServer(t)
|
||||
bad := [][]byte{
|
||||
[]byte(`{"username":"bad_json","display_name":"Я"}]`),
|
||||
[]byte(`{"username":"bad_json","display_name":"Я"}}`),
|
||||
[]byte(`{"Username":"bad_case","display_name":"Я"}`),
|
||||
append([]byte(`{"username":"bad_utf","display_name":"`), 0xff, '"', '}'),
|
||||
}
|
||||
for _, raw := range bad {
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", nil, raw, "application/json")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("user body %q: %d %s", raw, status, body)
|
||||
}
|
||||
}
|
||||
|
||||
alice := createUser(t, env, "alice", "Алиса")
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats", alice.ID, nil, []byte(`{"Title":"чат","member_ids":["`+alice.ID+`"]}`), "application/json")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("Title: %d %s", status, body)
|
||||
}
|
||||
chat := createChat(t, env, alice.ID, "чат", alice.ID)
|
||||
|
||||
status, _, body = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, nil, []byte(`{"TEXT":"hi"}`), "application/json")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("TEXT: %d %s", status, body)
|
||||
}
|
||||
rawText := append([]byte(`{"text":"`), 0xff, '"', '}')
|
||||
status, _, body = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, nil, rawText, "application/json")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("message utf-8: %d %s", status, body)
|
||||
}
|
||||
|
||||
status, _, body = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "one"}, nil, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("seed: %d %s", status, body)
|
||||
}
|
||||
status, _, body = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "two"}, nil, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("seed2: %d %s", status, body)
|
||||
}
|
||||
status, _, body = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1", alice.ID, nil, nil, "")
|
||||
if status != http.StatusOK {
|
||||
t.Fatalf("page: %d %s", status, body)
|
||||
}
|
||||
var page messagePage
|
||||
if err := json.Unmarshal(body, &page); err != nil || page.NextCursor == nil {
|
||||
t.Fatalf("cursor: %v %s", err, body)
|
||||
}
|
||||
decoded, err := base64.RawURLEncoding.DecodeString(*page.NextCursor)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tampered := base64.RawURLEncoding.EncodeToString(append(decoded, []byte("garbage")...))
|
||||
status, _, body = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1&cursor="+url.QueryEscape(tampered), alice.ID, nil, nil, "")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("tampered cursor: %d %s", status, body)
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1&cursor="+url.QueryEscape(*page.NextCursor), alice.ID, nil, nil, "")
|
||||
if status != http.StatusOK {
|
||||
t.Fatalf("valid cursor: %d", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDuplicateUsername(t *testing.T) {
|
||||
env := newServer(t)
|
||||
createUser(t, env, "alice", "Алиса")
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", map[string]string{
|
||||
"username": "alice", "display_name": "Другая", "password": testPassword,
|
||||
}, nil, "")
|
||||
if status != http.StatusConflict || !bytes.Contains(body, []byte(`"conflict"`)) {
|
||||
t.Fatalf("duplicate: %d %s", status, body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmptyMessageForeignChatAndAuth(t *testing.T) {
|
||||
env := newServer(t)
|
||||
alice := createUser(t, env, "alice", "Алиса")
|
||||
bob := createUser(t, env, "bob", "Боб")
|
||||
eve := createUser(t, env, "eve", "Ева")
|
||||
chat := createChat(t, env, alice.ID, "Контрактный тест", alice.ID, bob.ID)
|
||||
|
||||
status, _, _ := do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", "", nil, nil, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("missing header: %d", status)
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", "11111111-1111-4111-8111-111111111111", nil, nil, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("unknown user: %d", status)
|
||||
}
|
||||
meStatus, _, meBody := do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", alice.ID, nil, nil, "")
|
||||
if meStatus != http.StatusOK || !bytes.Contains(meBody, []byte(alice.ID)) {
|
||||
t.Fatalf("me: %d %s", meStatus, meBody)
|
||||
}
|
||||
|
||||
status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID, eve.ID, nil, nil, "")
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("foreign chat: %d", status)
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", eve.ID, map[string]string{"text": "чужое"}, nil, "")
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("foreign post: %d", status)
|
||||
}
|
||||
for _, text := range []string{"", " ", "\n\t"} {
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": text}, nil, "")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("empty %q: %d %s", text, status, body)
|
||||
}
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "привет", "sender_id": eve.ID}, nil, "")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("sender_id must be rejected: %d", status)
|
||||
}
|
||||
|
||||
text := "Привет, мир 👋"
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": text}, nil, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("unicode: %d %s", status, body)
|
||||
}
|
||||
var msg messageJSON
|
||||
if err := json.Unmarshal(body, &msg); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if msg.Text != text || msg.SenderID != alice.ID || msg.ChatID != chat.ID {
|
||||
t.Fatalf("message mutated: %+v", msg)
|
||||
}
|
||||
if !strings.HasSuffix(msg.CreatedAt, "Z") {
|
||||
t.Fatalf("timestamp: %s", msg.CreatedAt)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPaginationSeveralPages(t *testing.T) {
|
||||
env := newServer(t)
|
||||
alice := createUser(t, env, "alice", "Алиса")
|
||||
bob := createUser(t, env, "bob", "Боб")
|
||||
chat := createChat(t, env, alice.ID, "страницы", alice.ID, bob.ID)
|
||||
other := createChat(t, env, alice.ID, "другой", alice.ID)
|
||||
const n = 25
|
||||
ids := make([]string, 0, n)
|
||||
for i := 0; i < n; i++ {
|
||||
sender := alice.ID
|
||||
if i%2 == 1 {
|
||||
sender = bob.ID
|
||||
}
|
||||
status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", sender, map[string]string{
|
||||
"text": "сообщение " + strings.Repeat("я", i%3) + string(rune('a'+i%26)),
|
||||
}, nil, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("post %d: %d %s", i, status, body)
|
||||
}
|
||||
var msg messageJSON
|
||||
if err := json.Unmarshal(body, &msg); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ids = append(ids, msg.ID)
|
||||
}
|
||||
var got []string
|
||||
cursor := ""
|
||||
pages := 0
|
||||
for {
|
||||
pages++
|
||||
if pages > 10 {
|
||||
t.Fatal("pagination did not finish")
|
||||
}
|
||||
url := env.URL + "/api/v1/chats/" + chat.ID + "/messages?limit=10"
|
||||
if cursor != "" {
|
||||
url += "&cursor=" + cursor
|
||||
}
|
||||
status, _, body := do(t, env, http.MethodGet, url, bob.ID, nil, nil, "")
|
||||
if status != http.StatusOK {
|
||||
t.Fatalf("page: %d %s", status, body)
|
||||
}
|
||||
var page messagePage
|
||||
if err := json.Unmarshal(body, &page); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(page.Items) == 0 || len(page.Items) > 10 {
|
||||
t.Fatalf("page size %d", len(page.Items))
|
||||
}
|
||||
for _, item := range page.Items {
|
||||
got = append(got, item.ID)
|
||||
}
|
||||
if page.NextCursor == nil {
|
||||
break
|
||||
}
|
||||
cursor = *page.NextCursor
|
||||
}
|
||||
if pages < 3 {
|
||||
t.Fatalf("expected several pages, got %d", pages)
|
||||
}
|
||||
if strings.Join(got, ",") != strings.Join(ids, ",") {
|
||||
t.Fatalf("order/duplication mismatch\nwant %v\ngot %v", ids, got)
|
||||
}
|
||||
status, _, _ := do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+other.ID+"/messages?limit=10&cursor="+cursor, alice.ID, nil, nil, "")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("foreign cursor: %d", status)
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=0", alice.ID, nil, nil, "")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("limit 0: %d", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestConcurrentHundredMessages(t *testing.T) {
|
||||
env := newServer(t)
|
||||
users := make([]userJSON, 10)
|
||||
ids := make([]string, 10)
|
||||
for i := 0; i < 10; i++ {
|
||||
users[i] = createUser(t, env, "u"+string(rune('a'+i))+"x", "Участник")
|
||||
ids[i] = users[i].ID
|
||||
}
|
||||
chat := createChat(t, env, ids[0], "гонка", ids...)
|
||||
var wg sync.WaitGroup
|
||||
errCh := make(chan error, 100)
|
||||
for i := 0; i < 10; i++ {
|
||||
wg.Add(1)
|
||||
go func(user string) {
|
||||
defer wg.Done()
|
||||
for j := 0; j < 10; j++ {
|
||||
req, err := http.NewRequest(http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", strings.NewReader(`{"text":"n"}`))
|
||||
if err != nil {
|
||||
errCh <- err
|
||||
return
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("Authorization", "Bearer "+env.tokens[user])
|
||||
req.Header.Set("Idempotency-Key", user+"-"+strconv.Itoa(j))
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
errCh <- err
|
||||
return
|
||||
}
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusCreated {
|
||||
errCh <- &statusErr{resp.StatusCode, body}
|
||||
}
|
||||
}
|
||||
}(ids[i])
|
||||
}
|
||||
wg.Wait()
|
||||
close(errCh)
|
||||
for err := range errCh {
|
||||
t.Fatal(err)
|
||||
}
|
||||
seen := map[string]struct{}{}
|
||||
cursor := ""
|
||||
for {
|
||||
url := env.URL + "/api/v1/chats/" + chat.ID + "/messages?limit=17"
|
||||
if cursor != "" {
|
||||
url += "&cursor=" + cursor
|
||||
}
|
||||
status, _, body := do(t, env, http.MethodGet, url, ids[3], nil, nil, "")
|
||||
if status != http.StatusOK {
|
||||
t.Fatalf("list: %d %s", status, body)
|
||||
}
|
||||
var page messagePage
|
||||
if err := json.Unmarshal(body, &page); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, item := range page.Items {
|
||||
if _, ok := seen[item.ID]; ok {
|
||||
t.Fatalf("duplicate %s", item.ID)
|
||||
}
|
||||
seen[item.ID] = struct{}{}
|
||||
}
|
||||
if page.NextCursor == nil {
|
||||
break
|
||||
}
|
||||
cursor = *page.NextCursor
|
||||
}
|
||||
if len(seen) != 100 {
|
||||
t.Fatalf("unique messages = %d, want 100", len(seen))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSessionWrongPasswordLogoutAndIgnoredUserHeader(t *testing.T) {
|
||||
env := newServer(t)
|
||||
alice := createUser(t, env, "alice", "Алиса")
|
||||
eve := createUser(t, env, "eve", "Ева")
|
||||
|
||||
req, err := http.NewRequest(http.MethodPost, env.URL+"/api/v1/auth/sessions", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
req.SetBasicAuth("alice", "wrong-password-1")
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusUnauthorized || !strings.HasPrefix(resp.Header.Get("WWW-Authenticate"), "Basic ") {
|
||||
t.Fatalf("wrong password: %d %s %q", resp.StatusCode, body, resp.Header.Get("WWW-Authenticate"))
|
||||
}
|
||||
|
||||
status, hdr, _ := do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", "", nil, nil, "")
|
||||
if status != http.StatusUnauthorized || !strings.HasPrefix(hdr.Get("WWW-Authenticate"), "Bearer ") {
|
||||
t.Fatalf("missing bearer: %d %q", status, hdr.Get("WWW-Authenticate"))
|
||||
}
|
||||
bare, err := http.NewRequest(http.MethodGet, env.URL+"/api/v1/users/me", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
bare.Header.Set("X-User-Id", alice.ID)
|
||||
resp, err = http.DefaultClient.Do(bare)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusUnauthorized {
|
||||
t.Fatalf("X-User-Id alone: %d", resp.StatusCode)
|
||||
}
|
||||
over, err := http.NewRequest(http.MethodGet, env.URL+"/api/v1/users/me", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
over.Header.Set("Authorization", "Bearer "+env.tokens[alice.ID])
|
||||
over.Header.Set("X-User-Id", eve.ID)
|
||||
resp, err = http.DefaultClient.Do(over)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
raw, _ := io.ReadAll(resp.Body)
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK || !bytes.Contains(raw, []byte(alice.ID)) || bytes.Contains(raw, []byte(eve.ID)) {
|
||||
t.Fatalf("X-User-Id overrode bearer: %d %s", resp.StatusCode, raw)
|
||||
}
|
||||
|
||||
basic, err := http.NewRequest(http.MethodGet, env.URL+"/api/v1/users/me", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
basic.SetBasicAuth("alice", testPassword)
|
||||
resp, err = http.DefaultClient.Do(basic)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusUnauthorized || !strings.HasPrefix(resp.Header.Get("WWW-Authenticate"), "Bearer ") {
|
||||
t.Fatalf("basic on business endpoint: %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
status, _, body = do(t, env, http.MethodDelete, env.URL+"/api/v1/auth/sessions/current", alice.ID, nil, nil, "")
|
||||
if status != http.StatusNoContent || len(body) != 0 {
|
||||
t.Fatalf("logout: %d %q", status, body)
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", alice.ID, nil, nil, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("revoked token: %d", status)
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodDelete, env.URL+"/api/v1/auth/sessions/current", alice.ID, nil, nil, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("second logout: %d", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSessionExpires(t *testing.T) {
|
||||
env := newServerTTL(t, 2*time.Second)
|
||||
alice := createUser(t, env, "alice", "Алиса")
|
||||
time.Sleep(2100 * time.Millisecond)
|
||||
status, _, _ := do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", alice.ID, nil, nil, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("expired session: %d", status)
|
||||
}
|
||||
}
|
||||
|
||||
type downSessions struct{ session.Store }
|
||||
|
||||
func (downSessions) Lookup(context.Context, string) (string, time.Time, error) {
|
||||
return "", time.Time{}, session.ErrUnavailable
|
||||
}
|
||||
func (downSessions) Ping(context.Context) error { return session.ErrUnavailable }
|
||||
|
||||
type downStore struct{ store.Repository }
|
||||
|
||||
func (downStore) Ping(context.Context) error { return store.ErrUnavailable }
|
||||
func (downStore) User(context.Context, string) (store.User, error) {
|
||||
return store.User{}, store.ErrUnavailable
|
||||
}
|
||||
|
||||
func TestDependencyDownDoesNotTrustAnonymous(t *testing.T) {
|
||||
env := newServer(t)
|
||||
alice := createUser(t, env, "alice", "Алиса")
|
||||
broken := New(downStore{env.store}, downSessions{env.sess}, password.Params{Time: 1, Memory: 8, Threads: 1}, time.Hour, "test-instance", slog.New(slog.NewJSONHandler(io.Discard, nil)))
|
||||
srv := httptest.NewServer(broken)
|
||||
defer srv.Close()
|
||||
|
||||
live, err := http.Get(srv.URL + "/health/live")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
live.Body.Close()
|
||||
if live.StatusCode != http.StatusOK {
|
||||
t.Fatalf("live: %d", live.StatusCode)
|
||||
}
|
||||
ready, err := http.Get(srv.URL + "/health/ready")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
readyBody, _ := io.ReadAll(ready.Body)
|
||||
ready.Body.Close()
|
||||
if ready.StatusCode != http.StatusServiceUnavailable || !bytes.Contains(readyBody, []byte(`"unavailable"`)) {
|
||||
t.Fatalf("ready: %d %s", ready.StatusCode, readyBody)
|
||||
}
|
||||
|
||||
anon, err := http.Get(srv.URL + "/api/v1/users/me")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
anon.Body.Close()
|
||||
if anon.StatusCode != http.StatusUnauthorized {
|
||||
t.Fatalf("anonymous while down: %d", anon.StatusCode)
|
||||
}
|
||||
authed, err := http.NewRequest(http.MethodGet, srv.URL+"/api/v1/users/me", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
authed.Header.Set("Authorization", "Bearer "+env.tokens[alice.ID])
|
||||
resp, err := http.DefaultClient.Do(authed)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusServiceUnavailable {
|
||||
t.Fatalf("bearer while session store is down: %d", resp.StatusCode)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIdempotencyReplayConflictAndRace(t *testing.T) {
|
||||
env := newServer(t)
|
||||
alice := createUser(t, env, "alice", "Алиса")
|
||||
bob := createUser(t, env, "bob", "Боб")
|
||||
chat := createChat(t, env, alice.ID, "ключ", alice.ID, bob.ID)
|
||||
path := env.URL + "/api/v1/chats/" + chat.ID + "/messages"
|
||||
key := "same-key-1"
|
||||
|
||||
status, _, body := do(t, env, http.MethodPost, path, alice.ID, map[string]string{"text": "одно"}, nil, "", map[string]string{"Idempotency-Key": key})
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("first: %d %s", status, body)
|
||||
}
|
||||
var first messageJSON
|
||||
if err := json.Unmarshal(body, &first); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
status, _, body = do(t, env, http.MethodPost, path, alice.ID, nil, []byte(`{"text":"одно"}`), "application/json", map[string]string{"Idempotency-Key": key})
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("replay: %d %s", status, body)
|
||||
}
|
||||
var replay messageJSON
|
||||
if err := json.Unmarshal(body, &replay); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !reflect.DeepEqual(replay, first) {
|
||||
t.Fatalf("replay changed message: %+v vs %+v", replay, first)
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodPost, path, alice.ID, map[string]string{"text": "другое"}, nil, "", map[string]string{"Idempotency-Key": key})
|
||||
if status != http.StatusConflict {
|
||||
t.Fatalf("mismatch: %d", status)
|
||||
}
|
||||
req, err := http.NewRequest(http.MethodPost, path, strings.NewReader(`{"text":"без ключа"}`))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("Authorization", "Bearer "+env.tokens[alice.ID])
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusBadRequest {
|
||||
t.Fatalf("missing key: %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
status, _, body = do(t, env, http.MethodPost, path, bob.ID, map[string]string{"text": "одно"}, nil, "", map[string]string{"Idempotency-Key": key})
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("other user: %d %s", status, body)
|
||||
}
|
||||
var other messageJSON
|
||||
if err := json.Unmarshal(body, &other); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if other.ID == first.ID {
|
||||
t.Fatal("same key for another user reused the message")
|
||||
}
|
||||
|
||||
raceKey := "race-key"
|
||||
var wg sync.WaitGroup
|
||||
ids := make(chan string, 16)
|
||||
errs := make(chan error, 16)
|
||||
for i := 0; i < 16; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
req, err := http.NewRequest(http.MethodPost, path, strings.NewReader(`{"text":"гонка"}`))
|
||||
if err != nil {
|
||||
errs <- err
|
||||
return
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("Authorization", "Bearer "+env.tokens[alice.ID])
|
||||
req.Header.Set("Idempotency-Key", raceKey)
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
errs <- err
|
||||
return
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
raw, _ := io.ReadAll(resp.Body)
|
||||
if resp.StatusCode != http.StatusCreated {
|
||||
errs <- &statusErr{resp.StatusCode, raw}
|
||||
return
|
||||
}
|
||||
var msg messageJSON
|
||||
if err := json.Unmarshal(raw, &msg); err != nil {
|
||||
errs <- err
|
||||
return
|
||||
}
|
||||
ids <- msg.ID
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
close(ids)
|
||||
close(errs)
|
||||
for err := range errs {
|
||||
t.Fatal(err)
|
||||
}
|
||||
seen := map[string]struct{}{}
|
||||
for id := range ids {
|
||||
seen[id] = struct{}{}
|
||||
}
|
||||
if len(seen) != 1 {
|
||||
t.Fatalf("concurrent same key created %d messages", len(seen))
|
||||
}
|
||||
}
|
||||
|
||||
func pngBytes(t *testing.T, w, h int) []byte {
|
||||
t.Helper()
|
||||
img := image.NewNRGBA(image.Rect(0, 0, w, h))
|
||||
var buf bytes.Buffer
|
||||
if err := png.Encode(&buf, img); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return buf.Bytes()
|
||||
}
|
||||
|
||||
func TestAttachmentRoundTripAndRejections(t *testing.T) {
|
||||
env := newServer(t)
|
||||
env.api.EnableAttachments(blob.NewMemory(), 10*1024*1024, 40_000_000)
|
||||
alice := createUser(t, env, "alice", "Алиса")
|
||||
bob := createUser(t, env, "bob", "Боб")
|
||||
eve := createUser(t, env, "eve", "Ева")
|
||||
chat := createChat(t, env, alice.ID, "файлы", alice.ID, bob.ID)
|
||||
other := createChat(t, env, alice.ID, "другой", alice.ID)
|
||||
body := pngBytes(t, 4, 3)
|
||||
|
||||
status, _, raw := do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/attachments?filename=a/b.png", alice.ID, nil, body, "image/png")
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("slash filename: %d %s", status, raw)
|
||||
}
|
||||
status, _, raw = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/attachments?filename=note.png", alice.ID, nil, []byte("hello"), "image/png")
|
||||
if status != http.StatusUnsupportedMediaType {
|
||||
t.Fatalf("text as png: %d %s", status, raw)
|
||||
}
|
||||
jpegHeader := []byte{0xff, 0xd8, 0xff, 0xd9}
|
||||
status, _, raw = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/attachments?filename=x.png", alice.ID, nil, jpegHeader, "image/png")
|
||||
if status != http.StatusUnsupportedMediaType {
|
||||
t.Fatalf("mime swap: %d %s", status, raw)
|
||||
}
|
||||
|
||||
status, _, raw = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/attachments?filename=pic.png", alice.ID, nil, body, "image/png")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("upload: %d %s", status, raw)
|
||||
}
|
||||
var att attachmentJSON
|
||||
if err := json.Unmarshal(raw, &att); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if att.Status != "ready" || att.ErrorCode != nil || att.ChatID != chat.ID || att.OwnerID != alice.ID || len(att.Variants) != 0 {
|
||||
t.Fatalf("metadata: %+v", att)
|
||||
}
|
||||
if bytes.Contains(raw, []byte("object_key")) || bytes.Contains(raw, []byte("\"o/")) {
|
||||
t.Fatalf("key leaked: %s", raw)
|
||||
}
|
||||
status, hdr, got := do(t, env, http.MethodGet, env.URL+"/api/v1/attachments/"+att.ID+"/content", bob.ID, nil, nil, "")
|
||||
if status != http.StatusOK || hdr.Get("Content-Type") != "image/png" || !bytes.Equal(got, body) {
|
||||
t.Fatalf("download: %d %s %d", status, hdr.Get("Content-Type"), len(got))
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/attachments/"+att.ID, eve.ID, nil, nil, "")
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("outsider meta: %d", status)
|
||||
}
|
||||
status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/attachments/"+att.ID+"/content", eve.ID, nil, nil, "")
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("outsider bytes: %d", status)
|
||||
}
|
||||
|
||||
status, _, raw = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+other.ID+"/attachments?filename=other.png", alice.ID, nil, body, "image/png")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("other upload: %d %s", status, raw)
|
||||
}
|
||||
var foreign attachmentJSON
|
||||
if err := json.Unmarshal(raw, &foreign); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
status, _, raw = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]any{
|
||||
"text": "", "attachment_ids": []string{foreign.ID},
|
||||
}, nil, "")
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("foreign attachment: %d %s", status, raw)
|
||||
}
|
||||
status, _, raw = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]any{
|
||||
"text": "", "attachment_ids": []string{att.ID},
|
||||
}, nil, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("attach: %d %s", status, raw)
|
||||
}
|
||||
var msg messageJSON
|
||||
if err := json.Unmarshal(raw, &msg); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(msg.AttachmentIDs) != 1 || msg.AttachmentIDs[0] != att.ID || msg.Text != "" {
|
||||
t.Fatalf("message: %+v", msg)
|
||||
}
|
||||
|
||||
env.api.EnableAttachments(blob.NewMemory(), 8, 40_000_000)
|
||||
status, _, raw = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/attachments?filename=big.png", alice.ID, nil, body, "image/png")
|
||||
if status != http.StatusRequestEntityTooLarge {
|
||||
t.Fatalf("small cap: %d %s", status, raw)
|
||||
}
|
||||
}
|
||||
|
||||
type statusErr struct {
|
||||
code int
|
||||
body []byte
|
||||
}
|
||||
|
||||
func (e *statusErr) Error() string {
|
||||
return http.StatusText(e.code) + " " + string(e.body)
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
// Хранилище байтов вложения. Реализация — приватный S3-совместимый bucket.
|
||||
// Ключ задаёт вызывающий код; имя файла пользователя сюда не попадает.
|
||||
package blob
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrNotFound = errors.New("blob not found")
|
||||
ErrUnavailable = errors.New("blob unavailable")
|
||||
)
|
||||
|
||||
// Object — запись листинга. LastModified нужен сверке, чтобы не удалять свежий объект.
|
||||
type Object struct {
|
||||
Key string
|
||||
Size int64
|
||||
Modified time.Time
|
||||
}
|
||||
|
||||
// Store — операции, которые нужны загрузке, скачиванию и сверке.
|
||||
type Store interface {
|
||||
Ping(ctx context.Context) error
|
||||
Put(ctx context.Context, key, contentType string, body []byte) error
|
||||
Get(ctx context.Context, key string) (io.ReadCloser, error)
|
||||
Delete(ctx context.Context, key string) error
|
||||
// List обходит bucket одним листингом. pages — сколько страниц S3 прочитано.
|
||||
List(ctx context.Context) (objects []Object, pages int, err error)
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
package blob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"io"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type memObj struct {
|
||||
body []byte
|
||||
modified time.Time
|
||||
}
|
||||
|
||||
// Memory - двойник bucket для тестов без MinIO.
|
||||
type Memory struct {
|
||||
mu sync.Mutex
|
||||
m map[string]memObj
|
||||
}
|
||||
|
||||
func NewMemory() *Memory {
|
||||
return &Memory{m: map[string]memObj{}}
|
||||
}
|
||||
|
||||
func (m *Memory) Ping(ctx context.Context) error {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) Put(ctx context.Context, key, _ string, body []byte) error {
|
||||
return m.PutAt(ctx, key, body, time.Now().UTC())
|
||||
}
|
||||
|
||||
// PutAt записывает объект с заданным временем.
|
||||
func (m *Memory) PutAt(ctx context.Context, key string, body []byte, modified time.Time) error {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.m[key] = memObj{body: append([]byte(nil), body...), modified: modified.UTC()}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return nil, ErrUnavailable
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
obj, ok := m.m[key]
|
||||
if !ok {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return io.NopCloser(bytes.NewReader(obj.body)), nil
|
||||
}
|
||||
|
||||
func (m *Memory) Delete(ctx context.Context, key string) error {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
delete(m.m, key)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) List(ctx context.Context) ([]Object, int, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return nil, 0, ErrUnavailable
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
out := make([]Object, 0, len(m.m))
|
||||
for key, obj := range m.m {
|
||||
out = append(out, Object{Key: key, Size: int64(len(obj.body)), Modified: obj.modified})
|
||||
}
|
||||
pages := 1
|
||||
if len(out) == 0 {
|
||||
pages = 1
|
||||
}
|
||||
return out, pages, nil
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
package blob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"net/url"
|
||||
"strings"
|
||||
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/credentials"
|
||||
)
|
||||
|
||||
// S3 - path-style клиент одного bucket. Учётные данные - отдельный пользователь.
|
||||
type S3 struct {
|
||||
client *minio.Client
|
||||
bucket string
|
||||
}
|
||||
|
||||
func Open(endpoint, region, bucket, accessKey, secretKey string) (*S3, error) {
|
||||
u, err := url.Parse(endpoint)
|
||||
if err != nil || u.Host == "" || bucket == "" || accessKey == "" || secretKey == "" {
|
||||
return nil, errors.New("s3 config")
|
||||
}
|
||||
secure := u.Scheme == "https"
|
||||
client, err := minio.New(u.Host, &minio.Options{
|
||||
Creds: credentials.NewStaticV4(accessKey, secretKey, ""),
|
||||
Secure: secure,
|
||||
Region: region,
|
||||
BucketLookup: minio.BucketLookupPath,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &S3{client: client, bucket: bucket}, nil
|
||||
}
|
||||
|
||||
func (s *S3) Ping(ctx context.Context) error {
|
||||
ok, err := s.client.BucketExists(ctx, s.bucket)
|
||||
if err != nil || !ok {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *S3) Put(ctx context.Context, key, contentType string, body []byte) error {
|
||||
_, err := s.client.PutObject(ctx, s.bucket, key, bytes.NewReader(body), int64(len(body)), minio.PutObjectOptions{
|
||||
ContentType: contentType,
|
||||
})
|
||||
if err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *S3) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
_, err := s.client.StatObject(ctx, s.bucket, key, minio.StatObjectOptions{})
|
||||
if err != nil {
|
||||
if isMissing(err) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return nil, ErrUnavailable
|
||||
}
|
||||
obj, err := s.client.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{})
|
||||
if err != nil {
|
||||
return nil, ErrUnavailable
|
||||
}
|
||||
return obj, nil
|
||||
}
|
||||
|
||||
func (s *S3) Delete(ctx context.Context, key string) error {
|
||||
err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{})
|
||||
if err != nil && !isMissing(err) {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *S3) List(ctx context.Context) ([]Object, int, error) {
|
||||
ch := s.client.ListObjects(ctx, s.bucket, minio.ListObjectsOptions{Recursive: true})
|
||||
out := make([]Object, 0)
|
||||
for obj := range ch {
|
||||
if obj.Err != nil {
|
||||
return nil, 0, ErrUnavailable
|
||||
}
|
||||
out = append(out, Object{Key: obj.Key, Size: obj.Size, Modified: obj.LastModified.UTC()})
|
||||
}
|
||||
pages := 1
|
||||
if n := len(out); n > 0 {
|
||||
pages = (n + 999) / 1000
|
||||
}
|
||||
return out, pages, nil
|
||||
}
|
||||
|
||||
func isMissing(err error) bool {
|
||||
resp := minio.ToErrorResponse(err)
|
||||
switch resp.Code {
|
||||
case "NoSuchKey", "NoSuchBucket", "NotFound":
|
||||
return true
|
||||
default:
|
||||
return strings.Contains(resp.Code, "NoSuch")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
// Одноразовый и повторно безопасный bootstrap bucket.
|
||||
// Root нужен только здесь. Процесс API ходит отдельным ключом.
|
||||
package bootstrap
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/minio/madmin-go/v3"
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/credentials"
|
||||
)
|
||||
|
||||
const policyName = "messenger-app"
|
||||
|
||||
// Bucket создаёт приватный bucket, политику и пользователя API, если их ещё нет.
|
||||
func Bucket(ctx context.Context, endpoint, region, bucket, rootKey, rootSecret, appKey, appSecret string) error {
|
||||
u, err := url.Parse(endpoint)
|
||||
if err != nil || u.Host == "" || bucket == "" || rootKey == "" || rootSecret == "" || appKey == "" || appSecret == "" {
|
||||
return fmt.Errorf("s3 bootstrap config")
|
||||
}
|
||||
if region == "" {
|
||||
region = "us-east-1"
|
||||
}
|
||||
secure := u.Scheme == "https"
|
||||
root, err := minio.New(u.Host, &minio.Options{
|
||||
Creds: credentials.NewStaticV4(rootKey, rootSecret, ""),
|
||||
Secure: secure,
|
||||
Region: region,
|
||||
BucketLookup: minio.BucketLookupPath,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var last error
|
||||
for attempt := 0; attempt < 30; attempt++ {
|
||||
exists, err := root.BucketExists(ctx, bucket)
|
||||
if err == nil {
|
||||
if !exists {
|
||||
if err := root.MakeBucket(ctx, bucket, minio.MakeBucketOptions{Region: region}); err != nil {
|
||||
exists, again := root.BucketExists(ctx, bucket)
|
||||
if again != nil || !exists {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
last = nil
|
||||
break
|
||||
}
|
||||
last = err
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
case <-time.After(time.Second):
|
||||
}
|
||||
}
|
||||
if last != nil {
|
||||
return last
|
||||
}
|
||||
|
||||
adm, err := madmin.New(u.Host, rootKey, rootSecret, secure)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := adm.InfoCannedPolicy(ctx, policyName); err != nil {
|
||||
if err := adm.AddCannedPolicy(ctx, policyName, policyJSON(bucket)); err != nil {
|
||||
return fmt.Errorf("add policy: %w", err)
|
||||
}
|
||||
}
|
||||
if err := adm.AddUser(ctx, appKey, appSecret); err != nil {
|
||||
return fmt.Errorf("add user: %w", err)
|
||||
}
|
||||
if _, err := adm.AttachPolicy(ctx, madmin.PolicyAssociationReq{
|
||||
Policies: []string{policyName},
|
||||
User: appKey,
|
||||
}); err != nil {
|
||||
info, infoErr := adm.GetUserInfo(ctx, appKey)
|
||||
if infoErr != nil || !strings.Contains(info.PolicyName, policyName) {
|
||||
return fmt.Errorf("attach policy: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
app, err := minio.New(u.Host, &minio.Options{
|
||||
Creds: credentials.NewStaticV4(appKey, appSecret, ""),
|
||||
Secure: secure,
|
||||
Region: region,
|
||||
BucketLookup: minio.BucketLookupPath,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ok, err := app.BucketExists(ctx, bucket)
|
||||
if err != nil || !ok {
|
||||
return fmt.Errorf("app user cannot see bucket")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func policyJSON(bucket string) []byte {
|
||||
return []byte(`{
|
||||
"Version": "2012-10-17",
|
||||
"Statement": [
|
||||
{
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:GetBucketLocation", "s3:ListBucket"],
|
||||
"Resource": ["arn:aws:s3:::` + bucket + `"]
|
||||
},
|
||||
{
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
|
||||
"Resource": ["arn:aws:s3:::` + bucket + `/*"]
|
||||
}
|
||||
]
|
||||
}`)
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"os"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Config — параметры процесса. Секреты приходят из окружения, не из образа.
|
||||
type Config struct {
|
||||
Host string
|
||||
Port string
|
||||
Env string
|
||||
ShutdownTimeout time.Duration
|
||||
DatabaseURL string
|
||||
RedisURL string
|
||||
SessionTTL time.Duration
|
||||
DBMaxConns int32
|
||||
Argon2Time uint32
|
||||
Argon2Memory uint32
|
||||
Argon2Threads uint8
|
||||
InstanceID string
|
||||
IdempotencyTTL time.Duration
|
||||
S3Endpoint string
|
||||
S3Region string
|
||||
S3Bucket string
|
||||
S3AccessKey string
|
||||
S3SecretKey string
|
||||
MaxUploadBytes int64
|
||||
MaxImagePixels int
|
||||
ReconcileGrace time.Duration
|
||||
}
|
||||
|
||||
// Addr — адрес прослушивания. В контейнере это 0.0.0.0:8080,
|
||||
// иначе published port Docker не попадёт в процесс.
|
||||
func (c Config) Addr() string {
|
||||
return net.JoinHostPort(c.Host, c.Port)
|
||||
}
|
||||
|
||||
// Load завершает запуск ошибкой, если значение вне допустимого диапазона.
|
||||
func Load() (Config, error) {
|
||||
var c Config
|
||||
c.Host = getenv("APP_HOST", "0.0.0.0")
|
||||
c.Port = getenv("APP_PORT", "8080")
|
||||
c.Env = getenv("APP_ENV", "lab")
|
||||
if c.Host == "" {
|
||||
return Config{}, fmt.Errorf("APP_HOST is empty")
|
||||
}
|
||||
port, err := strconv.Atoi(c.Port)
|
||||
if err != nil || port < 1 || port > 65535 {
|
||||
return Config{}, fmt.Errorf("APP_PORT must be 1..65535")
|
||||
}
|
||||
|
||||
sec, err := nonNeg("SHUTDOWN_TIMEOUT_SECONDS", 8)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
if sec < 1 || sec > 10 {
|
||||
return Config{}, fmt.Errorf("SHUTDOWN_TIMEOUT_SECONDS must be 1..10")
|
||||
}
|
||||
c.ShutdownTimeout = time.Duration(sec) * time.Second
|
||||
|
||||
c.DatabaseURL = getenv("DATABASE_URL", "")
|
||||
c.RedisURL = getenv("REDIS_URL", "")
|
||||
if c.DatabaseURL == "" || c.RedisURL == "" {
|
||||
return Config{}, fmt.Errorf("DATABASE_URL and REDIS_URL are required")
|
||||
}
|
||||
ttl, err := nonNeg("SESSION_TTL_SECONDS", 3600)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
if ttl < 1 || ttl > 7*24*3600 {
|
||||
return Config{}, fmt.Errorf("SESSION_TTL_SECONDS must be 1..604800")
|
||||
}
|
||||
c.SessionTTL = time.Duration(ttl) * time.Second
|
||||
|
||||
maxConns, err := nonNeg("DB_MAX_CONNS", 10)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
if maxConns < 1 || maxConns > 50 {
|
||||
return Config{}, fmt.Errorf("DB_MAX_CONNS must be 1..50")
|
||||
}
|
||||
c.DBMaxConns = int32(maxConns)
|
||||
|
||||
argonTime, err := nonNeg("ARGON2_TIME", 2)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
argonMemory, err := nonNeg("ARGON2_MEMORY_KIB", 19456)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
argonThreads, err := nonNeg("ARGON2_THREADS", 1)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
if argonTime < 1 || argonTime > 10 || argonMemory < 8 || argonMemory > 1<<20 || argonThreads < 1 || argonThreads > 8 {
|
||||
return Config{}, fmt.Errorf("argon2 params are out of range")
|
||||
}
|
||||
c.Argon2Time = uint32(argonTime)
|
||||
c.Argon2Memory = uint32(argonMemory)
|
||||
c.Argon2Threads = uint8(argonThreads)
|
||||
|
||||
c.InstanceID = getenv("INSTANCE_ID", "")
|
||||
idemTTL, err := nonNeg("IDEMPOTENCY_TTL_SECONDS", 86400)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
if idemTTL < 86400 || idemTTL > 7*24*3600 {
|
||||
return Config{}, fmt.Errorf("IDEMPOTENCY_TTL_SECONDS must be 86400..604800")
|
||||
}
|
||||
c.IdempotencyTTL = time.Duration(idemTTL) * time.Second
|
||||
|
||||
c.S3Endpoint = getenv("S3_ENDPOINT", "")
|
||||
c.S3Region = getenv("S3_REGION", "us-east-1")
|
||||
c.S3Bucket = getenv("S3_BUCKET", "")
|
||||
c.S3AccessKey = getenv("S3_ACCESS_KEY", "")
|
||||
c.S3SecretKey = getenv("S3_SECRET_KEY", "")
|
||||
if c.S3Endpoint == "" || c.S3Bucket == "" || c.S3AccessKey == "" || c.S3SecretKey == "" {
|
||||
return Config{}, fmt.Errorf("S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY and S3_SECRET_KEY are required")
|
||||
}
|
||||
upload, err := nonNeg("MAX_UPLOAD_BYTES", 10*1024*1024)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
if upload < 1 || upload > 10*1024*1024 {
|
||||
return Config{}, fmt.Errorf("MAX_UPLOAD_BYTES must be 1..10485760")
|
||||
}
|
||||
c.MaxUploadBytes = int64(upload)
|
||||
pixels, err := nonNeg("MAX_IMAGE_PIXELS", 40_000_000)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
if pixels < 1 || pixels > 40_000_000 {
|
||||
return Config{}, fmt.Errorf("MAX_IMAGE_PIXELS must be 1..40000000")
|
||||
}
|
||||
c.MaxImagePixels = pixels
|
||||
grace, err := nonNeg("RECONCILE_GRACE_SECONDS", 900)
|
||||
if err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
if grace > 24*3600 {
|
||||
return Config{}, fmt.Errorf("RECONCILE_GRACE_SECONDS must be 0..86400")
|
||||
}
|
||||
c.ReconcileGrace = time.Duration(grace) * time.Second
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func getenv(key, def string) string {
|
||||
if v, ok := os.LookupEnv(key); ok && v != "" {
|
||||
return v
|
||||
}
|
||||
return def
|
||||
}
|
||||
|
||||
func nonNeg(key string, def int) (int, error) {
|
||||
v, ok := os.LookupEnv(key)
|
||||
if !ok || v == "" {
|
||||
return def, nil
|
||||
}
|
||||
n, err := strconv.Atoi(v)
|
||||
if err != nil || n < 0 {
|
||||
return 0, fmt.Errorf("%s must be a non-negative integer", key)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
// Проверка PNG/JPEG без распаковки всего растра в память.
|
||||
// Размеры читаются из заголовка. Полный Decode выполняется только для небольших
|
||||
// картинок, чтобы поймать битый поток.
|
||||
package imagecheck
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"hash/crc32"
|
||||
"image"
|
||||
_ "image/jpeg"
|
||||
_ "image/png"
|
||||
)
|
||||
|
||||
const decodePixelLimit = 1_000_000
|
||||
|
||||
var (
|
||||
ErrFormat = errors.New("image format")
|
||||
ErrPixels = errors.New("image pixels")
|
||||
)
|
||||
|
||||
var pngSig = []byte{0x89, 'P', 'N', 'G', '\r', '\n', 0x1a, '\n'}
|
||||
|
||||
// Inspect сверяет заявленный MIME с байтами, проверяет структуру и лимит пикселей.
|
||||
// declared - ровно image/png или image/jpeg, без параметров.
|
||||
func Inspect(declared string, data []byte, maxPixels int) (width, height int, err error) {
|
||||
if maxPixels < 1 {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
detected := Detect(data)
|
||||
if detected == "" || detected != declared {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
switch detected {
|
||||
case "image/png":
|
||||
width, height, err = parsePNG(data)
|
||||
case "image/jpeg":
|
||||
width, height, err = parseJPEG(data)
|
||||
default:
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
if err != nil {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
if uint64(width)*uint64(height) > uint64(maxPixels) {
|
||||
return 0, 0, ErrPixels
|
||||
}
|
||||
// Маленький файл декодируем целиком: битый IDAT/скан не должен стать ready.
|
||||
// Выше порога остаётся проверка заголовка и CRC/маркеров, без буфера width*height*4.
|
||||
if uint64(width)*uint64(height) <= decodePixelLimit {
|
||||
if _, _, decErr := image.Decode(bytes.NewReader(data)); decErr != nil {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
}
|
||||
return width, height, nil
|
||||
}
|
||||
|
||||
// Detect смотрит только на сигнатуру, не на заголовок Content-Type.
|
||||
func Detect(data []byte) string {
|
||||
if len(data) >= len(pngSig) && bytes.Equal(data[:len(pngSig)], pngSig) {
|
||||
return "image/png"
|
||||
}
|
||||
if len(data) >= 3 && data[0] == 0xff && data[1] == 0xd8 && data[2] == 0xff {
|
||||
return "image/jpeg"
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func parsePNG(data []byte) (int, int, error) {
|
||||
if len(data) < len(pngSig) || !bytes.Equal(data[:len(pngSig)], pngSig) {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
i := len(pngSig)
|
||||
first := true
|
||||
var width, height int
|
||||
for i < len(data) {
|
||||
if i+12 > len(data) {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
n64 := uint64(binary.BigEndian.Uint32(data[i : i+4]))
|
||||
if n64 > uint64(len(data)-i-12) {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
n := int(n64)
|
||||
chunk := data[i+4 : i+8+n]
|
||||
got := binary.BigEndian.Uint32(data[i+8+n : i+12+n])
|
||||
if crc32.ChecksumIEEE(chunk) != got {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
kind := string(data[i+4 : i+8])
|
||||
if first {
|
||||
if kind != "IHDR" || n != 13 {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
width = int(binary.BigEndian.Uint32(data[i+8 : i+12]))
|
||||
height = int(binary.BigEndian.Uint32(data[i+12 : i+16]))
|
||||
if width < 1 || height < 1 {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
first = false
|
||||
}
|
||||
i += 12 + n
|
||||
if kind == "IEND" {
|
||||
if n != 0 || i != len(data) {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
return width, height, nil
|
||||
}
|
||||
}
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
|
||||
func parseJPEG(data []byte) (int, int, error) {
|
||||
if len(data) < 4 || data[0] != 0xff || data[1] != 0xd8 {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
i := 2
|
||||
var width, height int
|
||||
sawSOF := false
|
||||
sawEOI := false
|
||||
for i < len(data) {
|
||||
if data[i] != 0xff {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
for i < len(data) && data[i] == 0xff {
|
||||
i++
|
||||
}
|
||||
if i >= len(data) {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
marker := data[i]
|
||||
i++
|
||||
switch {
|
||||
case marker == 0xd9:
|
||||
sawEOI = true
|
||||
case marker == 0x01 || (marker >= 0xd0 && marker <= 0xd7):
|
||||
continue
|
||||
case marker == 0xda:
|
||||
// Энтропийные данные до следующего маркера.
|
||||
for i < len(data) {
|
||||
if data[i] != 0xff {
|
||||
i++
|
||||
continue
|
||||
}
|
||||
if i+1 >= len(data) {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
if data[i+1] == 0x00 {
|
||||
i += 2
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
continue
|
||||
default:
|
||||
if i+2 > len(data) {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
seglen := int(data[i])<<8 | int(data[i+1])
|
||||
if seglen < 2 || i+seglen > len(data) {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
if isSOF(marker) {
|
||||
if seglen < 7 {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
height = int(data[i+3])<<8 | int(data[i+4])
|
||||
width = int(data[i+5])<<8 | int(data[i+6])
|
||||
sawSOF = true
|
||||
}
|
||||
i += seglen
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
if !sawSOF || !sawEOI || width < 1 || height < 1 {
|
||||
return 0, 0, ErrFormat
|
||||
}
|
||||
return width, height, nil
|
||||
}
|
||||
|
||||
func isSOF(marker byte) bool {
|
||||
switch marker {
|
||||
case 0xc0, 0xc1, 0xc2:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
package imagecheck
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"hash/crc32"
|
||||
"image"
|
||||
"image/color"
|
||||
"image/jpeg"
|
||||
"image/png"
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func tinyPNG(t *testing.T, w, h int) []byte {
|
||||
t.Helper()
|
||||
img := image.NewNRGBA(image.Rect(0, 0, w, h))
|
||||
img.Set(0, 0, color.NRGBA{R: 10, G: 20, B: 30, A: 255})
|
||||
var buf bytes.Buffer
|
||||
if err := png.Encode(&buf, img); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return buf.Bytes()
|
||||
}
|
||||
|
||||
func tinyJPEG(t *testing.T) []byte {
|
||||
t.Helper()
|
||||
img := image.NewRGBA(image.Rect(0, 0, 8, 4))
|
||||
var buf bytes.Buffer
|
||||
if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: 80}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return buf.Bytes()
|
||||
}
|
||||
|
||||
func TestInspectAcceptsEncodedImages(t *testing.T) {
|
||||
pngBytes := tinyPNG(t, 3, 2)
|
||||
w, h, err := Inspect("image/png", pngBytes, 40_000_000)
|
||||
if err != nil || w != 3 || h != 2 {
|
||||
t.Fatalf("png: %d %d %v", w, h, err)
|
||||
}
|
||||
jpg := tinyJPEG(t)
|
||||
w, h, err = Inspect("image/jpeg", jpg, 40_000_000)
|
||||
if err != nil || w != 8 || h != 4 {
|
||||
t.Fatalf("jpeg: %d %d %v", w, h, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInspectRejectsMIMESwapAndDamage(t *testing.T) {
|
||||
pngBytes := tinyPNG(t, 2, 2)
|
||||
if _, _, err := Inspect("image/jpeg", pngBytes, 40_000_000); err != ErrFormat {
|
||||
t.Fatalf("png declared as jpeg: %v", err)
|
||||
}
|
||||
if _, _, err := Inspect("image/png", tinyJPEG(t), 40_000_000); err != ErrFormat {
|
||||
t.Fatalf("jpeg declared as png: %v", err)
|
||||
}
|
||||
if _, _, err := Inspect("image/png", []byte("not an image"), 40_000_000); err != ErrFormat {
|
||||
t.Fatalf("text: %v", err)
|
||||
}
|
||||
cut := pngBytes[:len(pngBytes)/2]
|
||||
if _, _, err := Inspect("image/png", cut, 40_000_000); err != ErrFormat {
|
||||
t.Fatalf("truncated: %v", err)
|
||||
}
|
||||
flipped := append([]byte(nil), pngBytes...)
|
||||
flipped[len(flipped)-20] ^= 0xff
|
||||
if _, _, err := Inspect("image/png", flipped, 40_000_000); err != ErrFormat {
|
||||
t.Fatalf("flipped byte: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInspectPixelLimitBeforeDecode(t *testing.T) {
|
||||
// 20000×2001 = 40_020_000 > 40_000_000. Файл маленький: лимит смотрит IHDR, не растр.
|
||||
huge := pngWithSize(t, 20000, 2001)
|
||||
if _, _, err := Inspect("image/png", huge, 40_000_000); err != ErrPixels {
|
||||
t.Fatalf("pixels: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func pngWithSize(t *testing.T, w, h int) []byte {
|
||||
t.Helper()
|
||||
// Валидный минимальный PNG с подменёнными размерами и пересчитанным CRC IHDR
|
||||
// не обязателен: достаточно корректного CRC, Decode для огромного размера не вызывается.
|
||||
base := tinyPNG(t, 1, 1)
|
||||
// IHDR width/height лежат сразу после сигнатуры и длины/типа: смещение 16 и 20.
|
||||
out := append([]byte(nil), base...)
|
||||
out[16] = byte(w >> 24)
|
||||
out[17] = byte(w >> 16)
|
||||
out[18] = byte(w >> 8)
|
||||
out[19] = byte(w)
|
||||
out[20] = byte(h >> 24)
|
||||
out[21] = byte(h >> 16)
|
||||
out[22] = byte(h >> 8)
|
||||
out[23] = byte(h)
|
||||
// CRC IHDR: байты 12..28 type+data, CRC по смещению 29.
|
||||
sum := crc32.ChecksumIEEE(out[12:29])
|
||||
out[29] = byte(sum >> 24)
|
||||
out[30] = byte(sum >> 16)
|
||||
out[31] = byte(sum >> 8)
|
||||
out[32] = byte(sum)
|
||||
return out
|
||||
}
|
||||
|
||||
func TestFixtureSample(t *testing.T) {
|
||||
b, err := os.ReadFile("../../tests/fixtures/sample.png")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
w, h, err := Inspect("image/png", b, 40_000_000)
|
||||
if err != nil || w != 320 || h != 200 {
|
||||
t.Fatalf("fixture: %d %d %v", w, h, err)
|
||||
}
|
||||
if _, _, err := Inspect("image/jpeg", b, 40_000_000); err != ErrFormat {
|
||||
t.Fatalf("fixture mime: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
// применяет SQL из бинарника ровно один раз на файл.
|
||||
package migrate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"messenger/migrations"
|
||||
)
|
||||
|
||||
// advisoryLock сериализует миграции между процессами. Номер постоянный для этого приложения.
|
||||
const advisoryLock int64 = 748392016
|
||||
|
||||
// Apply создаёт schema_migrations и выполняет ещё не записанные файлы.
|
||||
// Замок держится на одном соединении: пул сам по себе не привязывает блокировку к сессии.
|
||||
func Apply(ctx context.Context, pool *pgxpool.Pool) error {
|
||||
conn, err := pool.Acquire(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer conn.Release()
|
||||
if _, err := conn.Exec(ctx, `SELECT pg_advisory_lock($1)`, advisoryLock); err != nil {
|
||||
return fmt.Errorf("advisory lock: %w", err)
|
||||
}
|
||||
defer func() {
|
||||
_, _ = conn.Exec(context.Background(), `SELECT pg_advisory_unlock($1)`, advisoryLock)
|
||||
}()
|
||||
|
||||
if _, err := conn.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
)`); err != nil {
|
||||
return fmt.Errorf("schema_migrations: %w", err)
|
||||
}
|
||||
entries, err := fs.ReadDir(migrations.FS, ".")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
names := make([]string, 0, len(entries))
|
||||
for _, entry := range entries {
|
||||
if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".sql") {
|
||||
continue
|
||||
}
|
||||
names = append(names, entry.Name())
|
||||
}
|
||||
sort.Strings(names)
|
||||
for _, name := range names {
|
||||
var applied bool
|
||||
if err := conn.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM schema_migrations WHERE version = $1)`, name).Scan(&applied); err != nil {
|
||||
return err
|
||||
}
|
||||
if applied {
|
||||
continue
|
||||
}
|
||||
body, err := fs.ReadFile(migrations.FS, name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
tx, err := conn.Begin(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.Exec(ctx, string(body)); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return fmt.Errorf("%s: %w", name, err)
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version) VALUES ($1)`, name); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return err
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
// Package password хеширует пароли Argon2id.
|
||||
package password
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/crypto/argon2"
|
||||
)
|
||||
|
||||
// Params — стоимость KDF. Значения пишутся в саму строку хеша,
|
||||
// поэтому старые пароли проверяются даже после смены настроек.
|
||||
type Params struct {
|
||||
Time uint32
|
||||
Memory uint32
|
||||
Threads uint8
|
||||
}
|
||||
|
||||
// Hash возвращает PHC-строку.
|
||||
func (p Params) Hash(plain string) (string, error) {
|
||||
if p.Time < 1 || p.Threads < 1 || p.Memory < 8*uint32(p.Threads) {
|
||||
return "", fmt.Errorf("argon2 params are too small")
|
||||
}
|
||||
salt := make([]byte, 16)
|
||||
if _, err := rand.Read(salt); err != nil {
|
||||
return "", err
|
||||
}
|
||||
sum := argon2.IDKey([]byte(plain), salt, p.Time, p.Memory, p.Threads, 32)
|
||||
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
|
||||
argon2.Version,
|
||||
p.Memory, p.Time, p.Threads,
|
||||
base64.RawStdEncoding.EncodeToString(salt),
|
||||
base64.RawStdEncoding.EncodeToString(sum),
|
||||
), nil
|
||||
}
|
||||
|
||||
// Verify сравнивает пароль с PHC-строкой. Параметры берутся из строки, не из текущего конфига.
|
||||
func Verify(plain, encoded string) bool {
|
||||
parts := strings.Split(encoded, "$")
|
||||
if len(parts) != 6 || parts[1] != "argon2id" || !strings.HasPrefix(parts[2], "v=") {
|
||||
return false
|
||||
}
|
||||
var memory, timeCost, threads int
|
||||
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil {
|
||||
return false
|
||||
}
|
||||
if memory < 8 || timeCost < 1 || threads < 1 || threads > 255 {
|
||||
return false
|
||||
}
|
||||
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
|
||||
if err != nil || len(salt) == 0 {
|
||||
return false
|
||||
}
|
||||
want, err := base64.RawStdEncoding.DecodeString(parts[5])
|
||||
if err != nil || len(want) == 0 {
|
||||
return false
|
||||
}
|
||||
got := argon2.IDKey([]byte(plain), salt, uint32(timeCost), uint32(memory), uint8(threads), uint32(len(want)))
|
||||
return subtle.ConstantTimeCompare(got, want) == 1
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
package password
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestArgon2idRoundTrip(t *testing.T) {
|
||||
p := Params{Time: 1, Memory: 8, Threads: 1}
|
||||
encoded, err := p.Hash("correct-horse-1")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if encoded == "correct-horse-1" || len(encoded) < 20 {
|
||||
t.Fatalf("hash is not a PHC string: %s", encoded)
|
||||
}
|
||||
if !Verify("correct-horse-1", encoded) {
|
||||
t.Fatal("matching password rejected")
|
||||
}
|
||||
if Verify("other-password-1", encoded) {
|
||||
t.Fatal("wrong password accepted")
|
||||
}
|
||||
if Verify("correct-horse-1", "sha256:deadbeef") {
|
||||
t.Fatal("non-argon string accepted")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
// Сверка PostgreSQL и bucket.
|
||||
// Удаляются только старые расхождения: объект без строки и строка без объекта,
|
||||
package reconcile
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"messenger/internal/blob"
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
// Meta - чтение и безопасное удаление метаданных. Удаление само проверяет ссылки и возраст.
|
||||
type Meta interface {
|
||||
AttachmentRefs(ctx context.Context) ([]store.AttachmentRef, error)
|
||||
DeleteUnreferencedAttachment(ctx context.Context, id string, olderThan time.Time) (bool, error)
|
||||
}
|
||||
|
||||
// Summary - наблюдаемый результат одного прохода.
|
||||
type Summary struct {
|
||||
Mode string `json:"mode"`
|
||||
GraceSeconds int `json:"grace_seconds"`
|
||||
Cutoff string `json:"cutoff"`
|
||||
DBRows int `json:"db_rows"`
|
||||
S3Objects int `json:"s3_objects"`
|
||||
ListPages int `json:"list_pages"`
|
||||
Pairs int `json:"pairs"`
|
||||
OrphanFresh int `json:"orphan_fresh"`
|
||||
OrphanStale int `json:"orphan_stale"`
|
||||
MissingFresh int `json:"missing_fresh"`
|
||||
MissingReferenced int `json:"missing_referenced"`
|
||||
MissingStaleUnreferenced int `json:"missing_stale_unreferenced"`
|
||||
DeletedObjects int `json:"deleted_objects"`
|
||||
DeletedRows int `json:"deleted_rows"`
|
||||
DurationMs int64 `json:"duration_ms"`
|
||||
}
|
||||
|
||||
// Run сравнивает множество ключей. Стоимость - один листинг bucket и один запрос метаданных,
|
||||
// без HEAD на каждый объект.
|
||||
func Run(ctx context.Context, meta Meta, objects blob.Store, grace time.Duration, apply bool) (Summary, error) {
|
||||
start := time.Now()
|
||||
if grace < 0 {
|
||||
grace = 0
|
||||
}
|
||||
cutoff := time.Now().UTC().Add(-grace)
|
||||
rows, err := meta.AttachmentRefs(ctx)
|
||||
if err != nil {
|
||||
return Summary{}, err
|
||||
}
|
||||
listed, pages, err := objects.List(ctx)
|
||||
if err != nil {
|
||||
return Summary{}, err
|
||||
}
|
||||
byKey := make(map[string]store.AttachmentRef, len(rows))
|
||||
for _, row := range rows {
|
||||
byKey[row.ObjectKey] = row
|
||||
}
|
||||
seen := make(map[string]struct{}, len(listed))
|
||||
sum := Summary{
|
||||
Mode: "dry-run",
|
||||
GraceSeconds: int(grace / time.Second),
|
||||
Cutoff: cutoff.Format(time.RFC3339),
|
||||
DBRows: len(rows),
|
||||
S3Objects: len(listed),
|
||||
ListPages: pages,
|
||||
}
|
||||
if apply {
|
||||
sum.Mode = "apply"
|
||||
}
|
||||
for _, obj := range listed {
|
||||
seen[obj.Key] = struct{}{}
|
||||
if _, ok := byKey[obj.Key]; ok {
|
||||
sum.Pairs++
|
||||
continue
|
||||
}
|
||||
if !obj.Modified.UTC().Before(cutoff) {
|
||||
sum.OrphanFresh++
|
||||
continue
|
||||
}
|
||||
sum.OrphanStale++
|
||||
if !apply {
|
||||
continue
|
||||
}
|
||||
if err := objects.Delete(ctx, obj.Key); err != nil {
|
||||
return Summary{}, err
|
||||
}
|
||||
sum.DeletedObjects++
|
||||
}
|
||||
for _, row := range rows {
|
||||
if _, ok := seen[row.ObjectKey]; ok {
|
||||
continue
|
||||
}
|
||||
if row.Referenced {
|
||||
sum.MissingReferenced++
|
||||
continue
|
||||
}
|
||||
if !row.CreatedAt.UTC().Before(cutoff) {
|
||||
sum.MissingFresh++
|
||||
continue
|
||||
}
|
||||
sum.MissingStaleUnreferenced++
|
||||
if !apply {
|
||||
continue
|
||||
}
|
||||
deleted, err := meta.DeleteUnreferencedAttachment(ctx, row.ID, cutoff)
|
||||
if err != nil {
|
||||
return Summary{}, err
|
||||
}
|
||||
if deleted {
|
||||
sum.DeletedRows++
|
||||
}
|
||||
}
|
||||
sum.DurationMs = time.Since(start).Milliseconds()
|
||||
return sum, nil
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
package reconcile
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"messenger/internal/blob"
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
func TestReconcileKeepsFreshAndReferenced(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
meta := store.New()
|
||||
objects := blob.NewMemory()
|
||||
old := time.Now().UTC().Add(-time.Hour)
|
||||
fresh := time.Now().UTC()
|
||||
|
||||
mustPut := func(key string, at time.Time) {
|
||||
t.Helper()
|
||||
if err := objects.PutAt(ctx, key, []byte("x"), at); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
mustRow := func(key string, at time.Time, referenced bool) string {
|
||||
t.Helper()
|
||||
row, err := meta.InsertAttachment(ctx, store.Attachment{
|
||||
ChatID: "chat", OwnerID: "user", Filename: "a.png", ContentType: "image/png",
|
||||
SizeBytes: 1, SHA256: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
ObjectKey: key, Width: 1, Height: 1, CreatedAt: at,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if referenced {
|
||||
meta.MarkReferenced(row.ID)
|
||||
}
|
||||
return row.ID
|
||||
}
|
||||
|
||||
mustPut("orphan-old", old)
|
||||
mustPut("orphan-fresh", fresh)
|
||||
mustPut("pair-fresh", fresh)
|
||||
refID := mustRow("missing-ref", old, true)
|
||||
staleID := mustRow("missing-stale", old, false)
|
||||
freshID := mustRow("missing-fresh", fresh, false)
|
||||
pairID := mustRow("pair-fresh", fresh, false)
|
||||
|
||||
grace := 15 * time.Minute
|
||||
dry, err := Run(ctx, meta, objects, grace, false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if dry.Mode != "dry-run" || dry.DeletedObjects != 0 || dry.DeletedRows != 0 {
|
||||
t.Fatalf("dry-run mutated: %+v", dry)
|
||||
}
|
||||
if dry.OrphanStale != 1 || dry.OrphanFresh != 1 || dry.MissingReferenced != 1 || dry.MissingStaleUnreferenced != 1 || dry.MissingFresh != 1 || dry.Pairs != 1 {
|
||||
t.Fatalf("classification: %+v", dry)
|
||||
}
|
||||
again, err := Run(ctx, meta, objects, grace, false)
|
||||
if err != nil || again.OrphanStale != dry.OrphanStale || again.MissingStaleUnreferenced != dry.MissingStaleUnreferenced {
|
||||
t.Fatalf("second dry-run: %+v %v", again, err)
|
||||
}
|
||||
|
||||
applied, err := Run(ctx, meta, objects, grace, true)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if applied.DeletedObjects != 1 || applied.DeletedRows != 1 {
|
||||
t.Fatalf("apply: %+v", applied)
|
||||
}
|
||||
if _, err := objects.Get(ctx, "orphan-old"); err != blob.ErrNotFound {
|
||||
t.Fatalf("old orphan still present: %v", err)
|
||||
}
|
||||
if _, err := objects.Get(ctx, "orphan-fresh"); err != nil {
|
||||
t.Fatalf("fresh orphan deleted: %v", err)
|
||||
}
|
||||
if _, err := meta.AttachmentByID(ctx, refID); err != nil {
|
||||
t.Fatalf("referenced row deleted: %v", err)
|
||||
}
|
||||
if _, err := meta.AttachmentByID(ctx, freshID); err != nil {
|
||||
t.Fatalf("fresh row deleted: %v", err)
|
||||
}
|
||||
if _, err := meta.AttachmentByID(ctx, pairID); err != nil {
|
||||
t.Fatalf("pair deleted: %v", err)
|
||||
}
|
||||
if _, err := meta.AttachmentByID(ctx, staleID); err != store.ErrNotFound {
|
||||
t.Fatalf("stale row remains: %v", err)
|
||||
}
|
||||
|
||||
clean, err := Run(ctx, meta, objects, grace, true)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if clean.DeletedObjects != 0 || clean.DeletedRows != 0 || clean.OrphanStale != 0 || clean.MissingStaleUnreferenced != 0 {
|
||||
t.Fatalf("rerun not idempotent: %+v", clean)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package session
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestMemoryExpiryAndRevoke(t *testing.T) {
|
||||
s := NewMemory()
|
||||
ctx := context.Background()
|
||||
exp := time.Now().Add(30 * time.Millisecond)
|
||||
if err := s.Create(ctx, "token-value-with-enough-entropy-xx", "user-1", exp); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, _, err := s.Lookup(ctx, "token-value-with-enough-entropy-xx"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
time.Sleep(40 * time.Millisecond)
|
||||
if _, _, err := s.Lookup(ctx, "token-value-with-enough-entropy-xx"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("expired: %v", err)
|
||||
}
|
||||
exp = time.Now().Add(time.Minute)
|
||||
if err := s.Create(ctx, "token-value-with-enough-entropy-yy", "user-1", exp); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.Revoke(ctx, "token-value-with-enough-entropy-yy"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, _, err := s.Lookup(ctx, "token-value-with-enough-entropy-yy"); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("revoked: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRedisDown(t *testing.T) {
|
||||
s, err := OpenRedis("redis://127.0.0.1:1/0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer s.Close()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
||||
defer cancel()
|
||||
if err := s.Ping(ctx); !errors.Is(err, ErrUnavailable) {
|
||||
t.Fatalf("ping: %v", err)
|
||||
}
|
||||
if err := s.Create(ctx, "token", "user", time.Now().Add(time.Minute)); !errors.Is(err, ErrUnavailable) {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntegrationRedisRoundTrip(t *testing.T) {
|
||||
raw := os.Getenv("REDIS_URL")
|
||||
if raw == "" {
|
||||
t.Skip("REDIS_URL is not set")
|
||||
}
|
||||
s, err := OpenRedis(raw)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer s.Close()
|
||||
ctx := context.Background()
|
||||
token := "integration-token-" + time.Now().UTC().Format("150405.000000")
|
||||
exp := time.Now().UTC().Add(2 * time.Second).Truncate(time.Microsecond)
|
||||
if err := s.Create(ctx, token, "11111111-1111-4111-8111-111111111111", exp); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
id, got, err := s.Lookup(ctx, token)
|
||||
if err != nil || id != "11111111-1111-4111-8111-111111111111" || !got.Equal(exp) {
|
||||
t.Fatalf("lookup id=%s exp=%s err=%v", id, got, err)
|
||||
}
|
||||
time.Sleep(2200 * time.Millisecond)
|
||||
if _, _, err := s.Lookup(ctx, token); !errors.Is(err, ErrNotFound) {
|
||||
t.Fatalf("ttl did not expire: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,173 @@
|
||||
// Package session хранит непрозрачные Bearer-сессии.
|
||||
// В стенде это Redis: ключ живёт ровно до expires_at, рестарт TTL не сдвигает.
|
||||
package session
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrNotFound = errors.New("session not found")
|
||||
ErrUnavailable = errors.New("session store unavailable")
|
||||
)
|
||||
|
||||
// Store — срок жизни сессии задаёт вызывающий, хранилище его не продлевает.
|
||||
type Store interface {
|
||||
Create(ctx context.Context, token, userID string, expiresAt time.Time) error
|
||||
Lookup(ctx context.Context, token string) (userID string, expiresAt time.Time, err error)
|
||||
Revoke(ctx context.Context, token string) error
|
||||
Ping(ctx context.Context) error
|
||||
Close() error
|
||||
}
|
||||
|
||||
type record struct {
|
||||
UserID string `json:"user_id"`
|
||||
ExpUnix int64 `json:"exp_unix"`
|
||||
}
|
||||
|
||||
// key — хеш токена. Сам токен в Redis не пишется: утечка дампа не равна утечке Bearer.
|
||||
func key(token string) string {
|
||||
sum := sha256.Sum256([]byte(token))
|
||||
return "sess:" + hex.EncodeToString(sum[:])
|
||||
}
|
||||
|
||||
// Memory — сессии процесса. Нужна юнит-тестам без Docker.
|
||||
type Memory struct {
|
||||
mu sync.Mutex
|
||||
items map[string]record
|
||||
}
|
||||
|
||||
func NewMemory() *Memory {
|
||||
return &Memory{items: make(map[string]record)}
|
||||
}
|
||||
|
||||
func (m *Memory) Create(_ context.Context, token, userID string, expiresAt time.Time) error {
|
||||
if token == "" || userID == "" {
|
||||
return ErrNotFound
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.items[key(token)] = record{UserID: userID, ExpUnix: expiresAt.UTC().UnixMicro()}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) Lookup(_ context.Context, token string) (string, time.Time, error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
rec, ok := m.items[key(token)]
|
||||
if !ok {
|
||||
return "", time.Time{}, ErrNotFound
|
||||
}
|
||||
exp := time.UnixMicro(rec.ExpUnix).UTC()
|
||||
if !time.Now().Before(exp) {
|
||||
delete(m.items, key(token))
|
||||
return "", time.Time{}, ErrNotFound
|
||||
}
|
||||
return rec.UserID, exp, nil
|
||||
}
|
||||
|
||||
func (m *Memory) Revoke(_ context.Context, token string) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
k := key(token)
|
||||
if _, ok := m.items[k]; !ok {
|
||||
return ErrNotFound
|
||||
}
|
||||
delete(m.items, k)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) Ping(ctx context.Context) error {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) Close() error { return nil }
|
||||
|
||||
// Redis — единственное хранилище сессий стенда.
|
||||
type Redis struct {
|
||||
client *redis.Client
|
||||
}
|
||||
|
||||
func OpenRedis(rawURL string) (*Redis, error) {
|
||||
opt, err := redis.ParseURL(rawURL)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
opt.DialTimeout = 500 * time.Millisecond
|
||||
opt.ReadTimeout = 500 * time.Millisecond
|
||||
opt.WriteTimeout = 500 * time.Millisecond
|
||||
opt.PoolSize = 10
|
||||
opt.MinIdleConns = 1
|
||||
return &Redis{client: redis.NewClient(opt)}, nil
|
||||
}
|
||||
|
||||
func (r *Redis) Create(ctx context.Context, token, userID string, expiresAt time.Time) error {
|
||||
if token == "" || userID == "" {
|
||||
return ErrNotFound
|
||||
}
|
||||
ttl := time.Until(expiresAt)
|
||||
if ttl < time.Millisecond {
|
||||
return ErrNotFound
|
||||
}
|
||||
body, err := json.Marshal(record{UserID: userID, ExpUnix: expiresAt.UTC().UnixMicro()})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := r.client.Set(ctx, key(token), body, ttl).Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Redis) Lookup(ctx context.Context, token string) (string, time.Time, error) {
|
||||
raw, err := r.client.Get(ctx, key(token)).Bytes()
|
||||
if errors.Is(err, redis.Nil) {
|
||||
return "", time.Time{}, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return "", time.Time{}, ErrUnavailable
|
||||
}
|
||||
var rec record
|
||||
if err := json.Unmarshal(raw, &rec); err != nil || rec.UserID == "" {
|
||||
return "", time.Time{}, ErrNotFound
|
||||
}
|
||||
exp := time.UnixMicro(rec.ExpUnix).UTC()
|
||||
if !time.Now().Before(exp) {
|
||||
_ = r.client.Del(ctx, key(token)).Err()
|
||||
return "", time.Time{}, ErrNotFound
|
||||
}
|
||||
return rec.UserID, exp, nil
|
||||
}
|
||||
|
||||
func (r *Redis) Revoke(ctx context.Context, token string) error {
|
||||
n, err := r.client.Del(ctx, key(token)).Result()
|
||||
if err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
if n == 0 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Redis) Ping(ctx context.Context) error {
|
||||
if err := r.client.Ping(ctx).Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Redis) Close() error {
|
||||
return r.client.Close()
|
||||
}
|
||||
@@ -0,0 +1,286 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
func (p *PG) InsertAttachment(ctx context.Context, row Attachment) (Attachment, error) {
|
||||
if row.ID == "" {
|
||||
row.ID = newID()
|
||||
}
|
||||
now := time.Now().UTC().Truncate(time.Microsecond)
|
||||
if row.CreatedAt.IsZero() {
|
||||
row.CreatedAt = now
|
||||
} else {
|
||||
row.CreatedAt = row.CreatedAt.UTC().Truncate(time.Microsecond)
|
||||
}
|
||||
row.UpdatedAt = row.CreatedAt
|
||||
row.Status = "ready"
|
||||
_, err := p.pool.Exec(ctx, `
|
||||
INSERT INTO attachments (
|
||||
id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
|
||||
object_key, width, height, status, created_at, updated_at
|
||||
) VALUES (
|
||||
$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13
|
||||
)`,
|
||||
row.ID, row.ChatID, row.OwnerID, row.Filename, row.ContentType, row.SizeBytes, row.SHA256,
|
||||
row.ObjectKey, row.Width, row.Height, row.Status, row.CreatedAt, row.UpdatedAt)
|
||||
if err != nil {
|
||||
return Attachment{}, mapDB(err)
|
||||
}
|
||||
return row, nil
|
||||
}
|
||||
|
||||
func (p *PG) AttachmentVisible(ctx context.Context, id, userID string) (Attachment, error) {
|
||||
var row Attachment
|
||||
err := p.pool.QueryRow(ctx, `
|
||||
SELECT a.id::text, a.chat_id::text, a.owner_id::text, a.filename, a.content_type,
|
||||
a.size_bytes, a.sha256, a.object_key, a.width, a.height, a.status, a.created_at, a.updated_at
|
||||
FROM attachments a
|
||||
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
|
||||
WHERE a.id = $1`, id, userID).Scan(
|
||||
&row.ID, &row.ChatID, &row.OwnerID, &row.Filename, &row.ContentType,
|
||||
&row.SizeBytes, &row.SHA256, &row.ObjectKey, &row.Width, &row.Height, &row.Status,
|
||||
&row.CreatedAt, &row.UpdatedAt)
|
||||
if err != nil {
|
||||
return Attachment{}, mapDB(err)
|
||||
}
|
||||
row.CreatedAt = row.CreatedAt.UTC()
|
||||
row.UpdatedAt = row.UpdatedAt.UTC()
|
||||
return row, nil
|
||||
}
|
||||
|
||||
func (p *PG) AttachmentRefs(ctx context.Context) ([]AttachmentRef, error) {
|
||||
rows, err := p.pool.Query(ctx, `
|
||||
SELECT a.id::text, a.object_key, a.created_at,
|
||||
EXISTS(SELECT 1 FROM message_attachments m WHERE m.attachment_id = a.id)
|
||||
FROM attachments a`)
|
||||
if err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
out := make([]AttachmentRef, 0)
|
||||
for rows.Next() {
|
||||
var row AttachmentRef
|
||||
if err := rows.Scan(&row.ID, &row.ObjectKey, &row.CreatedAt, &row.Referenced); err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
row.CreatedAt = row.CreatedAt.UTC()
|
||||
out = append(out, row)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (p *PG) DeleteUnreferencedAttachment(ctx context.Context, id string, olderThan time.Time) (bool, error) {
|
||||
tag, err := p.pool.Exec(ctx, `
|
||||
DELETE FROM attachments a
|
||||
WHERE a.id = $1
|
||||
AND a.created_at < $2
|
||||
AND NOT EXISTS (SELECT 1 FROM message_attachments m WHERE m.attachment_id = a.id)`, id, olderThan)
|
||||
if err != nil {
|
||||
return false, mapDB(err)
|
||||
}
|
||||
return tag.RowsAffected() == 1, nil
|
||||
}
|
||||
|
||||
func bindAttachments(ctx context.Context, tx pgx.Tx, messageID, chatID string, ids []string) error {
|
||||
for i, id := range ids {
|
||||
var gotChat, status string
|
||||
err := tx.QueryRow(ctx, `
|
||||
SELECT chat_id::text, status FROM attachments WHERE id = $1`, id).Scan(&gotChat, &status)
|
||||
if err != nil {
|
||||
if mapDB(err) == ErrNotFound {
|
||||
return ErrNotFound
|
||||
}
|
||||
return err
|
||||
}
|
||||
if gotChat != chatID {
|
||||
return ErrNotFound
|
||||
}
|
||||
if status != "ready" {
|
||||
return ErrNotReady
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `
|
||||
INSERT INTO message_attachments (message_id, attachment_id, position)
|
||||
VALUES ($1, $2, $3)`, messageID, id, i); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func attachmentIDsOf(ctx context.Context, q queryer, messageID string) ([]string, error) {
|
||||
rows, err := q.Query(ctx, `
|
||||
SELECT attachment_id::text
|
||||
FROM message_attachments
|
||||
WHERE message_id = $1
|
||||
ORDER BY position`, messageID)
|
||||
if err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
ids := make([]string, 0)
|
||||
for rows.Next() {
|
||||
var id string
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
return ids, nil
|
||||
}
|
||||
|
||||
func fillAttachmentIDs(ctx context.Context, q queryer, items []Message) error {
|
||||
if len(items) == 0 {
|
||||
return nil
|
||||
}
|
||||
ids := make([]string, len(items))
|
||||
for i := range items {
|
||||
ids[i] = items[i].ID
|
||||
items[i].AttachmentIDs = []string{}
|
||||
}
|
||||
rows, err := q.Query(ctx, `
|
||||
SELECT message_id::text, attachment_id::text
|
||||
FROM message_attachments
|
||||
WHERE message_id::text = ANY($1::text[])
|
||||
ORDER BY message_id, position`, ids)
|
||||
if err != nil {
|
||||
return mapDB(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
grouped := map[string][]string{}
|
||||
for rows.Next() {
|
||||
var messageID, attachmentID string
|
||||
if err := rows.Scan(&messageID, &attachmentID); err != nil {
|
||||
return mapDB(err)
|
||||
}
|
||||
grouped[messageID] = append(grouped[messageID], attachmentID)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return mapDB(err)
|
||||
}
|
||||
for i := range items {
|
||||
if got, ok := grouped[items[i].ID]; ok {
|
||||
items[i].AttachmentIDs = got
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Memory) InsertAttachment(ctx context.Context, row Attachment) (Attachment, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Attachment{}, ErrUnavailable
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if row.ID == "" {
|
||||
row.ID = newID()
|
||||
}
|
||||
now := s.nextTimeLocked()
|
||||
if row.CreatedAt.IsZero() {
|
||||
row.CreatedAt = now
|
||||
} else {
|
||||
row.CreatedAt = row.CreatedAt.UTC()
|
||||
}
|
||||
row.UpdatedAt = row.CreatedAt
|
||||
if row.Status == "" {
|
||||
row.Status = "ready"
|
||||
}
|
||||
s.attachments[row.ID] = row
|
||||
return row, nil
|
||||
}
|
||||
|
||||
func (s *Memory) AttachmentVisible(ctx context.Context, id, userID string) (Attachment, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Attachment{}, ErrUnavailable
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
row, ok := s.attachments[id]
|
||||
if !ok {
|
||||
return Attachment{}, ErrNotFound
|
||||
}
|
||||
rec, ok := s.chats[row.ChatID]
|
||||
if !ok {
|
||||
return Attachment{}, ErrNotFound
|
||||
}
|
||||
if _, member := rec.members[userID]; !member {
|
||||
return Attachment{}, ErrNotFound
|
||||
}
|
||||
return row, nil
|
||||
}
|
||||
|
||||
func (s *Memory) AttachmentRefs(ctx context.Context) ([]AttachmentRef, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return nil, ErrUnavailable
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
out := make([]AttachmentRef, 0, len(s.attachments))
|
||||
for _, row := range s.attachments {
|
||||
out = append(out, AttachmentRef{
|
||||
ID: row.ID, ObjectKey: row.ObjectKey, CreatedAt: row.CreatedAt, Referenced: s.referencedLocked(row.ID),
|
||||
})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (s *Memory) DeleteUnreferencedAttachment(ctx context.Context, id string, olderThan time.Time) (bool, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return false, ErrUnavailable
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
row, ok := s.attachments[id]
|
||||
if !ok || s.referencedLocked(row.ID) || !row.CreatedAt.Before(olderThan) {
|
||||
return false, nil
|
||||
}
|
||||
delete(s.attachments, id)
|
||||
return true, nil
|
||||
}
|
||||
|
||||
// MarkReferenced нужен тесту сверки: строка считается используемой без сообщения.
|
||||
func (s *Memory) MarkReferenced(id string) {
|
||||
s.mu.Lock()
|
||||
s.referenced[id] = struct{}{}
|
||||
s.mu.Unlock()
|
||||
}
|
||||
|
||||
// AttachmentByID читает строку без проверки участника. Только для тестов сверки.
|
||||
func (s *Memory) AttachmentByID(ctx context.Context, id string) (Attachment, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Attachment{}, ErrUnavailable
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
row, ok := s.attachments[id]
|
||||
if !ok {
|
||||
return Attachment{}, ErrNotFound
|
||||
}
|
||||
return row, nil
|
||||
}
|
||||
|
||||
func (s *Memory) referencedLocked(id string) bool {
|
||||
if _, ok := s.referenced[id]; ok {
|
||||
return true
|
||||
}
|
||||
for _, msgs := range s.messages {
|
||||
for _, m := range msgs {
|
||||
for _, aid := range m.AttachmentIDs {
|
||||
if aid == id {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -0,0 +1,473 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// PG - источник истины для пользователей, чатов и сообщений.
|
||||
// Запросы только с параметрами. Пул ограничен, у сессии соединения есть statement_timeout.
|
||||
type PG struct {
|
||||
pool *pgxpool.Pool
|
||||
idemTTL time.Duration
|
||||
}
|
||||
|
||||
func Open(ctx context.Context, databaseURL string, maxConns int32) (*PG, error) {
|
||||
cfg, err := pgxpool.ParseConfig(databaseURL)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if maxConns < 1 {
|
||||
maxConns = 10
|
||||
}
|
||||
cfg.MaxConns = maxConns
|
||||
cfg.MinConns = 1
|
||||
cfg.MaxConnLifetime = 30 * time.Minute
|
||||
cfg.MaxConnIdleTime = 5 * time.Minute
|
||||
cfg.HealthCheckPeriod = 30 * time.Second
|
||||
cfg.ConnConfig.ConnectTimeout = 3 * time.Second
|
||||
cfg.ConnConfig.RuntimeParams["application_name"] = "messenger"
|
||||
cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000"
|
||||
cfg.ConnConfig.RuntimeParams["lock_timeout"] = "3000"
|
||||
cfg.ConnConfig.RuntimeParams["idle_in_transaction_session_timeout"] = "10000"
|
||||
pool, err := pgxpool.NewWithConfig(ctx, cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pingCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
||||
defer cancel()
|
||||
if err := pool.Ping(pingCtx); err != nil {
|
||||
pool.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &PG{pool: pool, idemTTL: 24 * time.Hour}, nil
|
||||
}
|
||||
|
||||
// SetIdempotencyTTL задаёт, сколько хранить результат POST сообщения.
|
||||
func (p *PG) SetIdempotencyTTL(ttl time.Duration) {
|
||||
if ttl > 0 {
|
||||
p.idemTTL = ttl
|
||||
}
|
||||
}
|
||||
|
||||
func (p *PG) Close() { p.pool.Close() }
|
||||
|
||||
func (p *PG) Pool() *pgxpool.Pool { return p.pool }
|
||||
|
||||
func (p *PG) Ping(ctx context.Context) error {
|
||||
return mapDB(p.pool.Ping(ctx))
|
||||
}
|
||||
|
||||
func (p *PG) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) {
|
||||
u := User{
|
||||
ID: newID(),
|
||||
Username: username,
|
||||
DisplayName: displayName,
|
||||
CreatedAt: time.Now().UTC().Truncate(time.Microsecond),
|
||||
}
|
||||
_, err := p.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)
|
||||
if err != nil {
|
||||
return User{}, mapDB(err)
|
||||
}
|
||||
return u, nil
|
||||
}
|
||||
|
||||
func (p *PG) User(ctx context.Context, id string) (User, error) {
|
||||
row := p.pool.QueryRow(ctx, `
|
||||
SELECT id::text, username, display_name, created_at
|
||||
FROM users WHERE id = $1`, id)
|
||||
return scanUser(row)
|
||||
}
|
||||
|
||||
func (p *PG) UserByUsername(ctx context.Context, username string) (User, string, error) {
|
||||
var u User
|
||||
var hash string
|
||||
err := p.pool.QueryRow(ctx, `
|
||||
SELECT id::text, username, display_name, created_at, password_hash
|
||||
FROM users WHERE username = $1`, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash)
|
||||
if err != nil {
|
||||
return User{}, "", mapDB(err)
|
||||
}
|
||||
u.CreatedAt = u.CreatedAt.UTC()
|
||||
return u, hash, nil
|
||||
}
|
||||
|
||||
// CreateChat пишет чат и всех участников в одной транзакции.
|
||||
// Если кого-то из списка нет, COMMIT не случается и строка чата не остаётся.
|
||||
func (p *PG) CreateChat(ctx context.Context, title string, memberIDs []string, caller string) (Chat, error) {
|
||||
seen := make(map[string]struct{}, len(memberIDs))
|
||||
for _, id := range memberIDs {
|
||||
if _, dup := seen[id]; dup {
|
||||
return Chat{}, ErrInvalid
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
}
|
||||
if _, ok := seen[caller]; !ok {
|
||||
return Chat{}, ErrInvalid
|
||||
}
|
||||
tx, err := p.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return Chat{}, mapDB(err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
|
||||
c := Chat{
|
||||
ID: newID(),
|
||||
Title: title,
|
||||
MemberIDs: append([]string(nil), memberIDs...),
|
||||
CreatedAt: time.Now().UTC().Truncate(time.Microsecond),
|
||||
}
|
||||
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 Chat{}, mapDB(err)
|
||||
}
|
||||
var n int
|
||||
if err := tx.QueryRow(ctx, `SELECT count(*) FROM users WHERE id::text = ANY($1::text[])`, memberIDs).Scan(&n); err != nil {
|
||||
return Chat{}, mapDB(err)
|
||||
}
|
||||
if n != len(memberIDs) {
|
||||
return Chat{}, ErrInvalid
|
||||
}
|
||||
for i, id := range memberIDs {
|
||||
if _, err := tx.Exec(ctx, `
|
||||
INSERT INTO chat_members (chat_id, user_id, position) VALUES ($1, $2, $3)`,
|
||||
c.ID, id, i); err != nil {
|
||||
return Chat{}, mapDB(err)
|
||||
}
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return Chat{}, mapDB(err)
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (p *PG) ChatFor(ctx context.Context, chatID, userID string) (Chat, error) {
|
||||
var c Chat
|
||||
err := p.pool.QueryRow(ctx, `
|
||||
SELECT c.id::text, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $2
|
||||
WHERE c.id = $1`, chatID, userID).Scan(&c.ID, &c.Title, &c.CreatedAt)
|
||||
if err != nil {
|
||||
return Chat{}, mapDB(err)
|
||||
}
|
||||
c.CreatedAt = c.CreatedAt.UTC()
|
||||
ids, err := p.memberIDs(ctx, p.pool, []string{c.ID})
|
||||
if err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
c.MemberIDs = ids[c.ID]
|
||||
if c.MemberIDs == nil {
|
||||
c.MemberIDs = []string{}
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (p *PG) ListChats(ctx context.Context, userID string, cur *Cursor, limit int) ([]Chat, bool, error) {
|
||||
hasCursor := cur != nil
|
||||
at := time.Time{}
|
||||
var id any
|
||||
if hasCursor {
|
||||
at = cur.At
|
||||
id = cur.ID
|
||||
}
|
||||
rows, err := p.pool.Query(ctx, `
|
||||
SELECT c.id::text, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $1
|
||||
WHERE NOT $2::bool OR (c.created_at, c.id) > ($3::timestamptz, $4::uuid)
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $5`, userID, hasCursor, at, id, limit+1)
|
||||
if err != nil {
|
||||
return nil, false, mapDB(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
items := make([]Chat, 0)
|
||||
ids := make([]string, 0)
|
||||
for rows.Next() {
|
||||
var c Chat
|
||||
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
|
||||
return nil, false, mapDB(err)
|
||||
}
|
||||
c.CreatedAt = c.CreatedAt.UTC()
|
||||
items = append(items, c)
|
||||
ids = append(ids, c.ID)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, false, mapDB(err)
|
||||
}
|
||||
hasMore := len(items) > limit
|
||||
if hasMore {
|
||||
items = items[:limit]
|
||||
ids = ids[:limit]
|
||||
}
|
||||
members, err := p.memberIDs(ctx, p.pool, ids)
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
for i := range items {
|
||||
items[i].MemberIDs = members[items[i].ID]
|
||||
if items[i].MemberIDs == nil {
|
||||
items[i].MemberIDs = []string{}
|
||||
}
|
||||
}
|
||||
return items, hasMore, nil
|
||||
}
|
||||
|
||||
func (p *PG) AddMessage(ctx context.Context, chatID, senderID, text string, attachmentIDs []string, idemKey, fingerprint string) (Message, error) {
|
||||
if idemKey == "" || fingerprint == "" {
|
||||
return Message{}, ErrInvalid
|
||||
}
|
||||
var last error
|
||||
for attempt := 0; attempt < 5; attempt++ {
|
||||
msg, retry, err := p.addMessageOnce(ctx, chatID, senderID, text, attachmentIDs, idemKey, fingerprint)
|
||||
if !retry {
|
||||
return msg, err
|
||||
}
|
||||
last = err
|
||||
}
|
||||
if last == nil {
|
||||
last = ErrUnavailable
|
||||
}
|
||||
return Message{}, ErrUnavailable
|
||||
}
|
||||
|
||||
// addMessageOnce пишет сообщение и ключ одной транзакцией.
|
||||
// retry=true значит, что параллельная реплика заняла тот же ключ раньше: свою вставку откатываем и читаем её результат.
|
||||
func (p *PG) addMessageOnce(ctx context.Context, chatID, senderID, text string, attachmentIDs []string, idemKey, fingerprint string) (Message, bool, error) {
|
||||
tx, err := p.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return Message{}, false, mapDB(err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
|
||||
var member int
|
||||
if err := tx.QueryRow(ctx, `
|
||||
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, senderID).Scan(&member); err != nil {
|
||||
return Message{}, false, mapDB(err)
|
||||
}
|
||||
|
||||
var storedFP, messageID string
|
||||
var expires time.Time
|
||||
err = tx.QueryRow(ctx, `
|
||||
SELECT fingerprint, message_id::text, expires_at
|
||||
FROM message_idempotency
|
||||
WHERE user_id = $1 AND chat_id = $2 AND idem_key = $3
|
||||
FOR UPDATE`, senderID, chatID, idemKey).Scan(&storedFP, &messageID, &expires)
|
||||
if err == nil {
|
||||
if expires.After(time.Now()) {
|
||||
if storedFP != fingerprint {
|
||||
return Message{}, false, ErrIdempotencyMismatch
|
||||
}
|
||||
msg, err := scanMessage(tx.QueryRow(ctx, `
|
||||
SELECT id::text, chat_id::text, sender_id::text, text, created_at
|
||||
FROM messages WHERE id = $1`, messageID))
|
||||
if err != nil {
|
||||
return Message{}, false, err
|
||||
}
|
||||
msg.AttachmentIDs, err = attachmentIDsOf(ctx, tx, msg.ID)
|
||||
if err != nil {
|
||||
return Message{}, false, err
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return Message{}, false, mapDB(err)
|
||||
}
|
||||
return msg, false, nil
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `
|
||||
DELETE FROM message_idempotency
|
||||
WHERE user_id = $1 AND chat_id = $2 AND idem_key = $3`, senderID, chatID, idemKey); err != nil {
|
||||
return Message{}, false, mapDB(err)
|
||||
}
|
||||
} else if !errors.Is(err, pgx.ErrNoRows) {
|
||||
return Message{}, false, mapDB(err)
|
||||
}
|
||||
|
||||
now := time.Now().UTC().Truncate(time.Microsecond)
|
||||
m := Message{
|
||||
ID: newID(),
|
||||
ChatID: chatID,
|
||||
SenderID: senderID,
|
||||
Text: text,
|
||||
CreatedAt: now,
|
||||
AttachmentIDs: append([]string(nil), attachmentIDs...),
|
||||
}
|
||||
if m.AttachmentIDs == nil {
|
||||
m.AttachmentIDs = []string{}
|
||||
}
|
||||
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 Message{}, retryable(err), mapDB(err)
|
||||
}
|
||||
if err := bindAttachments(ctx, tx, m.ID, chatID, m.AttachmentIDs); err != nil {
|
||||
return Message{}, retryable(err), mapDB(err)
|
||||
}
|
||||
recorded := time.Now().UTC().Truncate(time.Microsecond)
|
||||
if _, err := tx.Exec(ctx, `
|
||||
INSERT INTO message_idempotency
|
||||
(user_id, chat_id, idem_key, fingerprint, message_id, created_at, expires_at)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7)`,
|
||||
senderID, chatID, idemKey, fingerprint, m.ID, recorded, recorded.Add(p.idemTTL)); err != nil {
|
||||
return Message{}, retryable(err), mapDB(err)
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return Message{}, retryable(err), mapDB(err)
|
||||
}
|
||||
return m, false, nil
|
||||
}
|
||||
|
||||
func retryable(err error) bool {
|
||||
var pgErr *pgconn.PgError
|
||||
if errors.As(err, &pgErr) {
|
||||
switch pgErr.Code {
|
||||
case "23505", "40001", "40P01":
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (p *PG) ListMessages(ctx context.Context, chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error) {
|
||||
var member int
|
||||
err := p.pool.QueryRow(ctx, `
|
||||
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, userID).Scan(&member)
|
||||
if err != nil {
|
||||
return nil, false, mapDB(err)
|
||||
}
|
||||
if cur != nil {
|
||||
var one int
|
||||
err := p.pool.QueryRow(ctx, `
|
||||
SELECT 1 FROM messages
|
||||
WHERE chat_id = $1 AND id = $2 AND created_at = $3`, chatID, cur.ID, cur.At).Scan(&one)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, false, ErrBadCursor
|
||||
}
|
||||
if err != nil {
|
||||
return nil, false, mapDB(err)
|
||||
}
|
||||
}
|
||||
hasCursor := cur != nil
|
||||
at := time.Time{}
|
||||
var id any
|
||||
if hasCursor {
|
||||
at = cur.At
|
||||
id = cur.ID
|
||||
}
|
||||
rows, err := p.pool.Query(ctx, `
|
||||
SELECT id::text, chat_id::text, sender_id::text, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
AND (NOT $2::bool OR (created_at, id) > ($3::timestamptz, $4::uuid))
|
||||
ORDER BY created_at, id
|
||||
LIMIT $5`, chatID, hasCursor, at, id, limit+1)
|
||||
if err != nil {
|
||||
return nil, false, mapDB(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
items := make([]Message, 0)
|
||||
for rows.Next() {
|
||||
m, err := scanMessage(rows)
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
items = append(items, m)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, false, mapDB(err)
|
||||
}
|
||||
hasMore := len(items) > limit
|
||||
if hasMore {
|
||||
items = items[:limit]
|
||||
}
|
||||
if err := fillAttachmentIDs(ctx, p.pool, items); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
return items, hasMore, nil
|
||||
}
|
||||
|
||||
type queryer interface {
|
||||
Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
|
||||
}
|
||||
|
||||
func (p *PG) memberIDs(ctx context.Context, q queryer, chatIDs []string) (map[string][]string, error) {
|
||||
out := make(map[string][]string, len(chatIDs))
|
||||
if len(chatIDs) == 0 {
|
||||
return out, nil
|
||||
}
|
||||
rows, err := q.Query(ctx, `
|
||||
SELECT chat_id::text, user_id::text
|
||||
FROM chat_members
|
||||
WHERE chat_id::text = ANY($1::text[])
|
||||
ORDER BY chat_id, position`, chatIDs)
|
||||
if err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var chatID, userID string
|
||||
if err := rows.Scan(&chatID, &userID); err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
out[chatID] = append(out[chatID], userID)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, mapDB(err)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func scanMessage(row pgx.Row) (Message, error) {
|
||||
var m Message
|
||||
if err := row.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
|
||||
return Message{}, mapDB(err)
|
||||
}
|
||||
m.CreatedAt = m.CreatedAt.UTC()
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func scanUser(row pgx.Row) (User, error) {
|
||||
var u User
|
||||
err := row.Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
|
||||
if err != nil {
|
||||
return User{}, mapDB(err)
|
||||
}
|
||||
u.CreatedAt = u.CreatedAt.UTC()
|
||||
return u, nil
|
||||
}
|
||||
|
||||
func mapDB(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return ErrNotFound
|
||||
}
|
||||
if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
|
||||
return ErrUnavailable
|
||||
}
|
||||
var pgErr *pgconn.PgError
|
||||
if errors.As(err, &pgErr) {
|
||||
switch pgErr.Code {
|
||||
case "23505":
|
||||
return ErrConflict
|
||||
case "23503", "23514", "22P02":
|
||||
return ErrInvalid
|
||||
case "57014", "55P03":
|
||||
return ErrUnavailable
|
||||
}
|
||||
}
|
||||
var netErr net.Error
|
||||
if errors.As(err, &netErr) {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,183 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"os"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"messenger/internal/migrate"
|
||||
)
|
||||
|
||||
func openIntegration(t *testing.T) *PG {
|
||||
t.Helper()
|
||||
raw := os.Getenv("DATABASE_URL")
|
||||
if raw == "" {
|
||||
t.Skip("DATABASE_URL is not set")
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
||||
defer cancel()
|
||||
pg, err := Open(ctx, raw, 10)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(pg.Close)
|
||||
if err := migrate.Apply(ctx, pg.Pool()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return pg
|
||||
}
|
||||
|
||||
func TestIntegrationMigrationRerunKeepsRows(t *testing.T) {
|
||||
pg := openIntegration(t)
|
||||
ctx := context.Background()
|
||||
name := "mig_" + newID()[:8]
|
||||
if _, err := pg.CreateUser(ctx, name, "Миграция", "hash"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var before int
|
||||
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM users`).Scan(&before); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := migrate.Apply(ctx, pg.Pool()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var after int
|
||||
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM users`).Scan(&after); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if before != after {
|
||||
t.Fatalf("migration rerun changed users %d -> %d", before, after)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntegrationUsernameRace(t *testing.T) {
|
||||
pg := openIntegration(t)
|
||||
ctx := context.Background()
|
||||
name := "race_" + newID()[:8]
|
||||
const n = 32
|
||||
var wg sync.WaitGroup
|
||||
wins := make(chan struct{}, n)
|
||||
fails := make(chan error, n)
|
||||
for i := 0; i < n; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
_, err := pg.CreateUser(ctx, name, "Гонка", "hash")
|
||||
if err == nil {
|
||||
wins <- struct{}{}
|
||||
return
|
||||
}
|
||||
fails <- err
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
close(wins)
|
||||
close(fails)
|
||||
got := 0
|
||||
for range wins {
|
||||
got++
|
||||
}
|
||||
if got != 1 {
|
||||
t.Fatalf("winners = %d, want 1", got)
|
||||
}
|
||||
for err := range fails {
|
||||
if !errors.Is(err, ErrConflict) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntegrationChatRollback(t *testing.T) {
|
||||
pg := openIntegration(t)
|
||||
ctx := context.Background()
|
||||
u, err := pg.CreateUser(ctx, "rb_"+newID()[:8], "Откат", "hash")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var before int
|
||||
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&before); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_, err = pg.CreateChat(ctx, "не должен сохраниться", []string{u.ID, "99999999-9999-4999-8999-999999999999"}, u.ID)
|
||||
if !errors.Is(err, ErrInvalid) {
|
||||
t.Fatalf("want invalid, got %v", err)
|
||||
}
|
||||
var after int
|
||||
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&after); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if before != after {
|
||||
t.Fatalf("rolled-back chat stayed: %d -> %d", before, after)
|
||||
}
|
||||
var members int
|
||||
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chat_members WHERE user_id = $1`, u.ID).Scan(&members); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if members != 0 {
|
||||
t.Fatalf("rolled-back membership stayed: %d", members)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntegrationIdempotencyRace(t *testing.T) {
|
||||
pg := openIntegration(t)
|
||||
ctx := context.Background()
|
||||
u, err := pg.CreateUser(ctx, "idm_"+newID()[:8], "Ключ", "hash")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
chat, err := pg.CreateChat(ctx, "идемпотентность", []string{u.ID}, u.ID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
const n = 16
|
||||
var wg sync.WaitGroup
|
||||
ids := make(chan string, n)
|
||||
errs := make(chan error, n)
|
||||
for i := 0; i < n; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
msg, err := pg.AddMessage(ctx, chat.ID, u.ID, "одно", nil, "key-1", "одно")
|
||||
if err != nil {
|
||||
errs <- err
|
||||
return
|
||||
}
|
||||
ids <- msg.ID
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
close(ids)
|
||||
close(errs)
|
||||
for err := range errs {
|
||||
t.Fatal(err)
|
||||
}
|
||||
seen := map[string]struct{}{}
|
||||
for id := range ids {
|
||||
seen[id] = struct{}{}
|
||||
}
|
||||
if len(seen) != 1 {
|
||||
t.Fatalf("concurrent key created %d messages", len(seen))
|
||||
}
|
||||
if _, err := pg.AddMessage(ctx, chat.ID, u.ID, "другое", nil, "key-1", "другое"); !errors.Is(err, ErrIdempotencyMismatch) {
|
||||
t.Fatalf("mismatch: %v", err)
|
||||
}
|
||||
var count int
|
||||
if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM messages WHERE chat_id = $1`, chat.ID).Scan(&count); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Fatalf("messages = %d, want 1", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPostgresUnreachable(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
||||
defer cancel()
|
||||
_, err := Open(ctx, "postgres://messenger:secret@127.0.0.1:1/messenger?sslmode=disable&connect_timeout=1", 1)
|
||||
if err == nil {
|
||||
t.Fatal("closed port was accepted")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,415 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrConflict = errors.New("conflict")
|
||||
ErrIdempotencyMismatch = errors.New("idempotency mismatch")
|
||||
ErrNotFound = errors.New("not found")
|
||||
ErrInvalid = errors.New("invalid")
|
||||
ErrBadCursor = errors.New("bad cursor")
|
||||
ErrUnavailable = errors.New("unavailable")
|
||||
ErrNotReady = errors.New("attachment not ready")
|
||||
)
|
||||
|
||||
// User — публичная карточка. Хеш пароля в неё не входит.
|
||||
type User struct {
|
||||
ID string
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// Chat — неизменяемый состав участников.
|
||||
type Chat struct {
|
||||
ID string
|
||||
Title string
|
||||
MemberIDs []string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// Message — подтверждённое сообщение. Текст после записи не меняется.
|
||||
type Message struct {
|
||||
ID string
|
||||
ChatID string
|
||||
SenderID string
|
||||
Text string
|
||||
CreatedAt time.Time
|
||||
AttachmentIDs []string
|
||||
}
|
||||
|
||||
// Attachment — метаданные файла. ObjectKey наружу API не отдаётся.
|
||||
type Attachment struct {
|
||||
ID string
|
||||
ChatID string
|
||||
OwnerID string
|
||||
Filename string
|
||||
ContentType string
|
||||
SizeBytes int64
|
||||
SHA256 string
|
||||
ObjectKey string
|
||||
Width int
|
||||
Height int
|
||||
Status string
|
||||
CreatedAt time.Time
|
||||
UpdatedAt time.Time
|
||||
}
|
||||
|
||||
// AttachmentRef — строка для сверки с bucket.
|
||||
type AttachmentRef struct {
|
||||
ID string
|
||||
ObjectKey string
|
||||
CreatedAt time.Time
|
||||
Referenced bool
|
||||
}
|
||||
|
||||
// Cursor — позиция keyset (created_at, id). Пустые поля означают первую страницу.
|
||||
type Cursor struct {
|
||||
ID string
|
||||
At time.Time
|
||||
}
|
||||
|
||||
// Repository — пользователи, чаты и сообщения. Сессии сюда не входят.
|
||||
type Repository interface {
|
||||
Ping(ctx context.Context) error
|
||||
CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error)
|
||||
User(ctx context.Context, id string) (User, error)
|
||||
UserByUsername(ctx context.Context, username string) (User, string, error)
|
||||
CreateChat(ctx context.Context, title string, memberIDs []string, caller string) (Chat, error)
|
||||
ChatFor(ctx context.Context, chatID, userID string) (Chat, error)
|
||||
ListChats(ctx context.Context, userID string, cur *Cursor, limit int) ([]Chat, bool, error)
|
||||
// AddMessage создаёт сообщение или возвращает уже записанное для того же ключа.
|
||||
// fingerprint — каноническое тело. Другой fingerprint при живом ключе даёт ErrIdempotencyMismatch.
|
||||
// Ключ живёт idempotencyTTL. Область: отправитель + чат + ключ (метод POST и путь чата).
|
||||
// Чужое или неизвестное вложение — ErrNotFound. Неготовое — ErrNotReady.
|
||||
AddMessage(ctx context.Context, chatID, senderID, text string, attachmentIDs []string, idemKey, fingerprint string) (Message, error)
|
||||
ListMessages(ctx context.Context, chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error)
|
||||
InsertAttachment(ctx context.Context, row Attachment) (Attachment, error)
|
||||
AttachmentVisible(ctx context.Context, id, userID string) (Attachment, error)
|
||||
AttachmentRefs(ctx context.Context) ([]AttachmentRef, error)
|
||||
DeleteUnreferencedAttachment(ctx context.Context, id string, olderThan time.Time) (bool, error)
|
||||
}
|
||||
|
||||
type chatRec struct {
|
||||
chat Chat
|
||||
members map[string]struct{}
|
||||
}
|
||||
|
||||
type idemRec struct {
|
||||
fingerprint string
|
||||
messageID string
|
||||
expires time.Time
|
||||
}
|
||||
|
||||
// Memory сериализует записи мьютексом. Это двойник контракта для тестов без PostgreSQL.
|
||||
type Memory struct {
|
||||
mu sync.RWMutex
|
||||
users map[string]User
|
||||
byName map[string]string
|
||||
hashes map[string]string
|
||||
chats map[string]*chatRec
|
||||
chatOrder []string
|
||||
messages map[string][]Message
|
||||
msgIndex map[string]map[string]int
|
||||
attachments map[string]Attachment
|
||||
referenced map[string]struct{}
|
||||
idem map[string]idemRec
|
||||
idemTTL time.Duration
|
||||
last time.Time
|
||||
}
|
||||
|
||||
func New() *Memory {
|
||||
return &Memory{
|
||||
users: make(map[string]User),
|
||||
byName: make(map[string]string),
|
||||
hashes: make(map[string]string),
|
||||
chats: make(map[string]*chatRec),
|
||||
messages: make(map[string][]Message),
|
||||
msgIndex: make(map[string]map[string]int),
|
||||
attachments: make(map[string]Attachment),
|
||||
referenced: make(map[string]struct{}),
|
||||
idem: make(map[string]idemRec),
|
||||
idemTTL: 24 * time.Hour,
|
||||
}
|
||||
}
|
||||
|
||||
// SetIdempotencyTTL меняет срок ключа. Нужен тестам; в PostgreSQL тот же смысл у IDEMPOTENCY_TTL_SECONDS.
|
||||
func (s *Memory) SetIdempotencyTTL(d time.Duration) {
|
||||
if d <= 0 {
|
||||
return
|
||||
}
|
||||
s.mu.Lock()
|
||||
s.idemTTL = d
|
||||
s.mu.Unlock()
|
||||
}
|
||||
|
||||
func (s *Memory) Ping(ctx context.Context) error {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Memory) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return User{}, ErrUnavailable
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if _, ok := s.byName[username]; ok {
|
||||
return User{}, ErrConflict
|
||||
}
|
||||
u := User{
|
||||
ID: newID(),
|
||||
Username: username,
|
||||
DisplayName: displayName,
|
||||
CreatedAt: s.nextTimeLocked(),
|
||||
}
|
||||
s.users[u.ID] = u
|
||||
s.byName[username] = u.ID
|
||||
s.hashes[u.ID] = passwordHash
|
||||
return u, nil
|
||||
}
|
||||
|
||||
func (s *Memory) User(ctx context.Context, id string) (User, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return User{}, ErrUnavailable
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
u, ok := s.users[id]
|
||||
if !ok {
|
||||
return User{}, ErrNotFound
|
||||
}
|
||||
return u, nil
|
||||
}
|
||||
|
||||
func (s *Memory) UserByUsername(ctx context.Context, username string) (User, string, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return User{}, "", ErrUnavailable
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
id, ok := s.byName[username]
|
||||
if !ok {
|
||||
return User{}, "", ErrNotFound
|
||||
}
|
||||
return s.users[id], s.hashes[id], nil
|
||||
}
|
||||
|
||||
func (s *Memory) CreateChat(ctx context.Context, title string, memberIDs []string, caller string) (Chat, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Chat{}, ErrUnavailable
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
seen := make(map[string]struct{}, len(memberIDs))
|
||||
for _, id := range memberIDs {
|
||||
if _, dup := seen[id]; dup {
|
||||
return Chat{}, ErrInvalid
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
if _, ok := s.users[id]; !ok {
|
||||
return Chat{}, ErrInvalid
|
||||
}
|
||||
}
|
||||
if _, ok := seen[caller]; !ok {
|
||||
return Chat{}, ErrInvalid
|
||||
}
|
||||
c := Chat{
|
||||
ID: newID(),
|
||||
Title: title,
|
||||
MemberIDs: append([]string(nil), memberIDs...),
|
||||
CreatedAt: s.nextTimeLocked(),
|
||||
}
|
||||
s.chats[c.ID] = &chatRec{chat: c, members: seen}
|
||||
s.chatOrder = append(s.chatOrder, c.ID)
|
||||
s.messages[c.ID] = nil
|
||||
s.msgIndex[c.ID] = make(map[string]int)
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (s *Memory) ChatFor(ctx context.Context, chatID, userID string) (Chat, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Chat{}, ErrUnavailable
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
rec, ok := s.chats[chatID]
|
||||
if !ok {
|
||||
return Chat{}, ErrNotFound
|
||||
}
|
||||
if _, member := rec.members[userID]; !member {
|
||||
return Chat{}, ErrNotFound
|
||||
}
|
||||
return rec.chat.clone(), nil
|
||||
}
|
||||
|
||||
func (s *Memory) ListChats(ctx context.Context, userID string, cur *Cursor, limit int) ([]Chat, bool, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return nil, false, ErrUnavailable
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
filtered := make([]Chat, 0)
|
||||
for _, id := range s.chatOrder {
|
||||
rec := s.chats[id]
|
||||
if _, ok := rec.members[userID]; ok {
|
||||
filtered = append(filtered, rec.chat.clone())
|
||||
}
|
||||
}
|
||||
start, err := indexAfter(filtered, cur, func(c Chat) (string, time.Time) {
|
||||
return c.ID, c.CreatedAt
|
||||
})
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
end := start + limit
|
||||
if end > len(filtered) {
|
||||
end = len(filtered)
|
||||
}
|
||||
return append([]Chat(nil), filtered[start:end]...), end < len(filtered), nil
|
||||
}
|
||||
|
||||
func (s *Memory) AddMessage(ctx context.Context, chatID, senderID, text string, attachmentIDs []string, idemKey, fingerprint string) (Message, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return Message{}, ErrUnavailable
|
||||
}
|
||||
if idemKey == "" || fingerprint == "" {
|
||||
return Message{}, ErrInvalid
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
rec, ok := s.chats[chatID]
|
||||
if !ok {
|
||||
return Message{}, ErrNotFound
|
||||
}
|
||||
if _, member := rec.members[senderID]; !member {
|
||||
return Message{}, ErrNotFound
|
||||
}
|
||||
slot := senderID + "\x00" + chatID + "\x00" + idemKey
|
||||
if prev, ok := s.idem[slot]; ok && prev.expires.After(time.Now()) {
|
||||
if prev.fingerprint != fingerprint {
|
||||
return Message{}, ErrIdempotencyMismatch
|
||||
}
|
||||
idx, ok := s.msgIndex[chatID][prev.messageID]
|
||||
if !ok {
|
||||
return Message{}, ErrNotFound
|
||||
}
|
||||
return s.messages[chatID][idx], nil
|
||||
}
|
||||
ids := append([]string(nil), attachmentIDs...)
|
||||
for _, id := range ids {
|
||||
row, ok := s.attachments[id]
|
||||
if !ok || row.ChatID != chatID {
|
||||
return Message{}, ErrNotFound
|
||||
}
|
||||
if row.Status != "ready" {
|
||||
return Message{}, ErrNotReady
|
||||
}
|
||||
}
|
||||
m := Message{
|
||||
ID: newID(),
|
||||
ChatID: chatID,
|
||||
SenderID: senderID,
|
||||
Text: text,
|
||||
CreatedAt: s.nextTimeLocked(),
|
||||
AttachmentIDs: ids,
|
||||
}
|
||||
if m.AttachmentIDs == nil {
|
||||
m.AttachmentIDs = []string{}
|
||||
}
|
||||
idx := len(s.messages[chatID])
|
||||
s.messages[chatID] = append(s.messages[chatID], m)
|
||||
s.msgIndex[chatID][m.ID] = idx
|
||||
s.idem[slot] = idemRec{fingerprint: fingerprint, messageID: m.ID, expires: time.Now().Add(s.idemTTL)}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (s *Memory) ListMessages(ctx context.Context, chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return nil, false, ErrUnavailable
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
rec, ok := s.chats[chatID]
|
||||
if !ok {
|
||||
return nil, false, ErrNotFound
|
||||
}
|
||||
if _, member := rec.members[userID]; !member {
|
||||
return nil, false, ErrNotFound
|
||||
}
|
||||
all := s.messages[chatID]
|
||||
start := 0
|
||||
if cur != nil {
|
||||
idx, ok := s.msgIndex[chatID][cur.ID]
|
||||
if !ok || !all[idx].CreatedAt.Equal(cur.At) {
|
||||
return nil, false, ErrBadCursor
|
||||
}
|
||||
start = idx + 1
|
||||
}
|
||||
end := start + limit
|
||||
if end > len(all) {
|
||||
end = len(all)
|
||||
}
|
||||
out := append([]Message(nil), all[start:end]...)
|
||||
return out, end < len(all), nil
|
||||
}
|
||||
|
||||
// nextTimeLocked выдаёт неубывающее время фиксации.
|
||||
func (s *Memory) nextTimeLocked() time.Time {
|
||||
now := time.Now().UTC().Truncate(time.Microsecond)
|
||||
if !now.After(s.last) {
|
||||
now = s.last.Add(time.Microsecond)
|
||||
}
|
||||
s.last = now
|
||||
return now
|
||||
}
|
||||
|
||||
func indexAfter[T any](items []T, cur *Cursor, key func(T) (string, time.Time)) (int, error) {
|
||||
if cur == nil {
|
||||
return 0, nil
|
||||
}
|
||||
for i, item := range items {
|
||||
id, at := key(item)
|
||||
if id == cur.ID {
|
||||
if !at.Equal(cur.At) {
|
||||
return 0, ErrBadCursor
|
||||
}
|
||||
return i + 1, nil
|
||||
}
|
||||
}
|
||||
return 0, ErrBadCursor
|
||||
}
|
||||
|
||||
func (c Chat) clone() Chat {
|
||||
c.MemberIDs = append([]string(nil), c.MemberIDs...)
|
||||
return c
|
||||
}
|
||||
|
||||
func newID() string {
|
||||
var b [16]byte
|
||||
if _, err := rand.Read(b[:]); err != nil {
|
||||
panic("crypto/rand: " + err.Error())
|
||||
}
|
||||
b[6] = (b[6] & 0x0f) | 0x40
|
||||
b[8] = (b[8] & 0x3f) | 0x80
|
||||
var buf [36]byte
|
||||
hex.Encode(buf[0:8], b[0:4])
|
||||
buf[8] = '-'
|
||||
hex.Encode(buf[9:13], b[4:6])
|
||||
buf[13] = '-'
|
||||
hex.Encode(buf[14:18], b[6:8])
|
||||
buf[18] = '-'
|
||||
hex.Encode(buf[19:23], b[8:10])
|
||||
buf[23] = '-'
|
||||
hex.Encode(buf[24:36], b[10:16])
|
||||
return string(buf[:])
|
||||
}
|
||||
@@ -0,0 +1,309 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"strconv"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"encoding/json"
|
||||
|
||||
"messenger/internal/api"
|
||||
"messenger/internal/blob"
|
||||
"messenger/internal/bootstrap"
|
||||
"messenger/internal/config"
|
||||
"messenger/internal/migrate"
|
||||
"messenger/internal/password"
|
||||
"messenger/internal/reconcile"
|
||||
"messenger/internal/session"
|
||||
"messenger/internal/store"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if len(os.Args) > 1 {
|
||||
switch os.Args[1] {
|
||||
case "healthcheck":
|
||||
os.Exit(runHealthcheck())
|
||||
case "migrate":
|
||||
os.Exit(runMigrate())
|
||||
case "reconcile":
|
||||
os.Exit(runReconcile(os.Args[2:]))
|
||||
case "bootstrap-s3":
|
||||
os.Exit(runBootstrap())
|
||||
case "s3-put":
|
||||
os.Exit(runS3Put(os.Args[2:]))
|
||||
case "s3-rm":
|
||||
os.Exit(runS3Remove(os.Args[2:]))
|
||||
}
|
||||
}
|
||||
|
||||
// Инициализация
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
slog.Error("config", "err", err.Error())
|
||||
os.Exit(2)
|
||||
}
|
||||
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
|
||||
root, stop := context.WithTimeout(context.Background(), 20*time.Second)
|
||||
pg, err := store.Open(root, cfg.DatabaseURL, cfg.DBMaxConns)
|
||||
if err != nil {
|
||||
stop()
|
||||
log.Error("postgres", "err", "connect failed")
|
||||
os.Exit(1)
|
||||
}
|
||||
defer pg.Close()
|
||||
pg.SetIdempotencyTTL(cfg.IdempotencyTTL)
|
||||
sessions, err := session.OpenRedis(cfg.RedisURL)
|
||||
if err != nil {
|
||||
stop()
|
||||
log.Error("redis", "err", "config failed")
|
||||
os.Exit(1)
|
||||
}
|
||||
defer sessions.Close()
|
||||
if err := sessions.Ping(root); err != nil {
|
||||
stop()
|
||||
log.Error("redis", "err", "ping failed")
|
||||
os.Exit(1)
|
||||
}
|
||||
objects, err := blob.Open(cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, cfg.S3AccessKey, cfg.S3SecretKey)
|
||||
if err != nil {
|
||||
stop()
|
||||
log.Error("s3", "err", "config failed")
|
||||
os.Exit(1)
|
||||
}
|
||||
if err := objects.Ping(root); err != nil {
|
||||
stop()
|
||||
log.Error("s3", "err", "bucket unavailable")
|
||||
os.Exit(1)
|
||||
}
|
||||
stop()
|
||||
instanceID := cfg.InstanceID
|
||||
if instanceID == "" {
|
||||
instanceID, err = os.Hostname()
|
||||
if err != nil || instanceID == "" {
|
||||
log.Error("hostname")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
application := api.New(pg, sessions, password.Params{
|
||||
Time: cfg.Argon2Time,
|
||||
Memory: cfg.Argon2Memory,
|
||||
Threads: cfg.Argon2Threads,
|
||||
}, cfg.SessionTTL, instanceID, log)
|
||||
application.EnableAttachments(objects, cfg.MaxUploadBytes, cfg.MaxImagePixels)
|
||||
// http сервер
|
||||
srv := &http.Server{
|
||||
Addr: cfg.Addr(),
|
||||
Handler: application,
|
||||
ReadHeaderTimeout: 5 * time.Second,
|
||||
ReadTimeout: 120 * time.Second,
|
||||
WriteTimeout: 120 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
MaxHeaderBytes: 1 << 20,
|
||||
}
|
||||
|
||||
// Запуск сервера
|
||||
errCh := make(chan error, 1)
|
||||
go func() {
|
||||
log.Info("listening",
|
||||
"addr", cfg.Addr(),
|
||||
"env", cfg.Env,
|
||||
"instance_id", instanceID,
|
||||
"shutdown_timeout_seconds", int(cfg.ShutdownTimeout/time.Second),
|
||||
)
|
||||
err := srv.ListenAndServe()
|
||||
if err != nil && !errors.Is(err, http.ErrServerClosed) {
|
||||
errCh <- err
|
||||
}
|
||||
close(errCh)
|
||||
}()
|
||||
|
||||
// Ожидание сигнала или ошибки
|
||||
sig := make(chan os.Signal, 1)
|
||||
signal.Notify(sig, syscall.SIGTERM, syscall.SIGINT)
|
||||
select {
|
||||
case err := <-errCh:
|
||||
log.Error("server", "err", err.Error())
|
||||
os.Exit(1)
|
||||
case <-sig:
|
||||
}
|
||||
|
||||
// Плавное завершение
|
||||
application.BeginShutdown()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout)
|
||||
defer cancel()
|
||||
if err := srv.Shutdown(ctx); err != nil {
|
||||
log.Error("shutdown timeout, closing listener", "err", err.Error())
|
||||
_ = srv.Close()
|
||||
}
|
||||
log.Info("shutdown complete")
|
||||
}
|
||||
|
||||
func runMigrate() int {
|
||||
db := os.Getenv("DATABASE_URL")
|
||||
if db == "" {
|
||||
slog.Error("migrate", "err", "DATABASE_URL is required")
|
||||
return 2
|
||||
}
|
||||
log := slog.New(slog.NewJSONHandler(os.Stdout, nil))
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
pg, err := store.Open(ctx, db, 2)
|
||||
if err != nil {
|
||||
log.Error("migrate", "err", "connect failed")
|
||||
return 1
|
||||
}
|
||||
defer pg.Close()
|
||||
if err := migrate.Apply(ctx, pg.Pool()); err != nil {
|
||||
log.Error("migrate", "err", "apply failed")
|
||||
return 1
|
||||
}
|
||||
log.Info("migrate complete")
|
||||
return 0
|
||||
}
|
||||
|
||||
func runReconcile(args []string) int {
|
||||
apply := false
|
||||
for _, arg := range args {
|
||||
if arg == "--apply" {
|
||||
apply = true
|
||||
continue
|
||||
}
|
||||
slog.Error("reconcile", "err", "usage: reconcile [--apply]")
|
||||
return 2
|
||||
}
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
slog.Error("config", "err", err.Error())
|
||||
return 2
|
||||
}
|
||||
log := slog.New(slog.NewJSONHandler(os.Stderr, nil))
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
pg, err := store.Open(ctx, cfg.DatabaseURL, 2)
|
||||
if err != nil {
|
||||
log.Error("postgres", "err", "connect failed")
|
||||
return 1
|
||||
}
|
||||
defer pg.Close()
|
||||
objects, err := blob.Open(cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, cfg.S3AccessKey, cfg.S3SecretKey)
|
||||
if err != nil {
|
||||
log.Error("s3", "err", "config failed")
|
||||
return 1
|
||||
}
|
||||
summary, err := reconcile.Run(ctx, pg, objects, cfg.ReconcileGrace, apply)
|
||||
if err != nil {
|
||||
log.Error("reconcile", "err", "run failed")
|
||||
return 1
|
||||
}
|
||||
enc := json.NewEncoder(os.Stdout)
|
||||
enc.SetIndent("", " ")
|
||||
if err := enc.Encode(summary); err != nil {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func runBootstrap() int {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
|
||||
defer cancel()
|
||||
err := bootstrap.Bucket(ctx,
|
||||
os.Getenv("S3_ENDPOINT"),
|
||||
os.Getenv("S3_REGION"),
|
||||
os.Getenv("S3_BUCKET"),
|
||||
os.Getenv("MINIO_ROOT_USER"),
|
||||
os.Getenv("MINIO_ROOT_PASSWORD"),
|
||||
os.Getenv("S3_ACCESS_KEY"),
|
||||
os.Getenv("S3_SECRET_KEY"),
|
||||
)
|
||||
if err != nil {
|
||||
slog.Error("bootstrap-s3", "err", err.Error())
|
||||
return 1
|
||||
}
|
||||
slog.Info("bootstrap-s3 complete")
|
||||
return 0
|
||||
}
|
||||
|
||||
func runS3Put(args []string) int {
|
||||
if len(args) != 1 || args[0] == "" {
|
||||
slog.Error("s3-put", "err", "usage: s3-put <object-key>")
|
||||
return 2
|
||||
}
|
||||
body, err := io.ReadAll(io.LimitReader(os.Stdin, 10*1024*1024+1))
|
||||
if err != nil || len(body) == 0 || len(body) > 10*1024*1024 {
|
||||
slog.Error("s3-put", "err", "body")
|
||||
return 2
|
||||
}
|
||||
objects, err := openS3()
|
||||
if err != nil {
|
||||
slog.Error("s3-put", "err", "config")
|
||||
return 1
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
if err := objects.Put(ctx, args[0], "application/octet-stream", body); err != nil {
|
||||
slog.Error("s3-put", "err", "put failed")
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func runS3Remove(args []string) int {
|
||||
if len(args) != 1 || args[0] == "" {
|
||||
slog.Error("s3-rm", "err", "usage: s3-rm <object-key>")
|
||||
return 2
|
||||
}
|
||||
objects, err := openS3()
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
if err := objects.Delete(ctx, args[0]); err != nil {
|
||||
slog.Error("s3-rm", "err", "delete failed")
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func openS3() (*blob.S3, error) {
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
slog.Error("config", "err", err.Error())
|
||||
return nil, err
|
||||
}
|
||||
return blob.Open(cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, cfg.S3AccessKey, cfg.S3SecretKey)
|
||||
}
|
||||
|
||||
func runHealthcheck() int {
|
||||
port := os.Getenv("APP_PORT")
|
||||
if port == "" {
|
||||
port = "8080"
|
||||
}
|
||||
n, err := strconv.Atoi(port)
|
||||
if err != nil || n < 1 || n > 65535 {
|
||||
return 1
|
||||
}
|
||||
client := http.Client{Timeout: 2 * time.Second}
|
||||
req, err := http.NewRequest(http.MethodGet, "http://"+net.JoinHostPort("127.0.0.1", port)+"/health/ready", nil)
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
_, _ = io.Copy(io.Discard, resp.Body)
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
-- Пользователи, чаты, состав и сообщения. PostgreSQL — источник истины.
|
||||
-- Сессии здесь не хранятся: их держит Redis с AOF.
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT users_username_unique UNIQUE (username),
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100),
|
||||
CONSTRAINT users_password_hash_present CHECK (char_length(password_hash) > 0)
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
-- Список чатов пользователя идёт по (created_at, id).
|
||||
CREATE INDEX chats_list_idx ON chats (created_at, id);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
position integer NOT NULL,
|
||||
PRIMARY KEY (chat_id, user_id),
|
||||
CONSTRAINT chat_members_position_nonneg CHECK (position >= 0),
|
||||
CONSTRAINT chat_members_position_unique UNIQUE (chat_id, position)
|
||||
);
|
||||
|
||||
-- Обратный поиск: чаты конкретного пользователя.
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
|
||||
);
|
||||
|
||||
-- Keyset-страница истории: WHERE chat_id = $1 AND (created_at, id) > cursor
|
||||
-- ORDER BY created_at, id LIMIT n. Индекс покрывает фильтр и порядок,
|
||||
-- поэтому страница не читает всю историю чата.
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,18 @@
|
||||
-- Общая идемпотентность POST сообщения. Область: пользователь + чат + ключ.
|
||||
-- Строка пишется в той же транзакции, что и сообщение, поэтому 5xx не оставляет
|
||||
-- «занятый» ключ без сообщения и не оставляет сообщение без ключа.
|
||||
-- Повтор с тем же текстом читает message_id. Другой текст — конфликт на уровне API.
|
||||
|
||||
CREATE TABLE message_idempotency (
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
idem_key text NOT NULL,
|
||||
fingerprint text NOT NULL,
|
||||
message_id uuid NOT NULL REFERENCES messages (id),
|
||||
created_at timestamptz NOT NULL,
|
||||
expires_at timestamptz NOT NULL,
|
||||
PRIMARY KEY (user_id, chat_id, idem_key),
|
||||
CONSTRAINT message_idempotency_key_len CHECK (char_length(idem_key) BETWEEN 1 AND 128),
|
||||
CONSTRAINT message_idempotency_fingerprint_present CHECK (char_length(fingerprint) > 0),
|
||||
CONSTRAINT message_idempotency_expiry CHECK (expires_at > created_at)
|
||||
);
|
||||
@@ -0,0 +1,42 @@
|
||||
-- Метаданные вложения живут в PostgreSQL, байты — в приватном bucket.
|
||||
-- object_key назначает сервер. filename только для показа и не входит в ключ.
|
||||
|
||||
ALTER TABLE messages DROP CONSTRAINT messages_text_len;
|
||||
ALTER TABLE messages ADD CONSTRAINT messages_text_len CHECK (char_length(text) <= 4000);
|
||||
|
||||
CREATE TABLE attachments (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
owner_id uuid NOT NULL REFERENCES users (id),
|
||||
filename text NOT NULL,
|
||||
content_type text NOT NULL,
|
||||
size_bytes bigint NOT NULL,
|
||||
sha256 text NOT NULL,
|
||||
object_key text NOT NULL,
|
||||
width integer NOT NULL,
|
||||
height integer NOT NULL,
|
||||
status text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
updated_at timestamptz NOT NULL,
|
||||
CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255),
|
||||
CONSTRAINT attachments_content_type CHECK (content_type IN ('image/png', 'image/jpeg')),
|
||||
CONSTRAINT attachments_size CHECK (size_bytes BETWEEN 1 AND 10485760),
|
||||
CONSTRAINT attachments_sha CHECK (sha256 ~ '^[a-f0-9]{64}$'),
|
||||
CONSTRAINT attachments_status CHECK (status = 'ready'),
|
||||
CONSTRAINT attachments_dimensions CHECK (width >= 1 AND height >= 1),
|
||||
CONSTRAINT attachments_object_key_unique UNIQUE (object_key)
|
||||
);
|
||||
|
||||
CREATE INDEX attachments_chat_idx ON attachments (chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE message_attachments (
|
||||
message_id uuid NOT NULL REFERENCES messages (id),
|
||||
attachment_id uuid NOT NULL REFERENCES attachments (id),
|
||||
position integer NOT NULL,
|
||||
PRIMARY KEY (message_id, position),
|
||||
CONSTRAINT message_attachments_position_nonneg CHECK (position >= 0),
|
||||
CONSTRAINT message_attachments_unique UNIQUE (message_id, attachment_id)
|
||||
);
|
||||
|
||||
-- Сверка и проверка «файл уже прикреплён» не сканируют всю историю.
|
||||
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id);
|
||||
@@ -0,0 +1,7 @@
|
||||
// хранит версионируемые SQL-файлы внутри бинарника.
|
||||
package migrations
|
||||
|
||||
import "embed"
|
||||
|
||||
//go:embed *.sql
|
||||
var FS embed.FS
|
||||
Executable
+83
@@ -0,0 +1,83 @@
|
||||
#!/bin/sh
|
||||
# Отказ Redis и PostgreSQL: анонимный запрос остаётся 401, живой Bearer не становится доверенным.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
mkdir -p evidence
|
||||
OUT=evidence/dependencies.txt
|
||||
: > "$OUT"
|
||||
log() { printf '%s\n' "$1" | tee -a "$OUT"; }
|
||||
|
||||
code_of() {
|
||||
# $1 name, $2 expected, $3 url, optional header in $4
|
||||
if [ "$#" -eq 4 ]; then
|
||||
got=$(curl -sS -o /tmp/lab2_dep_body -w '%{http_code}' -H "$4" "$3")
|
||||
else
|
||||
got=$(curl -sS -o /tmp/lab2_dep_body -w '%{http_code}' "$3")
|
||||
fi
|
||||
log "$1 $got"
|
||||
if [ "$got" != "$2" ]; then
|
||||
log "FAIL $1 want $2"
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
wait_ready() {
|
||||
i=0
|
||||
while [ "$i" -lt 90 ]; do
|
||||
if curl -sf -o /dev/null http://127.0.0.1:8080/health/ready; then
|
||||
return 0
|
||||
fi
|
||||
i=$((i + 1))
|
||||
sleep 0.5
|
||||
done
|
||||
log "FAIL ready did not return"
|
||||
exit 1
|
||||
}
|
||||
|
||||
trap 'rm -f /tmp/lab2_user.json /tmp/lab2_login.json /tmp/lab2_dep_body' EXIT
|
||||
wait_ready
|
||||
user="dep$(date +%s)"
|
||||
pass="Dep-check-$(date +%s)-xxxx"
|
||||
reg=$(curl -sS -o /tmp/lab2_user.json -w '%{http_code}' \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d "{\"username\":\"$user\",\"display_name\":\"Зависимость\",\"password\":\"$pass\"}" \
|
||||
http://127.0.0.1:8080/api/v1/users)
|
||||
if [ "$reg" != "201" ]; then
|
||||
log "FAIL register $reg"
|
||||
exit 1
|
||||
fi
|
||||
basic=$(printf '%s' "$user:$pass" | base64 -w 0)
|
||||
login=$(curl -sS -o /tmp/lab2_login.json -w '%{http_code}' \
|
||||
-X POST \
|
||||
-H "Authorization: Basic $basic" \
|
||||
http://127.0.0.1:8080/api/v1/auth/sessions)
|
||||
if [ "$login" != "201" ]; then
|
||||
log "FAIL login $login"
|
||||
exit 1
|
||||
fi
|
||||
token=$(python3 -c 'import json; print(json.load(open("/tmp/lab2_login.json"))["token"])')
|
||||
|
||||
log "stop redis"
|
||||
docker compose --env-file .env stop redis >> "$OUT"
|
||||
code_of live_redis_down 200 http://127.0.0.1:8080/health/live
|
||||
code_of ready_redis_down 503 http://127.0.0.1:8080/health/ready
|
||||
code_of anon_redis_down 401 http://127.0.0.1:8080/api/v1/users/me
|
||||
code_of bearer_redis_down 503 http://127.0.0.1:8080/api/v1/users/me "Authorization: Bearer $token"
|
||||
|
||||
log "start redis"
|
||||
docker compose --env-file .env start redis >> "$OUT"
|
||||
wait_ready
|
||||
|
||||
log "stop postgres"
|
||||
docker compose --env-file .env stop postgres >> "$OUT"
|
||||
code_of live_pg_down 200 http://127.0.0.1:8080/health/live
|
||||
code_of ready_pg_down 503 http://127.0.0.1:8080/health/ready
|
||||
code_of anon_pg_down 401 http://127.0.0.1:8080/api/v1/users/me
|
||||
code_of bearer_pg_down 503 http://127.0.0.1:8080/api/v1/users/me "Authorization: Bearer $token"
|
||||
|
||||
log "start postgres"
|
||||
docker compose --env-file .env start postgres >> "$OUT"
|
||||
wait_ready
|
||||
code_of bearer_after 200 http://127.0.0.1:8080/api/v1/users/me "Authorization: Bearer $token"
|
||||
log "PASS dependencies"
|
||||
rm -f /tmp/lab2_user.json /tmp/lab2_login.json /tmp/lab2_login_hdr /tmp/lab2_dep_body
|
||||
Executable
+143
@@ -0,0 +1,143 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Поочерёдный отказ каждой API-реплики и гонка одного Idempotency-Key."""
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "tests"))
|
||||
from client import Client, Failure # noqa: E402
|
||||
|
||||
|
||||
def compose(*args):
|
||||
subprocess.check_call(["docker", "compose", "--env-file", ".env", *args], cwd=ROOT)
|
||||
|
||||
|
||||
def instances(samples=40):
|
||||
client = Client("http://127.0.0.1:8080", timeout=2)
|
||||
found = []
|
||||
deadline = time.monotonic() + 60
|
||||
while time.monotonic() < deadline:
|
||||
found = []
|
||||
seen = set()
|
||||
try:
|
||||
for _ in range(samples):
|
||||
item = client.call("GET", "/health/live", schema="Health")["headers"]["X-Instance-Id"]
|
||||
if item not in seen:
|
||||
seen.add(item)
|
||||
found.append(item)
|
||||
if len(found) >= 2:
|
||||
return found
|
||||
except Failure:
|
||||
pass
|
||||
time.sleep(1)
|
||||
raise SystemExit("expected at least two API instances, saw " + ",".join(found))
|
||||
|
||||
|
||||
def restore_api():
|
||||
compose("up", "-d", "--no-deps", "api")
|
||||
ids = subprocess.check_output(
|
||||
["docker", "compose", "--env-file", ".env", "ps", "-aq", "api"], cwd=ROOT, text=True
|
||||
).split()
|
||||
if ids:
|
||||
subprocess.check_call(["docker", "start", *ids], cwd=ROOT)
|
||||
instances()
|
||||
|
||||
|
||||
def stop_and_measure(target):
|
||||
client = Client("http://127.0.0.1:8080", timeout=2)
|
||||
alice, _bob, _eve, chat = client.bootstrap()
|
||||
end = time.monotonic() + 12
|
||||
stats = {"ok": 0, "fail": 0, "after_ok": 0, "target_after_stop": 0, "first_recovery_s": None}
|
||||
started = {}
|
||||
stopped = {}
|
||||
|
||||
def worker():
|
||||
local = Client("http://127.0.0.1:8080", timeout=2)
|
||||
while time.monotonic() < end:
|
||||
key = uuid.uuid4().hex
|
||||
try:
|
||||
response = local.message(alice, chat, "отказ " + key, key=key)
|
||||
stats["ok"] += 1
|
||||
mark = started.get("at")
|
||||
if mark is not None and stats["first_recovery_s"] is None:
|
||||
stats["first_recovery_s"] = round(time.monotonic() - mark, 3)
|
||||
if stopped.get("at") is not None:
|
||||
stats["after_ok"] += 1
|
||||
if response["headers"].get("X-Instance-Id") == target:
|
||||
stats["target_after_stop"] += 1
|
||||
except Failure:
|
||||
stats["fail"] += 1
|
||||
|
||||
threads = [threading.Thread(target=worker) for _ in range(4)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
time.sleep(2)
|
||||
started["at"] = time.monotonic()
|
||||
env = os.environ.copy()
|
||||
env["TARGET_INSTANCE_ID"] = target
|
||||
proc = subprocess.run([str(ROOT / "scripts" / "stop-one.sh")], cwd=ROOT, env=env, text=True, capture_output=True)
|
||||
stopped["at"] = time.monotonic()
|
||||
stats["hook_exit"] = proc.returncode
|
||||
stats["hook_seconds"] = round(stopped["at"] - started["at"], 3)
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
stats["target"] = target
|
||||
stats["successful_rps"] = round(stats["ok"] / 12, 3)
|
||||
return stats
|
||||
|
||||
|
||||
def idempotency_race():
|
||||
client = Client("http://127.0.0.1:8080", timeout=5)
|
||||
alice, bob, _eve, chat = client.bootstrap()
|
||||
key = uuid.uuid4().hex
|
||||
ids = []
|
||||
errors = []
|
||||
|
||||
def once():
|
||||
try:
|
||||
ids.append(Client("http://127.0.0.1:8080", timeout=5).message(alice, chat, "гонка", key=key)["json"]["id"])
|
||||
except Failure as exc:
|
||||
errors.append(str(exc))
|
||||
|
||||
threads = [threading.Thread(target=once) for _ in range(12)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
page = client.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", actor=bob, schema="MessagePage")["json"]
|
||||
texts = [item["text"] for item in page["items"] if item["text"] == "гонка"]
|
||||
return {
|
||||
"parallel_requests": 12,
|
||||
"distinct_ids": len(set(ids)),
|
||||
"successes": len(ids),
|
||||
"errors": errors,
|
||||
"history_copies": len(texts),
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
os.chdir(ROOT)
|
||||
before = instances()
|
||||
runs = []
|
||||
for target in before:
|
||||
runs.append(stop_and_measure(target))
|
||||
restore_api()
|
||||
race = idempotency_race()
|
||||
report = {"instances_before": before, "failover": runs, "idempotency_race": race}
|
||||
dest = ROOT / "evidence" / "grade4.json"
|
||||
dest.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
print(json.dumps(report, ensure_ascii=False, indent=2))
|
||||
if any(item["hook_exit"] != 0 or item["after_ok"] < 1 or item["target_after_stop"] != 0 for item in runs):
|
||||
raise SystemExit("failover measurement failed")
|
||||
if race["distinct_ids"] != 1 or race["history_copies"] != 1 or race["errors"]:
|
||||
raise SystemExit("idempotency race failed")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+5
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
# Перезапуск API, балансировщика и всех хранилищ. Volumes не удаляются, данные не сидируются.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres redis minio api haproxy
|
||||
Executable
+28
@@ -0,0 +1,28 @@
|
||||
#!/bin/sh
|
||||
# Поочерёдная замена контейнеров api. Оставшаяся реплика продолжает принимать трафик.
|
||||
# Новые контейнеры собираются из текущего Dockerfile; старые заменяются по одному.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
scale="${API_REPLICAS:-2}"
|
||||
docker compose --env-file .env build api
|
||||
ids=$(docker compose --env-file .env ps -q api)
|
||||
for id in $ids; do
|
||||
docker stop -t 8 "$id" >/dev/null
|
||||
docker rm "$id" >/dev/null
|
||||
docker compose --env-file .env up -d --no-deps --no-recreate --scale "api=$scale" api >/dev/null
|
||||
ready=0
|
||||
i=0
|
||||
while [ "$i" -lt 40 ]; do
|
||||
if curl -fsS http://127.0.0.1:8080/health/ready >/dev/null; then
|
||||
ready=1
|
||||
break
|
||||
fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
if [ "$ready" -ne 1 ]; then
|
||||
echo "ready did not return after replacing one replica" >&2
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
echo "rolling update finished"
|
||||
Executable
+22
@@ -0,0 +1,22 @@
|
||||
#!/bin/sh
|
||||
# Останавливает одну API-реплику и оставляет её остановленной.
|
||||
# TARGET_INSTANCE_ID — значение X-Instance-Id (hostname контейнера).
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}"
|
||||
target=$(printf '%s' "$TARGET_INSTANCE_ID" | tr -d '[:space:]')
|
||||
found=""
|
||||
for id in $(docker compose --env-file .env ps -q api); do
|
||||
host=$(docker inspect -f '{{.Config.Hostname}}' "$id")
|
||||
full=$(docker inspect -f '{{.Id}}' "$id")
|
||||
short=$(printf '%s' "$full" | cut -c1-12)
|
||||
if [ "$host" = "$target" ] || [ "$short" = "$target" ] || [ "$full" = "$target" ]; then
|
||||
found=$id
|
||||
break
|
||||
fi
|
||||
done
|
||||
if [ -z "$found" ]; then
|
||||
echo "API replica not found" >&2
|
||||
exit 1
|
||||
fi
|
||||
docker stop -t 8 "$found" >/dev/null
|
||||
@@ -0,0 +1,246 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Негативные вложения, приватный bucket, память и трек сверки. Стенд уже запущен."""
|
||||
import json
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
BASE = "http://127.0.0.1:8080"
|
||||
EVIDENCE = ROOT / "evidence"
|
||||
|
||||
|
||||
def req(method, path, body=None, headers=None, content_type=None):
|
||||
data = body if isinstance(body, bytes) else (None if body is None else json.dumps(body).encode())
|
||||
h = dict(headers or {})
|
||||
if content_type:
|
||||
h["Content-Type"] = content_type
|
||||
elif data is not None and not isinstance(body, bytes):
|
||||
h["Content-Type"] = "application/json"
|
||||
request = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=60) as resp:
|
||||
return resp.status, resp.headers, resp.read()
|
||||
except urllib.error.HTTPError as exc:
|
||||
return exc.code, exc.headers, exc.read()
|
||||
|
||||
|
||||
def user(prefix):
|
||||
name = prefix + uuid.uuid4().hex[:8]
|
||||
status, _, raw = req("POST", "/api/v1/users", {"username": name, "display_name": prefix, "password": "correct-horse-1"})
|
||||
assert status == 201, raw
|
||||
body = json.loads(raw)
|
||||
token = basic_session(name, "correct-horse-1")
|
||||
return body, token
|
||||
|
||||
|
||||
def basic_session(username, password):
|
||||
import base64
|
||||
raw = base64.b64encode(f"{username}:{password}".encode()).decode()
|
||||
status, _, body = req("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + raw})
|
||||
assert status == 201, body
|
||||
return json.loads(body)["token"]
|
||||
|
||||
|
||||
def auth(token):
|
||||
return {"Authorization": "Bearer " + token}
|
||||
|
||||
|
||||
def chat(token, title, members):
|
||||
status, _, raw = req("POST", "/api/v1/chats", {"title": title, "member_ids": members}, headers=auth(token))
|
||||
assert status == 201, raw
|
||||
return json.loads(raw)
|
||||
|
||||
|
||||
def upload(token, chat_id, filename, body, content_type="image/png"):
|
||||
return req(
|
||||
"POST",
|
||||
f"/api/v1/chats/{chat_id}/attachments?filename={filename}",
|
||||
body,
|
||||
headers=auth(token),
|
||||
content_type=content_type,
|
||||
)
|
||||
|
||||
|
||||
def psql(sql):
|
||||
out = subprocess.check_output(
|
||||
["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres", "sh", "-c",
|
||||
'psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -At -c ' + json.dumps(sql)],
|
||||
cwd=ROOT, text=True)
|
||||
return [line for line in out.splitlines() if line.strip()]
|
||||
|
||||
|
||||
def s3(cmd, key, body=b""):
|
||||
proc = subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", "run", "--rm", "-T", "--no-deps", "api", cmd, key],
|
||||
cwd=ROOT, input=body, capture_output=True)
|
||||
if proc.returncode != 0:
|
||||
raise SystemExit(proc.stderr.decode()[-500:])
|
||||
|
||||
|
||||
def reconcile(apply=False, grace=5):
|
||||
args = ["docker", "compose", "--env-file", ".env", "run", "--rm", "-T", "--no-deps",
|
||||
"-e", f"RECONCILE_GRACE_SECONDS={grace}", "api", "reconcile"]
|
||||
if apply:
|
||||
args.append("--apply")
|
||||
proc = subprocess.run(args, cwd=ROOT, capture_output=True, text=True)
|
||||
if proc.returncode != 0:
|
||||
raise SystemExit(proc.stderr[-500:])
|
||||
return json.loads(proc.stdout)
|
||||
|
||||
|
||||
def main():
|
||||
EVIDENCE.mkdir(exist_ok=True)
|
||||
png = (ROOT / "tests/fixtures/sample.png").read_bytes()
|
||||
alice, ta = user("alice")
|
||||
bob, tb = user("bob")
|
||||
eve, te = user("eve")
|
||||
room = chat(ta, "негативные", [alice["id"], bob["id"]])
|
||||
other = chat(ta, "чужой", [alice["id"]])
|
||||
lines = []
|
||||
|
||||
def check(name, status, raw, expected):
|
||||
ok = status == expected and b"internal_error" not in raw
|
||||
lines.append(f"{name}: HTTP {status} expected {expected} {'PASS' if ok else 'FAIL'} body={raw[:180]!r}")
|
||||
if not ok:
|
||||
raise SystemExit("\n".join(lines))
|
||||
|
||||
status, _, raw = upload(ta, room["id"], "a/b.png", png)
|
||||
check("slash filename", status, raw, 400)
|
||||
status, _, raw = upload(ta, room["id"], "a\\b.png", png)
|
||||
check("backslash filename", status, raw, 400)
|
||||
status, _, raw = upload(ta, room["id"], "note.png", b"not-an-image")
|
||||
check("text as png", status, raw, 415)
|
||||
status, _, raw = upload(ta, room["id"], "swap.png", b"\xff\xd8\xff\xe0" + b"\x00" * 32, "image/png")
|
||||
check("mime swap", status, raw, 415)
|
||||
status, _, raw = upload(ta, room["id"], "cut.png", png[:80])
|
||||
check("truncated png", status, raw, 415)
|
||||
status, _, raw = upload(ta, room["id"], "big.bin", b"\x00" * (10 * 1024 * 1024 + 1))
|
||||
check("over 10MiB", status, raw, 413)
|
||||
before = psql("SELECT count(*) FROM attachments")[0]
|
||||
status, _, raw = upload(ta, room["id"], "pixels.png", pixel_bomb())
|
||||
check("pixel bomb", status, raw, 413)
|
||||
after = psql("SELECT count(*) FROM attachments")[0]
|
||||
lines.append(f"rejected uploads left attachment rows {before}->{after} {'PASS' if before == after else 'FAIL'}")
|
||||
|
||||
status, _, raw = upload(ta, room["id"], "ok.png", png)
|
||||
check("good upload", status, raw, 201)
|
||||
att = json.loads(raw)
|
||||
status, _, raw = req("POST", f"/api/v1/chats/{room['id']}/messages",
|
||||
{"text": "x", "attachment_ids": [str(uuid.uuid4())]},
|
||||
headers={**auth(ta), "Idempotency-Key": uuid.uuid4().hex})
|
||||
check("unknown attachment", status, raw, 404)
|
||||
status, _, foreign_raw = upload(ta, other["id"], "foreign.png", png)
|
||||
check("other chat upload", status, foreign_raw, 201)
|
||||
foreign = json.loads(foreign_raw)
|
||||
status, _, raw = req("POST", f"/api/v1/chats/{room['id']}/messages",
|
||||
{"text": "", "attachment_ids": [foreign["id"]]},
|
||||
headers={**auth(ta), "Idempotency-Key": uuid.uuid4().hex})
|
||||
check("attachment from other chat", status, raw, 404)
|
||||
status, _, raw = req("GET", f"/api/v1/attachments/{att['id']}/content", headers=auth(te))
|
||||
check("outsider download", status, raw, 404)
|
||||
|
||||
key = psql(f"SELECT object_key FROM attachments WHERE id = '{att['id']}'")[0]
|
||||
code = subprocess.check_output(
|
||||
["curl", "-s", "-o", "/dev/null", "-w", "%{http_code}",
|
||||
f"http://127.0.0.1:9000/messenger-attachments/{key}"], text=True).strip()
|
||||
lines.append(f"anonymous S3 GET {code} {'PASS' if code in ('403', '401') else 'FAIL'}")
|
||||
console = subprocess.run(["curl", "-s", "-o", "/dev/null", "-m", "2", "-w", "%{http_code}", "http://127.0.0.1:9001/"],
|
||||
capture_output=True, text=True)
|
||||
lines.append(f"console on host http_code={console.stdout.strip() or 'no-response'} err={console.returncode}")
|
||||
|
||||
# 10 одновременных загрузок по 1 МиБ мусора: каждая обрезается лимитом чтения, 500 быть не должно.
|
||||
junk = b"\x00" * (1 * 1024 * 1024)
|
||||
codes = []
|
||||
peak = {"mem": 0}
|
||||
|
||||
def one():
|
||||
status, _, _ = upload(ta, room["id"], "junk.png", junk)
|
||||
codes.append(status)
|
||||
|
||||
def sample():
|
||||
end = time.time() + 8
|
||||
while time.time() < end:
|
||||
out = subprocess.check_output(
|
||||
["docker", "stats", "--no-stream", "--format", "{{.Name}} {{.MemUsage}}"], text=True)
|
||||
for line in out.splitlines():
|
||||
if "api" not in line:
|
||||
continue
|
||||
mem = line.split()[1]
|
||||
num = float(mem.replace("MiB", "").replace("GiB", ""))
|
||||
if "GiB" in mem:
|
||||
num *= 1024
|
||||
peak["mem"] = max(peak["mem"], num)
|
||||
time.sleep(0.3)
|
||||
|
||||
sampler = threading.Thread(target=sample)
|
||||
sampler.start()
|
||||
threads = [threading.Thread(target=one) for _ in range(10)]
|
||||
t0 = time.perf_counter()
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
sampler.join()
|
||||
elapsed = time.perf_counter() - t0
|
||||
lines.append(f"10 parallel 1MiB uploads statuses={sorted(codes)} seconds={elapsed:.2f} peak_api_MiB={peak['mem']:.1f}")
|
||||
if any(c == 500 for c in codes) or len(codes) != 10:
|
||||
raise SystemExit("\n".join(lines))
|
||||
|
||||
# Трек 2. grace 5 секунд.
|
||||
status, _, raw = upload(ta, room["id"], "used.png", png)
|
||||
used = json.loads(raw)
|
||||
req("POST", f"/api/v1/chats/{room['id']}/messages",
|
||||
{"text": "", "attachment_ids": [used["id"]]},
|
||||
headers={**auth(ta), "Idempotency-Key": uuid.uuid4().hex})
|
||||
status, _, raw = upload(ta, room["id"], "loose.png", png)
|
||||
loose = json.loads(raw)
|
||||
s3("s3-put", "o/orphan-old", b"orphan-old")
|
||||
time.sleep(6)
|
||||
for row_id in (used["id"], loose["id"]):
|
||||
object_key = psql(f"SELECT object_key FROM attachments WHERE id = '{row_id}'")[0]
|
||||
s3("s3-rm", object_key)
|
||||
status, _, raw = upload(ta, room["id"], "fresh.png", png)
|
||||
fresh = json.loads(raw)
|
||||
s3("s3-put", "o/orphan-fresh", b"orphan-fresh")
|
||||
dry1 = reconcile(False)
|
||||
dry2 = reconcile(False)
|
||||
lines.append("dry-run-1 " + json.dumps(dry1, ensure_ascii=False))
|
||||
lines.append("dry-run-2 same=" + str(dry1["deleted_objects"] == 0 and dry2["deleted_objects"] == 0 and dry1["orphan_stale"] == dry2["orphan_stale"]))
|
||||
applied = reconcile(True)
|
||||
lines.append("apply " + json.dumps(applied, ensure_ascii=False))
|
||||
again = reconcile(True)
|
||||
lines.append("apply-again " + json.dumps({k: again[k] for k in ("deleted_objects", "deleted_rows", "orphan_stale", "missing_stale_unreferenced")}))
|
||||
status, _, _ = req("GET", f"/api/v1/attachments/{used['id']}", headers=auth(tb))
|
||||
lines.append(f"referenced metadata after apply HTTP {status}")
|
||||
status, _, _ = req("GET", f"/api/v1/attachments/{used['id']}/content", headers=auth(tb))
|
||||
lines.append(f"referenced bytes missing HTTP {status}")
|
||||
status, _, _ = req("GET", f"/api/v1/attachments/{loose['id']}", headers=auth(ta))
|
||||
lines.append(f"stale unreferenced metadata HTTP {status}")
|
||||
status, _, content = req("GET", f"/api/v1/attachments/{fresh['id']}/content", headers=auth(tb))
|
||||
lines.append(f"fresh download HTTP {status} same_bytes={content == png}")
|
||||
(EVIDENCE / "reconcile-apply.json").write_text(json.dumps({"dry": dry1, "apply": applied, "again": again}, indent=2) + "\n")
|
||||
(EVIDENCE / "grade45.txt").write_text("\n".join(lines) + "\n")
|
||||
print("\n".join(lines))
|
||||
|
||||
|
||||
def pixel_bomb():
|
||||
# Минимальный PNG 1×1 с подменой IHDR на 20000×2001 и пересчитанным CRC.
|
||||
import struct
|
||||
import zlib
|
||||
sig = b"\x89PNG\r\n\x1a\n"
|
||||
|
||||
def chunk(kind, data):
|
||||
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
|
||||
|
||||
ihdr = struct.pack(">IIBBBBB", 20000, 2001, 8, 2, 0, 0, 0)
|
||||
raw = b"\x00" + b"\x00\x00\x00"
|
||||
return sig + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(raw)) + chunk(b"IEND", b"")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,18 @@
|
||||
//go:build ignore
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"image"
|
||||
"image/color"
|
||||
"image/jpeg"
|
||||
"os"
|
||||
)
|
||||
|
||||
func main() {
|
||||
img := image.NewRGBA(image.Rect(0, 0, 8, 4))
|
||||
img.Set(0, 0, color.RGBA{R: 255, A: 255})
|
||||
if err := jpeg.Encode(os.Stdout, img, &jpeg.Options{Quality: 80}); err != nil {
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
//go:build ignore
|
||||
|
||||
// Проверка, что прикладной ключ видит свой bucket и не создаёт другой.
|
||||
// Печатает только код ошибки, не ключи.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/credentials"
|
||||
)
|
||||
|
||||
func main() {
|
||||
client, err := minio.New("127.0.0.1:9000", &minio.Options{
|
||||
Creds: credentials.NewStaticV4(os.Getenv("S3_ACCESS_KEY"), os.Getenv("S3_SECRET_KEY"), ""),
|
||||
Secure: false,
|
||||
Region: os.Getenv("S3_REGION"),
|
||||
BucketLookup: minio.BucketLookupPath,
|
||||
})
|
||||
if err != nil {
|
||||
fmt.Println("client: config error")
|
||||
os.Exit(1)
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
own := os.Getenv("S3_BUCKET")
|
||||
ok, err := client.BucketExists(ctx, own)
|
||||
fmt.Printf("BucketExists %s: ok=%v no_error=%v\n", own, ok, err == nil)
|
||||
err = client.MakeBucket(ctx, "messenger-other-bucket", minio.MakeBucketOptions{Region: os.Getenv("S3_REGION")})
|
||||
code := "nil"
|
||||
if err != nil {
|
||||
resp := minio.ToErrorResponse(err)
|
||||
code = resp.Code
|
||||
if code == "" {
|
||||
code = "error"
|
||||
}
|
||||
}
|
||||
fmt.Printf("MakeBucket messenger-other-bucket: %s\n", code)
|
||||
if code == "nil" || code == "" {
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user