forked from mtusi2026/mtusi2026lab5
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
57a253e0b4 |
+8
-20
@@ -1,20 +1,8 @@
|
||||
.git
|
||||
.github
|
||||
.env
|
||||
.env.*
|
||||
!.env.example
|
||||
secrets
|
||||
certs
|
||||
volumes
|
||||
data
|
||||
backups
|
||||
*.key
|
||||
*.pem
|
||||
*.p12
|
||||
*.pfx
|
||||
*.jks
|
||||
.venv
|
||||
__pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
**/.git
|
||||
**/.local
|
||||
**/.env
|
||||
**/secrets
|
||||
**/evidence
|
||||
**/node_modules
|
||||
**/.venv
|
||||
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
name: Application acceptance
|
||||
on: [push, pull_request]
|
||||
permissions:
|
||||
contents: read
|
||||
jobs:
|
||||
application:
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 25
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: oven-sh/setup-bun@v2
|
||||
- uses: actions/setup-go@v5
|
||||
with:
|
||||
go-version: '1.27.2'
|
||||
cache-dependency-path: backend/go.sum
|
||||
- run: ./scripts/up.sh
|
||||
- run: bun student-tests/wait.ts
|
||||
- run: make check test BASE_URL=http://127.0.0.1:28205
|
||||
- run: make test-persistence BASE_URL=http://127.0.0.1:28205 ACTION_SCRIPT=./scripts/restart.sh
|
||||
- run: bun student-tests/both-replicas.ts
|
||||
- run: ./student-tests/run-db-matrix.sh
|
||||
- run: bun student-tests/pipeline-faults.ts --point=after_original --restart-gap
|
||||
- run: bun student-tests/pipeline-faults.ts --point=after_commit
|
||||
- name: Stop only this stand
|
||||
if: always()
|
||||
run: ./scripts/compose.sh stop
|
||||
+3
-29
@@ -1,32 +1,6 @@
|
||||
# Local/private state
|
||||
.local/
|
||||
.env
|
||||
.env.*
|
||||
!.env.example
|
||||
secrets/
|
||||
certs/private/
|
||||
*.key
|
||||
*.p12
|
||||
*.pfx
|
||||
*.jks
|
||||
*.pem
|
||||
*.tfstate*
|
||||
volumes/
|
||||
data/
|
||||
backups/
|
||||
# Runtime/build artifacts
|
||||
.venv/
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
node_modules/
|
||||
dist/
|
||||
build/
|
||||
target/
|
||||
bin/
|
||||
obj/
|
||||
coverage/
|
||||
*.log
|
||||
.DS_Store
|
||||
.idea/
|
||||
.vscode/
|
||||
# Keep small, sanitized evidence summaries in evidence/ under version control.
|
||||
# Inspect git diff --cached: ignore rules are not a secret scanner.
|
||||
*.pyc
|
||||
|
||||
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
# syntax=docker/dockerfile:1
|
||||
FROM golang:1.27.2-alpine@sha256:f92b6ef800e499660581efdabdf25d9d817a9d124eaf900924f0504e7e27e12d AS build
|
||||
WORKDIR /src
|
||||
ENV CGO_ENABLED=0 GOFLAGS=-mod=readonly
|
||||
COPY backend/ ./
|
||||
RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build go build -trimpath -ldflags='-s -w' -o /out/messenger ./cmd/app && go build -trimpath -ldflags='-s -w' -o /out/worker ./cmd/worker
|
||||
FROM debian@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends imagemagick ca-certificates && apt-get clean
|
||||
COPY --from=build /out/messenger /messenger
|
||||
COPY --from=build /out/worker /worker
|
||||
USER 65532:65532
|
||||
ENV APP_HOST=0.0.0.0 APP_PORT=8080 GOMEMLIMIT=384MiB
|
||||
ENTRYPOINT ["/messenger"]
|
||||
|
||||
@@ -1,37 +1,67 @@
|
||||
# Отчёт — лабораторная 5
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
Автор: Медведев Андрей Михайлович, БПИ2303. Цель: все требования уровней3–4 и трек2 уровня5 «Доказанная идемпотентность pipeline». Оценка преподавателем не присвоена. Публикация и PR не выполнялись; подготовлен архив для сдачи.
|
||||
|
||||
## Запуск из чистого clone
|
||||
Основа: исходный skeleton ЛР5, commit276dbdad8a34da4c5b57fbf1879ca169b581d75b, и собственная ЛР4 из `/Users/rey/projects/vp-mtuci` (оригиналы не редактировались). Сохранены новые README, COURSE, contracts и публичные tests текущей работы. Реализацию и проверки помог подготовить ИИ; независимые находки reviewer исправлены с RED/GREEN. Первичные источники: [Redis Streams](https://redis.io/docs/latest/develop/data-types/streams/), [PostgreSQL UPDATE](https://www.postgresql.org/docs/current/sql-update.html), [ImageMagick limits](https://imagemagick.org/script/resources.php), контракты этого skeleton.
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
## Запуск
|
||||
|
||||
## Архитектура и решения
|
||||
Нужны Docker с Compose, Bun и Python3.9+; для расширенной PostgreSQL matrix нужен Go1.27.2 в PATH (или переменная GO с путём к нему). Проверено на Linux x86_64, Go1.27.2, Bun1.4.4, Docker29.9.2/Compose5.6.1. Все сервисы запускаются этим репозиторием. Образы Go1.27.2-alpine, Debian, PostgreSQL18.6, Valkey9, RustFS1.0.0-rc.1 и HAProxy3.2 закреплены digest в Dockerfile/compose.yaml. Runtime устанавливает ImageMagick из Debian; версию пакета фиксирует выбранный базовый release и его репозиторий, отдельного immutable snapshot apt нет.
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```sh
|
||||
./scripts/up.sh
|
||||
bun student-tests/wait.ts
|
||||
make check
|
||||
make test BASE_URL=http://127.0.0.1:28205
|
||||
make test-persistence BASE_URL=http://127.0.0.1:28205 ACTION_SCRIPT=./scripts/restart.sh
|
||||
make test-failover BASE_URL=http://127.0.0.1:28205 ACTION_SCRIPT=./scripts/stop-one.sh
|
||||
bun student-tests/both-replicas.ts
|
||||
./student-tests/run-db-matrix.sh
|
||||
bun student-tests/pipeline-faults.ts --point=after_original --restart-gap
|
||||
bun student-tests/pipeline-faults.ts --point=after_objects
|
||||
bun student-tests/pipeline-faults.ts --point=after_commit
|
||||
./scripts/compose.sh stop
|
||||
```
|
||||
|
||||
## Доказательства критериев
|
||||
`up.sh` генерирует отдельные учебные credentials в `.local` (родитель0700), строит один общий image, запускает зависимости, миграции, S3 bootstrap и две API+worker+LB. `.local` не входит в архив/git. При частично существующей конфигурации bootstrap останавливается, не затирая её. `compose.sh` всегда закрепляет manifest и project, поэтому чужие COMPOSE_* не перенаправят операции. Публичен только LB127.0.0.1:28205; остальные компоненты в private/internal network, edge есть лишь у LB.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
Остановка сохраняет volumes. Намеренное удаление только этого учебного стенда и всех его данных: `./scripts/compose.sh down --volumes`. Этот разрушительный сценарий в приёмке не запускался.
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
## Архитектура и ограничения
|
||||
|
||||
## Эксперименты и отказы
|
||||
API сохраняет validated original в S3 `staging/<id>`, затем одной PostgreSQL транзакцией переводит metadata в queued и создаёт outbox/job. Только после COMMIT возвращается202. Отдельный worker переносит intent в Valkey Streams и помечает публикацию в БД; сбой между XADD и DB отметкой создаёт допустимый дубль. Valkey AOF `appendfsync always`, PostgreSQL и S3 имеют отдельные persistent volumes. Недоступность broker после COMMIT не теряет DB intent.
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Сообщение содержит только схему/тип, UUID, версию, attempt, created_at и необязательный trace carrier; bytes, filename/URL и credentials в broker не попадают. Job UUID устойчив между повторами. Outbox читает до100 jobs каждые500ms. Stream удерживает примерно10000 записей; его trimming не удаляет источник истины — незавершённое intent повторно публикуется. XREADGROUP/claim count1, один worker/одно изображение, lease30s и обработка context20s. PEL восстанавливается XAUTOCLAIM через30s.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
Worker берёт доверенные metadata из БД, читает staging (или сохранённый immutable original при новой версии), повторно проверяет размер и SHA256, сохраняет `originals/<id>` и три `variants/<id>/v<version>/<name>`. Все variants публикуются атомарным fenced UPDATE только при текущей версии, lease и processing. До этого content409; ready устанавливается лишь после всех S3 записей. Ack идёт после durable результата либо durable next retry/failed, а не после самого получения сообщения.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
Ограничения изображения: до10MiB и40M pixels, PNG/JPEG; bounded временный файл и output16MiB на variant, tmpfs256MiB, subprocess context20s. ImageMagick memory/map256MiB, disk0, resize thread1. Thumbnail вписывается в256×256 без увеличения (floor, минимум1), crop128×128 центрирован с допустимым увеличением, optimized WebP вписывается в1280×1280 без увеличения. EXIF orientation применяется, alpha ложится на белый фон, metadata удаляются, quality82. Декодер-процесс и Go имеют также Docker RAM/CPU limits.
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
API: две реплики по1CPU/2GiB, MAX_INFLIGHT4, MAX_QUEUE32; worker1CPU/2GiB и GOMEMLIMIT384MiB; PostgreSQL/S3 по768MiB, Valkey/LB по128MiB. Это configured limits, не измеренный расход памяти. Пароли с Argon2 и hashed session tokens сохранены из ЛР4; TLS/OpenBao — отдельная ЛР7.
|
||||
|
||||
Retry по умолчанию5 попыток (конфигурация1..10), экспоненциальный backoff100ms×2^attempt плюс jitter0..99ms с ограниченным exponent. Только typed invalid_image permanent; ENOSPC, отсутствующий executable, S3/DB/timeout остаются transient. Исчерпание даёт failed/retry_exhausted в БД (реестр failed вместо отдельного broker DLQ). `./scripts/compose.sh run --rm worker --replay UUID` явно повторяет только failed/current/source-retained job; ready-дубль не исполняется. Replay атомарно сохраняет replay_count и replayed_at вместе со сбросом attempts. `--advance UUID` создаёт новую pipeline_version для operator-controlled version experiment.
|
||||
|
||||
Cleanup имеет отдельный durable staging_cleaned marker и выполняется независимо каждые1s, а также при redelivery completed job. Ready stage удаляется только при наличии original ожидаемого размера; неуспешный/unbound stage получает retention24h. Ошибка удаления не переводит ready в failed и будет повторена. Legacy reconcile не меняет versioned pipeline metadata; старый путь больше не может отметить original-only запись ready.
|
||||
|
||||
## Проверки и наблюдения
|
||||
|
||||
- `make check`, Go race tests, `go vet`, golangci-lint и non-writing gofmt check: результаты в `evidence/final-checks.txt`, `evidence/final-audit-build.txt` и финальном manifest. Env-gated интеграции отдельно, обычный `go test` не выдаётся за их запуск.
|
||||
- Публичный smoke, сохранность после PostgreSQL/Valkey/S3/API/worker/LB restart и failover с существующей сессией: `evidence/public-acceptance.txt`. Во время failover126 успешных записей,1 неудачная попытка, первое подтверждённое восстановление1.492s. Это наблюдение конкретного теста, не benchmark/SLO.
|
||||
- Обе реальные API реплики отдельно остановлены; существующая сессия и все подтверждённые сообщения сохранены, surviving instance отличается от остановленной. `evidence/both-replicas.json`:1025ms и27ms — время наблюдения после stop в двух проверках, не универсальный recovery bound.
|
||||
- Реальный ImageMagick integration: landscape320×200, tiny1×1, portrait23×67, EXIF rotation, JPEG content/white alpha/geometry/hash и WebP magic. Команда `RUN_VARIANT_TESTS=1 go test -v ./internal/adapter/imagefile`, runtime выполнялся в image с ImageMagick.
|
||||
- Crash после S3 original/variants и после результата COMMIT: реальный worker `-fault` завершён os.Exit88. Actual legacy `/messenger -reconcile -apply -grace1m` не публикует неполную processing запись. После lease recovery готово3 variants, original byte-exact, staging_cleaned=true. JSON `evidence/runtime-pipeline-faults-after_*.json`.
|
||||
- COMMIT/publish gap: worker уже остановлен, API202, DB job published_at=epoch, content409, сообщение с attachment создаётся. Затем реальные API+Valkey restart с volumes, запуск fault worker и обычное восстановление того же UUID без создания job вручную. `evidence/runtime-pipeline-faults-after_original-restart-gap.json`.
|
||||
- Versioned pipeline: настоящий PostgreSQLStore+S3+Pipeline, concurrent current duplicates, старая v1 до/после v2, fabricated future delivery, повтор v2. Детерминированный test Transformer выдаёт разные v1/v2 bytes (остальное реально); v2 metadata и S3 bytes остаются неизменны. ENOSPC×5 даёт failed/retry_exhausted, explicit replay восстанавливает ready. После after_commit completed-redelivery очищает настоящий S3 staging. `evidence/versioned-fault-matrix.txt` и `evidence/final-runtime.txt`.
|
||||
- Regression готовой v1→normal stage cleanup→advance v2→failed→replay сначала воспроизвёл отказ, затем прошёл на реальном SQL после исправления staging_expired; отдельный RED/GREEN сохранён. Audit replay также проверен сначала RED без сохранённого count/timestamp, затем GREEN. `evidence/{red,green}-replay-version2.txt`, `evidence/red-replay-audit.txt`, финальная DB matrix.
|
||||
|
||||
## Трек2 уровня5
|
||||
|
||||
Гипотеза: at-least-once доставка допускает дубли и reorder без потери durable принятого intent и без публикации результата старой версии поверх новой, если владельцем результата остаётся PostgreSQL lease+version fence, а ключ S3 эффекта включает version. Проверяемые инварианты: immutable original; один logical job на attachment/version; только действующий lease публикует ready; old/future/completed deliveries не меняют текущий результат; повтор после COMMIT может безопасно завершить cleanup.
|
||||
|
||||
Методика и команды выше автоматизированы. Падение after_original одновременно находится после side effect original и до side effects variants; after_objects — после variants до result COMMIT; after_commit — после durable результата до ack/cleanup. Дубли/reorder проверены вызовом того же реального Pipeline consumer method на настоящих PG/S3 с различимым oracle. Процессные падения и рестарты дополнительно проверены настоящим worker и broker. Тестовый Transformer не заменяет ImageMagick acceptance: native image scenarios проверяются отдельно.
|
||||
|
||||
Exactly-once доставка не заявлена: XADD и DB отметка публикации не атомарны, ack может потеряться, S3 PUT повторяется; exactly-once эффект обеспечивается в пределах logical key/fenced publication, а не отсутствием повторных вычислений/записей.
|
||||
|
||||
## Практические пределы
|
||||
|
||||
Один host/PostgreSQL/Valkey/S3 не защищает от потери host или volumes. Не измерены throughput/p95/RSS под перегрузкой: выбран fault-injection трек, benchmark во время игры запрещён. Retry/retention управляются БД clock; на зависшем host hard wall-clock guarantee отсутствует. Детерминированность разных реализаций ImageMagick не заявлена: версии pipeline и metadata фиксируют выбранный эффект. Старые versioned объекты сохраняются для исследования; автоматическая политика удаления исторических версий здесь не реализована. Публикация в student fork, PR и оценка преподавателем — следующие внешние действия владельца.
|
||||
|
||||
@@ -0,0 +1,163 @@
|
||||
{
|
||||
"createdAt": "2026-11-15T17:44:00.621Z",
|
||||
"assignment": "VP Lab5",
|
||||
"student": "Медведев Андрей Михайлович, БПИ2303",
|
||||
"skeleton": "276dbdad8a34da4c5b57fbf1879ca169b581d75b",
|
||||
"validation": "Go1.27.2 Linux unit/race/vet/lint/build; full OpenAPI; public smoke/persistence/both-replica failures; actual worker crashes; real PostgreSQL/S3 fault matrix and audit",
|
||||
"fileHashes": {
|
||||
".dockerignore": "62eeb54240e2ee9fda932ed40912aa78983f3be6abc48e44612df399645f5dbb",
|
||||
".env.example": "bf057714d05158b66620099ec06b5d81430fd3ed371fabaac47143b5fd4c3a3a",
|
||||
".github/pull_request_template.md": "7cfeabfbcb19f34d85ed99cbcd6797977d6d722e65f7533e859147d5ab4d5e9b",
|
||||
".github/workflows/application.yml": "fd75a11c8fe9c9c07d2a68078a92df4077516955e8d75cb120358f4c947196cd",
|
||||
".github/workflows/contracts.yml": "a45d7932ef14130aff8020bce79f043cccaf9692d697088a754d309a03f7d3e8",
|
||||
".gitignore": "385e0e7c81ca13ebf0bab2ebcaf51c1dbfe9af14a01714886d98b5689718b195",
|
||||
"CONTRIBUTING.md": "2c01dd698cc9653dece49a94c9fd3f58d36e84764aaa643b46e26d7e599dc12e",
|
||||
"COURSE.md": "c34d53cd082d194aa4b58f504c4e0348d25b6afec3d6a9c0963dd01c9c81e971",
|
||||
"Dockerfile": "40095fcce1fc5c43eea0f7cbc0cce55ab6e630969abafdaddc64ce4f9a778fb4",
|
||||
"Dockerfile.example": "fd7ac9491c0c3c663b083c41a762fb38bc2d212fa4a2ed3e6a0702af72108709",
|
||||
"MAINTAINERS.md": "2ac3103bc622557ab5e550d716dbdb62bcccf8fc4c0eb410bcbfe5a9f127e7ff",
|
||||
"Makefile": "c05bd07058ae0949dd4905afdae7674bc7e3e63863a6cdf8b72661140d445826",
|
||||
"README.md": "0651974eebbd4f34a04cd7c06df167cf61ae686cc67ceb2ac977a115ad70b866",
|
||||
"REPORT.md": "2dfdb23f1837c614d3d35f25ba85e2363701a21af86f0e629493575761f571bf",
|
||||
"SUBMISSION.md": "768525e53d40e8541b9a95c2202abe0ee3ab38f29ab496c869ac461a8511cff6",
|
||||
"backend/.golangci.yaml": "215578dee14bcef1b66759a68543083e0a624611efcdb785197307b50cb7725d",
|
||||
"backend/cmd/app/main.go": "89f8cdf64c4a22a2ae65fb5b88f97dc7bfff7a1aff6cb0c766d3f495ea14fcd3",
|
||||
"backend/cmd/worker/main.go": "97ae2cafaf861443d0a56a635739f80f66b878b31fffd52f8136888e17c466ea",
|
||||
"backend/codegen.yaml": "e4d37ce5c5a9f969f696833cd59a6e1b86f99fb2b0de69101a1aa5f4a539aebe",
|
||||
"backend/db/migrate.go": "33044d905354f24fff194fefd35ee9327d63d6e5062ded8496e518b6ce38dbea",
|
||||
"backend/db/migrations/00001_core.sql": "b6bd8c70d51aed6c966e07eebffd262af2e694c8b3479c70bbf9a9eacf5a7aad",
|
||||
"backend/db/migrations/00002_idempotency.sql": "97c98785547db8391c1fa0a685e4d4bcc810b8f79055c0e2fc6ef473cd38b37b",
|
||||
"backend/db/migrations/00003_attachments.sql": "6b4f707dde32f0c3f531741c108bcf0f22be05c9e2ede327f27a1d9ef0cfcc7f",
|
||||
"backend/db/migrations/00005_replay_audit.sql": "234a04177bca08621fa38b135cb8086bcdd55ae9084008b25814751e1dd742a4",
|
||||
"backend/db/sqlc/queries/attachments.sql": "8e64f0e6169fab7664b0f4a97f2be353553b93c0c928d10678cb930e44de37da",
|
||||
"backend/db/sqlc/queries/core.sql": "1aed3d0d2fc04650351d86d15837cf3239636844727e799aabf5ddd534429f33",
|
||||
"backend/db/sqlc/queries/idempotency.sql": "5bdec86e85705f7805fb603e2c792bb87c11cf3156952fa48e7bcee35fd683ca",
|
||||
"backend/db/sqlc/queries/pipeline.sql": "6c5fa5356024da6e70b7e3116a0765e2865342d7ca474caa4f647c04e4fb9cf4",
|
||||
"backend/db/sqlc/sqlc.yaml": "803b161e063692398c93152b11a08f9e42e1bf3c72a1e64553b82c494545fd10",
|
||||
"backend/generator-overlay.yaml": "e666da2959b31befed713a8366237de53070a565f93850d6daae7a582a038819",
|
||||
"backend/go.mod": "0b8da0a50d49decdd1b36c920363f5908b372a786a85bd6c2b789ce781ac8f91",
|
||||
"backend/go.sum": "b981fecb6445955924c2162a1ca9a6877820143af458df963624b3ceb583b861",
|
||||
"backend/integration/object_metadata_test.go": "598e973575d57c6ee563f0b15d0111d37b27de6774c6f486c998dbc70594f15d",
|
||||
"backend/internal/adapter/handler/api.gen.go": "4034501f5c661c87af3b81d0d1ecb9996050828569bea7e85b3604a2a8c8bdbe",
|
||||
"backend/internal/adapter/handler/api.go": "9d9f109e13c9322287b29ed18e7913e0e8d5a9ef2dc4be23f10c7686de3f70fe",
|
||||
"backend/internal/adapter/handler/attachments.go": "608827653c4d3e4252dff863d30007e93b1bf82579bbe71d8b647bf22128b1b2",
|
||||
"backend/internal/adapter/handler/auth.go": "3889f58ac4c58b798192776ea05455d52735a2c024ba664ab9af5eb405187557",
|
||||
"backend/internal/adapter/handler/errors.go": "39a5b916112fd9cc2be9979b6e78d6305e7c3c8ab5fa462f1b8e9f18c88c1a4a",
|
||||
"backend/internal/adapter/handler/gate.go": "b662058ebc59010f30d21da12404837aa2329fe5e5590761efdd9140c1d24e9c",
|
||||
"backend/internal/adapter/handler/gate_test.go": "f7938bdeb5617ed3611303c54818000de9861dde5915fa2c6fa0f74e1fa33268",
|
||||
"backend/internal/adapter/handler/handler.go": "dc5a9abe76b57c3514c67feb7b98654bc058d3329c35724aef0b6a50476d0ebf",
|
||||
"backend/internal/adapter/handler/json.go": "d6458b8e8e4426816ec8c855ff6c8d88a151161bc1560e4b98df0ea4b0dbf6be",
|
||||
"backend/internal/adapter/handler/message_json_test.go": "8dd976c4cad81ee531c76165787b2c8b6052057d934ae4b09b60d8a261cf30e5",
|
||||
"backend/internal/adapter/handler/middleware.go": "256221524d19e057ab2a330e08f1c5b0bd5fc95b8d19391f69fd286e5aa8ba54",
|
||||
"backend/internal/adapter/handler/stats.go": "5cd375e5a0db8cc3596293d323e635b86fef22d8ec680f310ab5a460f8176f64",
|
||||
"backend/internal/adapter/handler/utf8_test.go": "eac6a14b5f3b0ea9aa5329337afc6db27e17f5c17999874da9ce3592dc7a4205",
|
||||
"backend/internal/adapter/imagefile/image.go": "8a9b399b22573992fd7fd4c87096f953b46c1bc7cad4e09c023923919d755375",
|
||||
"backend/internal/adapter/imagefile/image_test.go": "a2dc0d3797a5c2ac7ad46a7453a34ea13aba94c3385d2692032705610026dc71",
|
||||
"backend/internal/adapter/imagefile/stress_test.go": "3d7b0671f57ce5e01fa7e175a86c16a51d56d8f11ec6d3bfb09b2c8bfe8c04d8",
|
||||
"backend/internal/adapter/imagefile/variants.go": "50762d1e2af635c9a9344d2721ee145bb9d9d43408f680fc280cdd493aeef886",
|
||||
"backend/internal/adapter/imagefile/variants_integration_test.go": "d25e3371432128e58073ff61e1b87fa741bc32ee7d9bc6e8cb40ae3f3a5b4434",
|
||||
"backend/internal/adapter/imagefile/variants_test.go": "79c24a3d5c0cb339a32fdea28eb56689703f35ad3c668c464ea7a4f5e82322e5",
|
||||
"backend/internal/adapter/password/argon.go": "94643bf4b61ca390f8dd56a241e02e1325a994fc40887ffa0e2b8f8e5aebb4c7",
|
||||
"backend/internal/adapter/queue/streams.go": "4b9b8def20b61d4dec82afc32b540cc7e712cf4e25a6c7f4685747be7a1f5016",
|
||||
"backend/internal/adapter/repository/postgres/attachments.go": "88f8b8744d95407421eafc111ecc83bcb4b145f1683618d69cac19a8d1c39500",
|
||||
"backend/internal/adapter/repository/postgres/pipeline.go": "9a367d7a50a9418e96851c253f61ace4a54753044e7fa672c73a3b4526a22245",
|
||||
"backend/internal/adapter/repository/postgres/pipeline_integration_test.go": "58274475a02f1098a0f79a65a9e8d7608d05dfa26213f90c706a9239fabb586c",
|
||||
"backend/internal/adapter/repository/postgres/queries/attachments.sql.go": "ccbdaac42ee599d318eae05bb6e0b3580e43c7437ce2cbc9268aa27068460213",
|
||||
"backend/internal/adapter/repository/postgres/queries/core.sql.go": "9a0e082263cbea39535de9c7c72c41a39a551efc9ee57fdd7b08856831d074b3",
|
||||
"backend/internal/adapter/repository/postgres/queries/db.go": "4863732830879d4162be215ff245375b953359de23bcd821ed7abc5c32a36c0f",
|
||||
"backend/internal/adapter/repository/postgres/queries/idempotency.sql.go": "cf6fbc316e93339e0f938c7ca82007e29c3e32f1a21ee1433a2ce8784697f002",
|
||||
"backend/internal/adapter/repository/postgres/queries/models.go": "26e72c3e908bd66a2a09baabc567d9eb6f88ac9662f6f1eebe8e77b609aa737b",
|
||||
"backend/internal/adapter/repository/postgres/queries/pipeline.sql.go": "82c3e339f3aae0b9e12f05eb299e615d6f293bbb88fb8139b36a20de5fe6b395",
|
||||
"backend/internal/adapter/repository/postgres/repository.go": "e380d7c0c52a2447653db9e4d13db432f4c1330e3205a0396510d957441bb978",
|
||||
"backend/internal/adapter/storage/bootstrap.go": "44c8f422826b29f85a918029bb71a62cd3018190f8efe889cbeee63d19d7039e",
|
||||
"backend/internal/adapter/storage/readiness_test.go": "a6c79cba7af74ce67e69678085e5bb267a47f9dd7be57daf003ba03951274a5c",
|
||||
"backend/internal/adapter/storage/s3.go": "99a717604c71da5c181bef74612a603abe3cfc913ccb3da84ed581a57a11ccd8",
|
||||
"backend/internal/application/usecase/attachments.go": "9e3e69bad8c988f1c931357336c2b0bfe1b0b2ac17fe6f299c1d9cc66dbd9230",
|
||||
"backend/internal/application/usecase/auth.go": "93802954db2c8eda3782acc71bca817947fd556986d3f6552c78c4b346d988ca",
|
||||
"backend/internal/application/usecase/messenger.go": "c58aba0d3f5d0ab92fab5d2771b90a3af5ad06e6afe0c7cc46f481a429e89f48",
|
||||
"backend/internal/application/usecase/pipeline.go": "4f60f7b96bb39e8b5c13597da953783194e9e2c5f8a4030483628a80496d86e0",
|
||||
"backend/internal/application/usecase/pipeline_retry_test.go": "6068c07fdaa61fdb0bb0b73bd2094aacdec7a10ff2db1ebd64decb3288f2de5c",
|
||||
"backend/internal/application/usecase/reconcile.go": "239edee16f767dd16b116791900994540a8f99ae3403fd0308f5e2c0797a892d",
|
||||
"backend/internal/application/usecase/reconcile_pipeline_test.go": "75e1fb5fcc5ffb2188a2368688e5505a4bf54453c2800b5e46c8e9e23de89b7c",
|
||||
"backend/internal/application/usecase/reconcile_test.go": "fdbcfad86851fc97a3cf635b6d884c41b43084eedc42b3c4847790c5eaad4a6f",
|
||||
"backend/internal/config/config.go": "58795b18980c4dd938c73721ab937d06410af94edc156b7a7aa9b2c4c2388238",
|
||||
"backend/internal/config/config_test.go": "390e3b5a4682719a0b25a8eb9aefeda9a9d1c774d3f8d1f08062c79a58d8859a",
|
||||
"backend/internal/domain/model/attachment.go": "e532f2c8e8c123d0fda6101bff4b21168527a0a446e53f566f5e5919b972133b",
|
||||
"backend/internal/domain/model/chat.go": "3f7454f48ef442c277fd2741ce5aeeccf03d590bd2d31b9b89fa39f0ba05de7f",
|
||||
"backend/internal/domain/model/errors.go": "d043547d742e94d9ef9f0799dced7c43dc2adc44d7d90906e891e5afee8de04d",
|
||||
"backend/internal/domain/model/job.go": "21a2b424b9a72fe098f9a70f34b6137b3e3fcd0129b10ef81071fac11a7c737c",
|
||||
"backend/internal/domain/model/message.go": "0e0126663d2de04c9d14c8c7427f42a9fb733e3b170ceee7ed86c2138f51b23c",
|
||||
"backend/internal/domain/model/model_test.go": "77bb8767ac1352bd3551e724eaaeaad4fe93eae248cc8c3008ee8b1c08adddca",
|
||||
"backend/internal/domain/model/page.go": "cd6a07579bff01aa0d8a11b34fd000a804142b321cef302d386bdb95e9c7f953",
|
||||
"backend/internal/domain/model/postgres_text_test.go": "8c245eef99a97261daf0aa16fec9edd7bcd3253ec4144c50b4f8e56e45e2186e",
|
||||
"backend/internal/domain/model/text.go": "c9410cacd9d1b2fd7f3f2cb7e4112e637ecc494f6e4b6da649f936ce0c9a0457",
|
||||
"backend/internal/domain/model/user.go": "c20c8b8d8a9c0327a3a24afd74f3051d78caed1d2f0851baf340ef61ac502a92",
|
||||
"backend/internal/domain/port/auth.go": "465c1a1f19075b6f8301eef8dbd7fd9a8d20255716d72c97e946db04c2850dda",
|
||||
"backend/internal/domain/port/objects.go": "4d22b5ef5ff6fa13404884c160fe52bd7cef4099f84b29268137c27034a0f3ec",
|
||||
"backend/internal/domain/port/pipeline.go": "5fe7c6909cbaf6a21a4be5d9ed0c2b1551681894d0054463cdba13ea09c21aac",
|
||||
"backend/internal/domain/repository/repository.go": "baff51af1cf9c6b273b013f6cb8aa3069eaab615e279dd8fe0a2d19f9bb205a6",
|
||||
"backend/pkg/logger/logger.go": "d839f31015eee692065c31d2538a4cb4c841b0d89e690f0ab8baf80168510556",
|
||||
"backend/pkg/server/server.go": "3ce957e4e45a94453610217007a9dbf0e8b9723346ff9cc8a3e5aa8ff3676527",
|
||||
"compose.example.yaml": "2ae5ec12669a2b4281cddc94a2d1725de1993ce093aea32c290fa026749163cc",
|
||||
"compose.yaml": "bfd9a9be404e90b0a63bc7be89e0def5fba27fa21d0eb7475ab93e3f2a2e26dd",
|
||||
"config/haproxy.cfg": "5fbd83685515fa68b463fd887b66f23cd2ffab9283c9ece6d015cc5634c7f5bd",
|
||||
"contracts/README.md": "72df27a559f88ffa3fd8c3c79d3c32f6db2c5986a0602677c51994c434a3fc4f",
|
||||
"contracts/attachment-states.md": "cf0519e137410e4b34ab632aadb8ad8a381d4b73033e27b354c58eeacbdf86d6",
|
||||
"contracts/examples.json": "381cc18c03789e935b391d007fb5843964be9cfd9f7530cb6b1996ed4a1c4c37",
|
||||
"contracts/infrastructure.json": "6d4ca861b160118cef8764ae0ca292ac924b541963ccc7be4857eddbef6d77d8",
|
||||
"contracts/jobs.schema.json": "9ccf9b11466c0c3a26a941520ac5ff543241fc4935e3a6eebb01ef303779b10d",
|
||||
"contracts/openapi.json": "62b6e1d43ca0c6115e9c6ad0ffa9be0835e8fdf9ae664d2fea3c258ef745d56d",
|
||||
"evidence/README.md": "78e4bfd738d034597d15d8846accd8a8a5dc738a23a3d15f243f3992bd530cc3",
|
||||
"evidence/both-replicas.json": "66ac26922382548de136603cb21b160c0b6c0edf20de9de11204ff418ab1c217",
|
||||
"evidence/both-replicas.txt": "aa2b09b91bf119b29e5989d0d2e3704177524d6293e03c168c069ca84a46cf3e",
|
||||
"evidence/final-audit-build.txt": "de5843141ad158447f7a86a229b2e96df603497dd1b609dd37dd7718ee17666d",
|
||||
"evidence/final-checks.txt": "c24bc53e2383435c4d364767d585ace553e75d968793c3a88041cf82b2d0f5f4",
|
||||
"evidence/final-runtime.txt": "07bca91c910f4077eb709ab00ed233c86102be319c4cf98f79076dbb434a5edc",
|
||||
"evidence/fresh-db-messenger_stage_70b6ccce.json": "10fdd7032a24d092c8847c8a1499caaef467cd8685e6a3b3ac7b11d9a24ff259",
|
||||
"evidence/golangci-lint.txt": "ad482a92858eb599d691c55516cb81a5ae9214c855111c7aa2b15d1a77ed2aaf",
|
||||
"evidence/green-replay-version2.txt": "abeb344088114195f241f2c823a5c32eb657c95176056499dc661bcb54370328",
|
||||
"evidence/openapi-validate.txt": "422aec45ba93e5567e0de199fa32116a48c970ca3b82738b40f0ed7681ef621f",
|
||||
"evidence/public-acceptance.txt": "d7a0e35702acb28bff81e3747c6c51f139326b9807c910c209870a59b147103d",
|
||||
"evidence/red-completed-cleanup.txt": "cf9c45b46d8ce8b09f27a17801368c87713a0947185863f2a1e70bc1bde68c5f",
|
||||
"evidence/red-fit.txt": "5ad35817fe12fb2c96c579a37c9d8dfd87e5804446178f855f5e95c41035e2be",
|
||||
"evidence/red-reconciler.txt": "35de766d6a44714a797cad771814c2f159fa6b4536cb69f9fcf2278066b8a59a",
|
||||
"evidence/red-replay-audit.txt": "0ea3e2607931f6ccdf236ae057465dae9e1bc87eefdab90dd755a2aeefeaa036",
|
||||
"evidence/red-replay-version2.txt": "b01671551be3e97c7647105da4351b984df4b7cadeb0bdbe1c23f0b1bfb0ba4c",
|
||||
"evidence/red-transform-infrastructure.txt": "ecd4e6c93ffce849db7fe6b0fd1b7be89da8b7e9c8602cc2bacd31347c0edb98",
|
||||
"evidence/replay-version2-command.md": "59aab41601f4c11fefaf89049a434554cd11740216981eb6b05977187609b867",
|
||||
"evidence/runtime-commit-publish-gap.txt": "5d7abc96a82c2ad0d43b91f5492f7882b35ae659ecbb67c952526b98a76c9b63",
|
||||
"evidence/runtime-pipeline-faults-after_commit.json": "1029f5c2c7fcbbf8d9798934c64491e78c14d2800fbf989ab9dceacb0c8b7106",
|
||||
"evidence/runtime-pipeline-faults-after_objects.json": "a119e3950320a73f3d83bcb112f61f81543848132289577cac00bb0fb6abf954",
|
||||
"evidence/runtime-pipeline-faults-after_original-restart-gap.json": "c3c5ab9ac827aecbcd7a435cd702c50419f1dfabdc4cc4aec059846e0899b5a4",
|
||||
"evidence/runtime-pipeline-faults.json": "c426438148b854a4e0c2f701def53e833c8eea9b588b164a5288033c9aff51a7",
|
||||
"evidence/runtime-reconciler-red.json": "0a68fc6c9c5a915c055f6775374eb1deeaba1ebb76e28062aac8ecf7a5d9a785",
|
||||
"evidence/validate-dependencies.txt": "e2e9b0fdaef59a6becf3c2b4476e264fe1b774ac74fe3cf91474044d52d86b2b",
|
||||
"evidence/versioned-fault-matrix.txt": "97b8aee040692ecbf0ce2b67e3fe812af8dfe4c6ad782604111b568efa24a761",
|
||||
"examples/requests.http": "8c086fd540092b3e31a945a416632bcda6c4bea39253f86b076f791b362cf5e4",
|
||||
"infra/README.md": "0e804fa51debba4c38d3cc84abf4704897665e0335b272060363f03aadd6354f",
|
||||
"lab.json": "69c44ec7761e238c6a2d25f121a33328f2bbf7592a9348d85f84312d782ed70c",
|
||||
"requirements-dev.txt": "4cefdb67007caf026d1613be7c519c01b4c8343db7c4f4b618677e01cf113525",
|
||||
"scripts/bootstrap.ts": "eec21c7e9d66fce3003d2697dc2ff1394c8011e3d6c0a3312fbf265d2e2a754e",
|
||||
"scripts/check_contract.py": "7c4402c2a6ab80d3b4676e1866d6ecc87b6daea14c080bcb9be9a7e8b959d671",
|
||||
"scripts/compose.sh": "a2f7328c38f19c7e58dbadef88b087c5d21c17fb520a8a02e90f4da67b80df87",
|
||||
"scripts/restart.example.sh": "0328246ba75defbced992104e986fde973f63e3830d83251eced5953263e944b",
|
||||
"scripts/restart.sh": "dfbdc591fcfe6b7262207fea240b15341ea6c7dcc4be40388e7e33dabfc9918f",
|
||||
"scripts/stop-one.example.sh": "1bcf34394520b89d95b7605ec56675be799eea920e83cfbba306d5dc0a6d9811",
|
||||
"scripts/stop-one.sh": "8f236a157a4698362e66b5c73ca0150eefe3b33cf8b49e0200bbe8a3cb2efaa6",
|
||||
"scripts/up.sh": "98af809567105f5a3321ba1ff2b105798e7166cf72834a88ee33dd84b198a8c7",
|
||||
"scripts/validate_openapi.py": "4e981acbfc10dac58817bf922d5896e996798551fedc1b2385130e1cddb13d54",
|
||||
"student-tests/both-replicas.ts": "4864ccb73f3522fe50967521f2464a94cfc8f9e3ba2da1f837f79b8b47a9c8cd",
|
||||
"student-tests/pipeline-faults.ts": "76073314ea6a7cab1c7ae7a60d57e6f26f10ccf91f68be88fc31265e285da9ef",
|
||||
"student-tests/reconciler-red.ts": "55a618dd647ef96f3932e9d086cd0de4baf3b14a3b9571962fcf899ecf2dec95",
|
||||
"student-tests/run-db-matrix.sh": "bee4d38300d5af9b266877883170d19f43412a54253d51afe1af70b0bb04f8fd",
|
||||
"student-tests/wait.ts": "9dff91ee5a9876d5c4758d66a65b3b42c29a6d3071c7e510babae561a84cf35b",
|
||||
"tests/README.md": "e0bfa7e196797f6a5bf6e44d8ad2ffeb82651927ff5d8484eb1c2dda1ec7dec5",
|
||||
"tests/client.py": "8d50976fc7c7bbb81e88a152f613c61ab25eaf53dba33c6a9dfab19f868d546d",
|
||||
"tests/fixtures/README.md": "c001783760b4f87a7a8441a7ba55f5d080ff48e1397d3581d72a88d7691f96c2",
|
||||
"tests/fixtures/sample.png": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75",
|
||||
"tests/image_probe.py": "a9a4f89181c8e0fda6ce42e1a1af32fb42d8e3ae519e314207127c9b9b448b13",
|
||||
"tests/load.py": "6d3511ea719c7a7e841083e73d435c86dcbfd9f4e5c2a07d62eb9614b01d9933",
|
||||
"tests/resilience.py": "1f96663a174b3978d24eff66f2741f5f8c9b788d3242261d37a972720c52788b",
|
||||
"tests/smoke.py": "52ac38eb343ff7d43e7543588e1da58ca06c9fce74b2b0d0bf0e4982bc23c1db"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
# ЛР5 — БПИ2303 — Медведев — цель5, трек2
|
||||
|
||||
Асинхронный pipeline сохраняет staging и transactional outbox до202, обрабатывается отдельным durable Valkey worker и публикует original+thumbnail/crop/WebP через lease/version fence. Повторы, исчерпание retry, явный replay с audit и независимый staging cleanup сохраняют ready при redelivery и падении после COMMIT.
|
||||
|
||||
Проверены полный OpenAPI, race/vet/lint/build, публичный smoke, полный restart с существующей сессией и файлами, отказ обеих API реплик, реальные worker crashes, COMMIT/publish gap и настоящие PostgreSQL/S3 regressions дублей/reorder/version/replay. Команды и пределы в REPORT.md, фактические receipts в evidence/, точные файлы в SUBMISSION-MANIFEST.json. Это подготовленный результат для сдачи; PR и преподавательская оценка ещё отсутствуют.
|
||||
@@ -0,0 +1,36 @@
|
||||
version: "2"
|
||||
run:
|
||||
allow-parallel-runners: true
|
||||
linters:
|
||||
default: standard
|
||||
enable: [depguard]
|
||||
settings:
|
||||
errcheck:
|
||||
# Close тела ответа и файла, открытого на чтение: ошибке некуда деться.
|
||||
exclude-functions:
|
||||
- (io.ReadCloser).Close
|
||||
- (*os.File).Close
|
||||
depguard:
|
||||
rules:
|
||||
# Гексагон: ядро и use-case'ы зависят от портов, а не от адаптеров и транспорта.
|
||||
inner-pure:
|
||||
files: ["**/internal/domain/**", "**/internal/application/**"]
|
||||
deny:
|
||||
- pkg: backend/internal/adapter
|
||||
desc: домен и приложение зависят от портов, не от адаптеров
|
||||
- pkg: backend/internal/config
|
||||
desc: конфиг читает только cmd
|
||||
- pkg: net/http
|
||||
desc: HTTP только в adapter/handler
|
||||
- pkg: github.com/go-chi
|
||||
desc: роутер только в adapter/handler
|
||||
- pkg: github.com/rs/zerolog
|
||||
desc: логирование на границе, в адаптерах
|
||||
domain-core:
|
||||
files: ["**/internal/domain/**"]
|
||||
deny:
|
||||
- pkg: backend/internal/application
|
||||
desc: домен не знает о use-case'ах
|
||||
exclusions:
|
||||
paths:
|
||||
- ".*\\.gen\\.go$"
|
||||
@@ -0,0 +1,195 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"backend/db"
|
||||
"backend/internal/adapter/handler"
|
||||
"backend/internal/adapter/password"
|
||||
"backend/internal/adapter/repository/postgres"
|
||||
"backend/internal/adapter/storage"
|
||||
"backend/internal/application/usecase"
|
||||
"backend/internal/config"
|
||||
"backend/pkg/logger"
|
||||
"backend/pkg/server"
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
func main() {
|
||||
healthcheck := flag.Bool("healthcheck", false, "проверить /health/ready и выйти (для Docker HEALTHCHECK)")
|
||||
migrate := flag.Bool("migrate", false, "apply migrations and exit")
|
||||
bootstrapS3 := flag.Bool("bootstrap-s3", false, "initialize private bucket and application IAM credentials")
|
||||
reconcile := flag.Bool("reconcile", false, "reconcile at most 100 metadata rows and 100 objects; dry-run by default")
|
||||
apply := flag.Bool("apply", false, "apply safe reconciliation changes")
|
||||
grace := flag.Duration("grace", 10*time.Minute, "minimum safe object age, at least 60 seconds")
|
||||
after := flag.String("after", "", "metadata UUID cursor")
|
||||
objectAfter := flag.String("object-after", "", "object key cursor")
|
||||
flag.Parse()
|
||||
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "config:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
if *healthcheck {
|
||||
os.Exit(probe(cfg.Port))
|
||||
}
|
||||
|
||||
log := logger.New(cfg.LogLevel)
|
||||
dsn, err := config.ReadSecret(cfg.DatabaseURLFile)
|
||||
if err != nil {
|
||||
log.Fatal().Msg("database secret unavailable")
|
||||
}
|
||||
if *migrate {
|
||||
if err = db.Migrate(context.Background(), dsn); err != nil {
|
||||
log.Fatal().Err(err).Msg("migration failed")
|
||||
}
|
||||
return
|
||||
}
|
||||
s3path := os.Getenv("S3_CONFIG_FILE")
|
||||
if s3path == "" {
|
||||
s3path = "/run/secrets/s3_credentials"
|
||||
}
|
||||
s3config, err := storage.ReadConfig(s3path)
|
||||
if err != nil {
|
||||
log.Fatal().Msg("S3 application credentials unavailable")
|
||||
}
|
||||
objects, err := storage.FromConfig(s3config)
|
||||
if err != nil {
|
||||
log.Fatal().Msg("invalid S3 endpoint")
|
||||
}
|
||||
if *bootstrapS3 {
|
||||
root, e := storage.ReadConfig("/run/secrets/s3_root")
|
||||
if e != nil {
|
||||
log.Fatal().Msg("S3 bootstrap credentials unavailable")
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
if e = storage.Bootstrap(ctx, root, s3config); e != nil {
|
||||
log.Fatal().Err(e).Msg("S3 bootstrap failed")
|
||||
}
|
||||
return
|
||||
}
|
||||
pc, err := pgxpool.ParseConfig(dsn)
|
||||
if err != nil {
|
||||
log.Fatal().Msg("invalid database configuration")
|
||||
}
|
||||
pc.MaxConns = cfg.MaxConns
|
||||
pc.MinConns = 0
|
||||
pc.ConnConfig.ConnectTimeout = time.Second
|
||||
pc.ConnConfig.RuntimeParams["statement_timeout"] = "2000"
|
||||
pc.ConnConfig.RuntimeParams["lock_timeout"] = "1000"
|
||||
pool, err := pgxpool.NewWithConfig(context.Background(), pc)
|
||||
if err != nil {
|
||||
log.Fatal().Msg("database initialization failed")
|
||||
}
|
||||
defer pool.Close()
|
||||
var cache *redis.Client
|
||||
if url, e := config.ReadSecret(cfg.CacheURLFile); e == nil {
|
||||
opts, e := redis.ParseURL(url)
|
||||
if e != nil {
|
||||
log.Fatal().Msg("invalid cache configuration")
|
||||
}
|
||||
opts.MaxRetries = 0
|
||||
opts.DialTimeout = 80 * time.Millisecond
|
||||
opts.ReadTimeout = 80 * time.Millisecond
|
||||
opts.WriteTimeout = 80 * time.Millisecond
|
||||
cache = redis.NewClient(opts)
|
||||
defer func() { _ = cache.Close() }()
|
||||
}
|
||||
store := postgres.New(pool, cache)
|
||||
if *reconcile {
|
||||
cursor := uuid.Nil
|
||||
if *after != "" {
|
||||
cursor, err = uuid.Parse(*after)
|
||||
if err != nil {
|
||||
log.Fatal().Msg("invalid metadata cursor")
|
||||
}
|
||||
}
|
||||
if len(*objectAfter) > 64 {
|
||||
log.Fatal().Msg("object cursor too long")
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
report, e := usecase.NewReconciler(store, objects, time.Now).Run(ctx, cursor, *objectAfter, *grace, *apply)
|
||||
if err = json.NewEncoder(os.Stdout).Encode(report); err != nil {
|
||||
log.Fatal().Msg("reconciliation report write failed")
|
||||
}
|
||||
if e != nil {
|
||||
log.Fatal().Err(e).Msg("reconciliation incomplete")
|
||||
}
|
||||
return
|
||||
}
|
||||
app := usecase.NewMessenger(store)
|
||||
auth := usecase.NewAuth(store, password.New(), app, time.Duration(cfg.SessionTTLSeconds)*time.Second, time.Now)
|
||||
attachments := usecase.NewAttachments(store, app, objects)
|
||||
probeDependencies := func(ctx context.Context) error {
|
||||
if e := pool.Ping(ctx); e != nil {
|
||||
return e
|
||||
}
|
||||
return objects.Ready(ctx)
|
||||
}
|
||||
h := handler.New(app, auth, attachments, probeDependencies, handler.Limits{
|
||||
MaxBodyBytes: cfg.MaxBodyBytes,
|
||||
MaxInflight: cfg.MaxInflight,
|
||||
MaxQueue: cfg.MaxQueue,
|
||||
QueueTimeout: cfg.QueueTimeout,
|
||||
}, func() any {
|
||||
return map[string]any{"pool_total": pool.Stat().TotalConns(), "pool_acquired": pool.Stat().AcquiredConns(), "pool_max": pool.Stat().MaxConns()}
|
||||
}, &log)
|
||||
srv := server.New(cfg.Addr(), h.Router())
|
||||
|
||||
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
|
||||
defer stop()
|
||||
|
||||
serveErr := make(chan error, 1)
|
||||
go func() { serveErr <- srv.ListenAndServe() }()
|
||||
log.Info().Str("addr", cfg.Addr()).Str("env", cfg.Env).
|
||||
Int("max_inflight", cfg.MaxInflight).
|
||||
Int("max_queue", cfg.MaxQueue).Msg("server started")
|
||||
|
||||
select {
|
||||
case err := <-serveErr:
|
||||
log.Fatal().Err(err).Msg("server failed")
|
||||
case <-ctx.Done():
|
||||
}
|
||||
|
||||
started := time.Now()
|
||||
log.Info().Dur("timeout", cfg.ShutdownTimeout).Msg("shutdown signal received, draining")
|
||||
h.Drain()
|
||||
shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout)
|
||||
defer cancel()
|
||||
if err := srv.Shutdown(shutdownCtx); err != nil {
|
||||
log.Error().Err(err).Msg("shutdown timed out, open requests aborted")
|
||||
}
|
||||
if err := <-serveErr; err != nil && !errors.Is(err, http.ErrServerClosed) {
|
||||
log.Error().Err(err).Msg("server error")
|
||||
}
|
||||
log.Info().Dur("took", time.Since(started)).Msg("shutdown complete")
|
||||
}
|
||||
|
||||
// probe — healthcheck без curl в образе distroless: сам бинарник ходит в
|
||||
// /health/ready и возвращает код выхода для Docker.
|
||||
func probe(port int) int {
|
||||
client := http.Client{Timeout: 2 * time.Second}
|
||||
resp, err := client.Get(fmt.Sprintf("http://127.0.0.1:%d/health/ready", port))
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"backend/internal/adapter/imagefile"
|
||||
"backend/internal/adapter/queue"
|
||||
"backend/internal/adapter/repository/postgres"
|
||||
"backend/internal/adapter/storage"
|
||||
"backend/internal/application/usecase"
|
||||
"backend/internal/config"
|
||||
"context"
|
||||
"flag"
|
||||
"fmt"
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
"github.com/redis/go-redis/v9"
|
||||
"os"
|
||||
"os/signal"
|
||||
"strconv"
|
||||
"syscall"
|
||||
"time"
|
||||
)
|
||||
|
||||
func main() {
|
||||
replay := flag.String("replay", "", "replay failed attachment UUID")
|
||||
advance := flag.String("advance", "", "new version for ready/failed attachment UUID")
|
||||
fault := flag.String("fault", "", "test-only crash point: after_original/after_objects/after_commit")
|
||||
flag.Parse()
|
||||
cfg, e := config.Load()
|
||||
must(e)
|
||||
dsn, e := config.ReadSecret(cfg.DatabaseURLFile)
|
||||
must(e)
|
||||
pc, e := pgxpool.ParseConfig(dsn)
|
||||
must(e)
|
||||
pc.MaxConns = 2
|
||||
pc.ConnConfig.ConnectTimeout = time.Second
|
||||
pc.ConnConfig.RuntimeParams["statement_timeout"] = "2000"
|
||||
pc.ConnConfig.RuntimeParams["lock_timeout"] = "1000"
|
||||
pool, e := pgxpool.NewWithConfig(context.Background(), pc)
|
||||
must(e)
|
||||
defer pool.Close()
|
||||
repo := postgres.New(pool, nil)
|
||||
if *replay != "" || *advance != "" {
|
||||
s := *replay
|
||||
if s == "" {
|
||||
s = *advance
|
||||
}
|
||||
id, e := uuid.Parse(s)
|
||||
must(e)
|
||||
var ok bool
|
||||
if *replay != "" {
|
||||
ok, e = repo.ReplayJob(context.Background(), id)
|
||||
} else {
|
||||
ok, e = repo.AdvancePipeline(context.Background(), id)
|
||||
}
|
||||
must(e)
|
||||
fmt.Printf("{\"changed\":%v}\n", ok)
|
||||
return
|
||||
}
|
||||
s3path := os.Getenv("S3_CONFIG_FILE")
|
||||
if s3path == "" {
|
||||
s3path = "/run/secrets/s3_credentials"
|
||||
}
|
||||
s3cfg, e := storage.ReadConfig(s3path)
|
||||
must(e)
|
||||
objects, e := storage.FromConfig(s3cfg)
|
||||
must(e)
|
||||
url, e := config.ReadSecret(cfg.CacheURLFile)
|
||||
must(e)
|
||||
opts, e := redis.ParseURL(url)
|
||||
must(e)
|
||||
opts.MaxRetries = 0
|
||||
opts.DialTimeout = time.Second
|
||||
opts.ReadTimeout = 2 * time.Second
|
||||
opts.WriteTimeout = time.Second
|
||||
client := redis.NewClient(opts)
|
||||
defer func() { _ = client.Close() }()
|
||||
attempts := 5
|
||||
if s := os.Getenv("WORKER_MAX_ATTEMPTS"); s != "" {
|
||||
attempts, e = strconv.Atoi(s)
|
||||
must(e)
|
||||
}
|
||||
if attempts < 1 || attempts > 10 {
|
||||
must(fmt.Errorf("attempts out of bounds"))
|
||||
}
|
||||
pipeline := usecase.NewPipeline(repo, objects, imagefile.NewTransformer(), int32(attempts))
|
||||
if *fault != "" {
|
||||
switch *fault {
|
||||
case "after_original", "after_objects", "after_commit":
|
||||
default:
|
||||
must(fmt.Errorf("invalid fault point"))
|
||||
}
|
||||
pipeline.Fault = func(point string) error {
|
||||
if point == *fault {
|
||||
os.Exit(88)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
broker := queue.New(client, repo, uuid.NewString())
|
||||
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
||||
defer stop()
|
||||
logError := func(error) { fmt.Fprintln(os.Stderr, "{\"event\":\"pipeline_dependency_error\"}") }
|
||||
cleanupDone := make(chan struct{})
|
||||
go func() {
|
||||
defer close(cleanupDone)
|
||||
ticker := time.NewTicker(time.Second)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
cleanup, cancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
e := pipeline.Cleanup(cleanup)
|
||||
cancel()
|
||||
if e != nil {
|
||||
logError(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
done := make(chan struct{})
|
||||
go func() { defer close(done); broker.RunPublisher(ctx, logError) }()
|
||||
broker.RunWorker(ctx, pipeline.Process, logError)
|
||||
stop()
|
||||
<-done
|
||||
<-cleanupDone
|
||||
}
|
||||
func must(e error) {
|
||||
if e != nil {
|
||||
fmt.Fprintln(os.Stderr, "worker initialization/operation failed")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package: handler
|
||||
generate:
|
||||
models: true
|
||||
chi-server: true
|
||||
strict-server: true
|
||||
output: api.gen.go
|
||||
output-options:
|
||||
overlay:
|
||||
path: ../../../generator-overlay.yaml
|
||||
# date-time -> handler.Timestamp: ровно 6 цифр дробной части (см. timestamp.go)
|
||||
type-mapping:
|
||||
string:
|
||||
formats:
|
||||
date-time:
|
||||
type: Timestamp
|
||||
@@ -0,0 +1,25 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"embed"
|
||||
_ "github.com/jackc/pgx/v5/stdlib"
|
||||
"github.com/pressly/goose/v3"
|
||||
)
|
||||
|
||||
//go:embed migrations/*.sql
|
||||
var migrations embed.FS
|
||||
|
||||
func Migrate(ctx context.Context, dsn string) error {
|
||||
conn, err := sql.Open("pgx", dsn)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() { _ = conn.Close() }()
|
||||
goose.SetBaseFS(migrations)
|
||||
if err = goose.SetDialect("postgres"); err != nil {
|
||||
return err
|
||||
}
|
||||
return goose.UpContext(ctx, conn, "migrations")
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
-- +goose Up
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
chat_count integer NOT NULL DEFAULT 0 CHECK (chat_count BETWEEN 0 AND 1000),
|
||||
message_count integer NOT NULL DEFAULT 0 CHECK (message_count BETWEEN 0 AND 1000000),
|
||||
attachment_count integer NOT NULL DEFAULT 0 CHECK (attachment_count BETWEEN 0 AND 10000)
|
||||
);
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX member_chats ON chat_members(user_id,chat_id);
|
||||
CREATE INDEX chats_order ON chats(created_at,id);
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
sender_id uuid NOT NULL REFERENCES users(id),
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 0 AND 4000),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
FOREIGN KEY (chat_id,sender_id) REFERENCES chat_members(chat_id,user_id)
|
||||
);
|
||||
CREATE INDEX messages_history ON messages(chat_id,created_at,id);
|
||||
CREATE TABLE sessions (
|
||||
token_hash text PRIMARY KEY CHECK (length(token_hash)=64),
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
expires_at timestamptz NOT NULL
|
||||
);
|
||||
CREATE INDEX sessions_user ON sessions(user_id,expires_at);
|
||||
|
||||
-- +goose Down
|
||||
DROP TABLE sessions;
|
||||
DROP TABLE messages;
|
||||
DROP TABLE chat_members;
|
||||
DROP TABLE chats;
|
||||
DROP TABLE users;
|
||||
@@ -0,0 +1,12 @@
|
||||
-- +goose Up
|
||||
CREATE TABLE idempotency (
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
|
||||
payload_hash text NOT NULL CHECK (length(payload_hash)=64),
|
||||
message_id uuid NOT NULL REFERENCES messages(id) DEFERRABLE INITIALLY DEFERRED,
|
||||
expires_at timestamptz NOT NULL,
|
||||
PRIMARY KEY(user_id,chat_id,key)
|
||||
);
|
||||
-- +goose Down
|
||||
DROP TABLE idempotency;
|
||||
@@ -0,0 +1,49 @@
|
||||
-- +goose Up
|
||||
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 CHECK(char_length(filename) BETWEEN 1 AND 255),
|
||||
content_type text NOT NULL CHECK(content_type IN ('image/png','image/jpeg')),
|
||||
size_bytes bigint NOT NULL CHECK(size_bytes BETWEEN 1 AND 10485760),
|
||||
sha256 text NOT NULL CHECK(sha256 ~ '^[a-f0-9]{64}$'),
|
||||
status text NOT NULL CHECK(status IN ('uploading','queued','processing','ready','failed','missing','abandoned')),
|
||||
pipeline_version integer NOT NULL DEFAULT 1 CHECK(pipeline_version>0),
|
||||
error_code text NOT NULL DEFAULT '',
|
||||
variants jsonb NOT NULL DEFAULT '[]' CHECK(jsonb_typeof(variants)='array' AND jsonb_array_length(variants)<=3),
|
||||
staging_expired boolean NOT NULL DEFAULT false,
|
||||
staging_cleaned boolean NOT NULL DEFAULT false,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
FOREIGN KEY(chat_id,owner_id) REFERENCES chat_members(chat_id,user_id)
|
||||
);
|
||||
CREATE INDEX attachments_owner ON attachments(owner_id,id);
|
||||
CREATE INDEX attachments_staging_cleanup ON attachments(updated_at,id) WHERE NOT staging_cleaned;
|
||||
CREATE TABLE message_attachments (
|
||||
message_id uuid NOT NULL REFERENCES messages(id),
|
||||
attachment_id uuid NOT NULL REFERENCES attachments(id),
|
||||
ordinal integer NOT NULL CHECK(ordinal BETWEEN 0 AND 9),
|
||||
PRIMARY KEY(message_id,ordinal),
|
||||
UNIQUE(message_id,attachment_id)
|
||||
);
|
||||
CREATE INDEX attachment_references ON message_attachments(attachment_id);
|
||||
CREATE TABLE attachment_jobs (
|
||||
id uuid PRIMARY KEY,
|
||||
attachment_id uuid NOT NULL REFERENCES attachments(id),
|
||||
pipeline_version integer NOT NULL CHECK(pipeline_version>0),
|
||||
attempt integer NOT NULL DEFAULT 0 CHECK(attempt>=0),
|
||||
traceparent text NOT NULL DEFAULT '' CHECK(char_length(traceparent)<=55),
|
||||
tracestate text NOT NULL DEFAULT '' CHECK(char_length(tracestate)<=512),
|
||||
lease_id uuid NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000',
|
||||
lease_until timestamptz NOT NULL DEFAULT 'epoch',
|
||||
next_attempt timestamptz NOT NULL DEFAULT 'epoch',
|
||||
published_at timestamptz NOT NULL DEFAULT 'epoch',
|
||||
completed boolean NOT NULL DEFAULT false,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
UNIQUE(attachment_id,pipeline_version)
|
||||
);
|
||||
CREATE INDEX pending_attachment_jobs ON attachment_jobs(next_attempt,published_at) WHERE NOT completed;
|
||||
-- +goose Down
|
||||
DROP TABLE attachment_jobs;
|
||||
DROP TABLE message_attachments;
|
||||
DROP TABLE attachments;
|
||||
@@ -0,0 +1,4 @@
|
||||
-- +goose Up
|
||||
ALTER TABLE attachment_jobs ADD COLUMN replay_count bigint NOT NULL DEFAULT 0 CHECK(replay_count>=0), ADD COLUMN replayed_at timestamptz NOT NULL DEFAULT 'epoch';
|
||||
-- +goose Down
|
||||
ALTER TABLE attachment_jobs DROP COLUMN replay_count, DROP COLUMN replayed_at;
|
||||
@@ -0,0 +1,15 @@
|
||||
-- name: ChargeAttachment :one
|
||||
UPDATE users SET attachment_count=attachment_count+1 WHERE id=$1 AND attachment_count<10000 RETURNING id;
|
||||
-- name: InsertAttachment :one
|
||||
INSERT INTO attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,status)
|
||||
VALUES($1,$2,$3,$4,$5,$6,$7,'uploading') RETURNING *;
|
||||
-- name: GetAttachment :one
|
||||
SELECT * FROM attachments WHERE id=$1 FOR SHARE;
|
||||
-- name: SetAttachmentStatus :execrows
|
||||
UPDATE attachments SET status=$2,updated_at=clock_timestamp() WHERE id=$1 AND status=$3 AND pipeline_version=0;
|
||||
-- name: InsertMessageAttachment :exec
|
||||
INSERT INTO message_attachments(message_id,attachment_id,ordinal) VALUES($1,$2,$3);
|
||||
-- name: MessageAttachments :many
|
||||
SELECT attachment_id FROM message_attachments WHERE message_id=$1 ORDER BY ordinal LIMIT 10;
|
||||
-- name: ReconcileAttachments :many
|
||||
SELECT * FROM attachments WHERE id>$1 ORDER BY id LIMIT 101;
|
||||
@@ -0,0 +1,42 @@
|
||||
-- name: CreateUser :one
|
||||
INSERT INTO users(id,username,display_name,password_hash) VALUES($1,$2,$3,$4)
|
||||
RETURNING id,username,display_name,created_at;
|
||||
-- name: GetUser :one
|
||||
SELECT id,username,display_name,created_at FROM users WHERE id=$1;
|
||||
-- name: Credentials :one
|
||||
SELECT id,password_hash FROM users WHERE username=$1;
|
||||
-- name: ChargeChat :one
|
||||
UPDATE users SET chat_count=chat_count+1 WHERE id=$1 AND chat_count<1000 RETURNING id;
|
||||
-- name: ChargeMessage :one
|
||||
UPDATE users SET message_count=message_count+1 WHERE id=$1 AND message_count<1000000 RETURNING id;
|
||||
-- name: InsertChat :one
|
||||
INSERT INTO chats(id,title) VALUES($1,$2) RETURNING id,title,created_at;
|
||||
-- name: InsertMembers :exec
|
||||
INSERT INTO chat_members(chat_id,user_id) SELECT $1,unnest($2::uuid[]);
|
||||
-- name: GetChat :one
|
||||
SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id)::uuid[] AS members
|
||||
FROM chats c WHERE c.id=$1;
|
||||
-- name: ListChats :many
|
||||
SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id)::uuid[] AS members
|
||||
FROM chats c JOIN chat_members m ON m.chat_id=c.id
|
||||
WHERE m.user_id=sqlc.arg(member_id) AND (c.created_at,c.id)>(sqlc.arg(after_time)::timestamptz,sqlc.arg(after_id)::uuid)
|
||||
ORDER BY c.created_at,c.id LIMIT sqlc.arg(page_limit);
|
||||
-- name: InsertMessage :one
|
||||
INSERT INTO messages(id,chat_id,sender_id,text) VALUES($1,$2,$3,$4) RETURNING id,chat_id,sender_id,text,created_at;
|
||||
-- name: ListMessages :many
|
||||
SELECT m.id,m.chat_id,m.sender_id,m.text,m.created_at,
|
||||
ARRAY(SELECT attachment_id FROM message_attachments WHERE message_id=m.id ORDER BY ordinal LIMIT 10)::uuid[] AS attachment_ids
|
||||
FROM messages m WHERE m.chat_id=$1 AND (m.created_at,m.id)>(sqlc.arg(after_time)::timestamptz,sqlc.arg(after_id)::uuid)
|
||||
ORDER BY m.created_at,m.id LIMIT sqlc.arg(page_limit);
|
||||
-- name: LockSessionOwner :one
|
||||
SELECT id FROM users WHERE id=$1 FOR UPDATE;
|
||||
-- name: DeleteExpiredSessions :exec
|
||||
DELETE FROM sessions WHERE user_id=$1 AND expires_at<=clock_timestamp();
|
||||
-- name: InsertSession :one
|
||||
INSERT INTO sessions(token_hash,user_id,expires_at)
|
||||
SELECT $1,$2,$3 WHERE (SELECT count(*) FROM sessions WHERE user_id=$2)<100
|
||||
RETURNING user_id;
|
||||
-- name: AuthenticateSession :one
|
||||
SELECT user_id FROM sessions WHERE token_hash=$1 AND expires_at>clock_timestamp();
|
||||
-- name: RevokeSession :exec
|
||||
DELETE FROM sessions WHERE token_hash=$1;
|
||||
@@ -0,0 +1,12 @@
|
||||
-- name: ReserveKey :one
|
||||
INSERT INTO idempotency(user_id,chat_id,key,payload_hash,message_id,expires_at)
|
||||
VALUES($1,$2,$3,$4,$5,clock_timestamp()+interval '24 hours')
|
||||
ON CONFLICT(user_id,chat_id,key) DO UPDATE SET payload_hash=excluded.payload_hash,
|
||||
message_id=excluded.message_id,expires_at=excluded.expires_at
|
||||
WHERE idempotency.expires_at<=clock_timestamp()
|
||||
RETURNING message_id;
|
||||
-- name: ReplayMessage :one
|
||||
SELECT m.id,m.chat_id,m.sender_id,m.text,m.created_at,i.payload_hash,
|
||||
ARRAY(SELECT attachment_id FROM message_attachments WHERE message_id=m.id ORDER BY ordinal LIMIT 10)::uuid[] AS attachment_ids
|
||||
FROM idempotency i JOIN messages m ON m.id=i.message_id
|
||||
WHERE i.user_id=$1 AND i.chat_id=$2 AND i.key=$3;
|
||||
@@ -0,0 +1,50 @@
|
||||
-- name: InsertJob :exec
|
||||
INSERT INTO attachment_jobs(id,attachment_id,pipeline_version,traceparent,tracestate)
|
||||
VALUES(sqlc.arg(job_id),sqlc.arg(attachment_id),sqlc.arg(pipeline_version),sqlc.arg(traceparent),sqlc.arg(tracestate));
|
||||
-- name: QueueAttachment :one
|
||||
UPDATE attachments SET status='queued',updated_at=clock_timestamp() WHERE id=$1 AND status='uploading' AND NOT staging_expired RETURNING *;
|
||||
-- name: PendingJobs :many
|
||||
SELECT j.* FROM attachment_jobs j JOIN attachments a ON a.id=j.attachment_id AND a.pipeline_version=j.pipeline_version
|
||||
WHERE NOT j.completed AND a.status IN ('queued','processing') AND j.next_attempt<=clock_timestamp()
|
||||
AND j.lease_until<clock_timestamp() AND j.published_at<clock_timestamp()-interval '2 seconds'
|
||||
ORDER BY j.created_at,j.id LIMIT 100;
|
||||
-- name: Published :exec
|
||||
UPDATE attachment_jobs SET published_at=clock_timestamp() WHERE id=$1;
|
||||
-- name: AcquireJob :one
|
||||
UPDATE attachment_jobs j SET attempt=j.attempt+1,lease_id=sqlc.arg(lease_id),lease_until=clock_timestamp()+sqlc.arg(lease_seconds)::int*interval '1 second'
|
||||
WHERE j.id=sqlc.arg(job_id) AND j.pipeline_version=sqlc.arg(pipeline_version) AND NOT j.completed
|
||||
AND j.next_attempt<=clock_timestamp() AND j.lease_until<clock_timestamp()
|
||||
AND EXISTS(SELECT 1 FROM attachments a WHERE a.id=j.attachment_id AND a.pipeline_version=j.pipeline_version AND a.status IN ('queued','processing'))
|
||||
RETURNING j.*;
|
||||
-- name: ProcessingAttachment :one
|
||||
UPDATE attachments SET status='processing',updated_at=clock_timestamp()
|
||||
WHERE id=sqlc.arg(attachment_id) AND pipeline_version=sqlc.arg(pipeline_version) AND status IN ('queued','processing') RETURNING *;
|
||||
-- name: CompleteAttachment :execrows
|
||||
UPDATE attachments a SET status='ready',variants=sqlc.arg(variants)::jsonb,error_code='',updated_at=clock_timestamp()
|
||||
FROM attachment_jobs j WHERE j.id=sqlc.arg(job_id) AND j.attachment_id=a.id AND j.pipeline_version=a.pipeline_version
|
||||
AND j.lease_id=sqlc.arg(lease_id) AND j.lease_until>clock_timestamp() AND NOT j.completed AND a.status='processing';
|
||||
-- name: CompleteJob :exec
|
||||
UPDATE attachment_jobs SET completed=true,lease_until='epoch' WHERE id=sqlc.arg(job_id) AND lease_id=sqlc.arg(lease_id);
|
||||
-- name: RetryAttachment :execrows
|
||||
UPDATE attachments a SET status=sqlc.arg(next_status),error_code=sqlc.arg(error_code),updated_at=clock_timestamp()
|
||||
FROM attachment_jobs j WHERE j.id=sqlc.arg(job_id) AND j.attachment_id=a.id AND j.pipeline_version=a.pipeline_version
|
||||
AND j.lease_id=sqlc.arg(lease_id) AND j.lease_until>clock_timestamp() AND NOT j.completed AND a.status='processing';
|
||||
-- name: RetryJob :exec
|
||||
UPDATE attachment_jobs SET lease_until='epoch',next_attempt=clock_timestamp()+sqlc.arg(delay_ms)::int*interval '1 millisecond',completed=sqlc.arg(completed)
|
||||
WHERE id=sqlc.arg(job_id) AND lease_id=sqlc.arg(lease_id);
|
||||
-- name: ReplayAttachment :one
|
||||
UPDATE attachments SET status='queued',error_code='',updated_at=clock_timestamp() WHERE id=$1 AND status='failed' AND NOT staging_expired RETURNING *;
|
||||
-- name: ReplayJobs :exec
|
||||
UPDATE attachment_jobs SET replay_count=replay_count+1,replayed_at=clock_timestamp(),completed=false,attempt=0,lease_until='epoch',next_attempt='epoch',published_at='epoch' WHERE attachment_id=$1 AND pipeline_version=$2;
|
||||
-- name: AdvancePipeline :one
|
||||
UPDATE attachments SET status='queued',error_code='',variants='[]',pipeline_version=pipeline_version+1,staging_expired=false,updated_at=clock_timestamp() WHERE id=$1 AND (status='ready' OR (status='failed' AND NOT staging_expired)) RETURNING *;
|
||||
-- name: StagingCleanup :many
|
||||
WITH candidates AS (
|
||||
SELECT id FROM attachments WHERE NOT staging_cleaned AND (status='ready' OR (status IN ('failed','uploading') AND updated_at<clock_timestamp()-interval '24 hours'))
|
||||
ORDER BY updated_at,id LIMIT 20
|
||||
)
|
||||
UPDATE attachments a SET staging_expired=(a.status<>'ready') FROM candidates c WHERE a.id=c.id AND NOT a.staging_cleaned
|
||||
AND (a.status='ready' OR (a.status IN ('failed','uploading') AND a.updated_at<clock_timestamp()-interval '24 hours')) RETURNING a.*;
|
||||
-- name: StagingCleaned :exec
|
||||
UPDATE attachments SET staging_cleaned=true WHERE id=$1 AND (staging_expired OR status='ready');
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
version: '2'
|
||||
sql:
|
||||
- schema: ../migrations
|
||||
queries: queries
|
||||
engine: postgresql
|
||||
gen:
|
||||
go:
|
||||
package: queries
|
||||
out: ../../internal/adapter/repository/postgres/queries
|
||||
sql_package: pgx/v5
|
||||
emit_empty_slices: true
|
||||
overrides:
|
||||
- db_type: uuid
|
||||
go_type: github.com/google/uuid.UUID
|
||||
- db_type: timestamptz
|
||||
go_type: time.Time
|
||||
@@ -0,0 +1,15 @@
|
||||
overlay: 1.0.0
|
||||
info:
|
||||
title: Go DTO generation view; normative contract remains unchanged
|
||||
version: 1.0.0
|
||||
actions:
|
||||
# oapi-codegen 2.8 emits duplicate Body fields for two binary MIME types.
|
||||
# The adapter reads the original bounded request stream and validates both types.
|
||||
- target: $.paths['/api/v1/chats/{chat_id}/attachments'].post.requestBody.content['image/jpeg']
|
||||
remove: true
|
||||
# anyOf expresses runtime requirements, not different Go representations.
|
||||
# The domain enforces text-or-attachments; the adapter keeps strict JSON decoding.
|
||||
- target: $.components.schemas.CreateMessage.anyOf
|
||||
remove: true
|
||||
- target: $.components.schemas.Message.anyOf
|
||||
remove: true
|
||||
+331
@@ -0,0 +1,331 @@
|
||||
module backend
|
||||
|
||||
go 1.27.2
|
||||
|
||||
tool (
|
||||
github.com/golangci/golangci-lint/v2/cmd/golangci-lint
|
||||
github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen
|
||||
github.com/pressly/goose/v3/cmd/goose
|
||||
github.com/sqlc-dev/sqlc/cmd/sqlc
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/go-chi/chi/v5 v5.5.0
|
||||
github.com/google/uuid v1.6.0
|
||||
github.com/oapi-codegen/runtime v1.7.0
|
||||
github.com/rs/zerolog v1.35.1
|
||||
github.com/spf13/viper v1.21.0
|
||||
)
|
||||
|
||||
require (
|
||||
4d63.com/gocheckcompilerdirectives v1.4.0 // indirect
|
||||
4d63.com/gochecknoglobals v0.2.2 // indirect
|
||||
cel.dev/expr v0.25.3 // indirect
|
||||
charm.land/lipgloss/v2 v2.0.6 // indirect
|
||||
codeberg.org/chavacava/garif v0.2.1 // indirect
|
||||
codeberg.org/polyfloyd/go-errorlint v1.9.0 // indirect
|
||||
dev.gaijin.team/go/exhaustruct/v4 v4.0.0 // indirect
|
||||
dev.gaijin.team/go/exhaustruct/v5 v5.2.0 // indirect
|
||||
dev.gaijin.team/go/golib v0.8.1 // indirect
|
||||
filippo.io/edwards25519 v1.2.0 // indirect
|
||||
github.com/4meepo/tagalign v1.4.4 // indirect
|
||||
github.com/Abirdcfly/dupword v0.1.8 // indirect
|
||||
github.com/AdminBenni/iota-mixing v1.0.0 // indirect
|
||||
github.com/AlwxSin/noinlineerr v1.0.6 // indirect
|
||||
github.com/Antonboom/errname v1.1.2 // indirect
|
||||
github.com/Antonboom/nilnil v1.1.2 // indirect
|
||||
github.com/Antonboom/testifylint v1.6.4 // indirect
|
||||
github.com/Azure/azure-sdk-for-go/sdk/azcore v1.24.0 // indirect
|
||||
github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.15.0 // indirect
|
||||
github.com/Azure/azure-sdk-for-go/sdk/internal v1.13.0 // indirect
|
||||
github.com/AzureAD/microsoft-authentication-library-for-go v1.10.1 // indirect
|
||||
github.com/BurntSushi/toml v1.6.0 // indirect
|
||||
github.com/ClickHouse/ch-go v0.75.0 // indirect
|
||||
github.com/ClickHouse/clickhouse-go-linter v1.2.1 // indirect
|
||||
github.com/ClickHouse/clickhouse-go/v2 v2.51.0 // indirect
|
||||
github.com/Djarvur/go-err113 v0.1.1 // indirect
|
||||
github.com/Masterminds/semver/v3 v3.5.0 // indirect
|
||||
github.com/MirrexOne/unqueryvet v1.5.4 // indirect
|
||||
github.com/OpenPeeDeeP/depguard/v2 v2.2.1 // indirect
|
||||
github.com/alecthomas/chroma/v2 v2.27.0 // indirect
|
||||
github.com/alecthomas/go-check-sumtype v0.5.1-0.20260828200218-ae6904d28606 // indirect
|
||||
github.com/alexkohler/nakedret/v2 v2.0.6 // indirect
|
||||
github.com/alexkohler/prealloc v1.1.0 // indirect
|
||||
github.com/alfatraining/structtag v1.0.0 // indirect
|
||||
github.com/alingse/asasalint v0.0.11 // indirect
|
||||
github.com/alingse/nilnesserr v0.2.0 // indirect
|
||||
github.com/andybalholm/brotli v1.3.0 // indirect
|
||||
github.com/antlr4-go/antlr/v4 v4.13.1 // indirect
|
||||
github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect
|
||||
github.com/ashanbrown/forbidigo/v2 v2.3.1 // indirect
|
||||
github.com/ashanbrown/makezero/v2 v2.2.1 // indirect
|
||||
github.com/beorn7/perks v1.0.1 // indirect
|
||||
github.com/bkielbasa/cyclop v1.2.3 // indirect
|
||||
github.com/blizzy78/varnamelen v0.8.0 // indirect
|
||||
github.com/bombsimon/wsl/v4 v4.7.0 // indirect
|
||||
github.com/bombsimon/wsl/v5 v5.9.0 // indirect
|
||||
github.com/breml/bidichk v0.3.3 // indirect
|
||||
github.com/breml/errchkjson v0.4.1 // indirect
|
||||
github.com/butuzov/ireturn v0.4.1 // indirect
|
||||
github.com/butuzov/mirror v1.3.3 // indirect
|
||||
github.com/catenacyber/perfsprint v0.10.1 // indirect
|
||||
github.com/ccojocar/zxcvbn-go v1.0.4 // indirect
|
||||
github.com/cespare/xxhash/v2 v2.3.0 // indirect
|
||||
github.com/charithe/durationcheck v0.0.11 // indirect
|
||||
github.com/charmbracelet/colorprofile v0.4.3 // indirect
|
||||
github.com/charmbracelet/ultraviolet v0.0.0-20260811164956-006e29f97886 // indirect
|
||||
github.com/charmbracelet/x/ansi v0.11.8 // indirect
|
||||
github.com/charmbracelet/x/term v0.2.2 // indirect
|
||||
github.com/charmbracelet/x/termios v0.1.1 // indirect
|
||||
github.com/charmbracelet/x/windows v0.2.2 // indirect
|
||||
github.com/ckaznocha/intrange v0.3.1 // indirect
|
||||
github.com/clipperhouse/displaywidth v0.11.0 // indirect
|
||||
github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
|
||||
github.com/coder/websocket v1.8.15 // indirect
|
||||
github.com/coreos/go-semver v0.3.1 // indirect
|
||||
github.com/cubicdaiya/gonp v1.0.4 // indirect
|
||||
github.com/curioswitch/go-reassign v0.3.0 // indirect
|
||||
github.com/daixiang0/gci v0.13.7 // indirect
|
||||
github.com/dave/dst v0.27.3 // indirect
|
||||
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
|
||||
github.com/denis-tingaikin/go-header v0.5.0 // indirect
|
||||
github.com/dlclark/regexp2/v2 v2.2.1 // indirect
|
||||
github.com/dprotaso/go-yit v0.0.0-20220510233725-9ba8df137936 // indirect
|
||||
github.com/dustin/go-humanize v1.1.0 // indirect
|
||||
github.com/elastic/go-sysinfo v1.15.5 // indirect
|
||||
github.com/elastic/go-windows v1.0.2 // indirect
|
||||
github.com/ettle/strcase v0.2.0 // indirect
|
||||
github.com/fatih/color v1.19.0 // indirect
|
||||
github.com/fatih/structtag v1.2.0 // indirect
|
||||
github.com/firefart/nonamedreturns v1.0.8 // indirect
|
||||
github.com/fsnotify/fsnotify v1.9.0 // indirect
|
||||
github.com/fzipp/gocyclo v0.6.0 // indirect
|
||||
github.com/getkin/kin-openapi v0.142.0 // indirect
|
||||
github.com/ghostiam/protogetter v1.0.1 // indirect
|
||||
github.com/go-critic/go-critic v0.15.0 // indirect
|
||||
github.com/go-faster/city v1.0.1 // indirect
|
||||
github.com/go-faster/errors v0.8.0 // indirect
|
||||
github.com/go-openapi/jsonpointer v0.23.1 // indirect
|
||||
github.com/go-openapi/swag/jsonname v0.26.0 // indirect
|
||||
github.com/go-sql-driver/mysql v1.10.1 // indirect
|
||||
github.com/go-toolsmith/astcast v1.1.0 // indirect
|
||||
github.com/go-toolsmith/astcopy v1.1.0 // indirect
|
||||
github.com/go-toolsmith/astequal v1.2.0 // indirect
|
||||
github.com/go-toolsmith/astfmt v1.1.0 // indirect
|
||||
github.com/go-toolsmith/astp v1.1.0 // indirect
|
||||
github.com/go-toolsmith/strparse v1.1.0 // indirect
|
||||
github.com/go-toolsmith/typep v1.1.0 // indirect
|
||||
github.com/go-viper/mapstructure/v2 v2.5.0 // indirect
|
||||
github.com/go-xmlfmt/xmlfmt v1.1.3 // indirect
|
||||
github.com/gobwas/glob v0.2.3 // indirect
|
||||
github.com/godoc-lint/godoc-lint v0.11.4 // indirect
|
||||
github.com/gofrs/flock v0.13.1 // indirect
|
||||
github.com/golang-jwt/jwt/v4 v4.5.2 // indirect
|
||||
github.com/golang-jwt/jwt/v5 v5.3.1 // indirect
|
||||
github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
|
||||
github.com/golang-sql/sqlexp v0.1.0 // indirect
|
||||
github.com/golang/protobuf v1.5.4 // indirect
|
||||
github.com/golangci/asciicheck v0.5.0 // indirect
|
||||
github.com/golangci/canonicalheader v0.0.0-20260827115959-a25c71c521f6 // indirect
|
||||
github.com/golangci/dupl v0.0.0-20260401084720-c99c5cf5c202 // indirect
|
||||
github.com/golangci/go-printf-func-name v0.1.1 // indirect
|
||||
github.com/golangci/gofmt v0.0.0-20260820135601-e84e05053792 // indirect
|
||||
github.com/golangci/golangci-lint/v2 v2.14.0 // indirect
|
||||
github.com/golangci/golines v0.15.0 // indirect
|
||||
github.com/golangci/misspell v0.8.0 // indirect
|
||||
github.com/golangci/plugin-module-register v0.1.2 // indirect
|
||||
github.com/golangci/revgrep v0.8.0 // indirect
|
||||
github.com/golangci/rowserrcheck v0.0.0-20260419091836-c5f79b8a11ba // indirect
|
||||
github.com/golangci/swaggoswag v0.0.0-20250504205917-77f2aca3143e // indirect
|
||||
github.com/golangci/unconvert v0.0.0-20250410112200-a129a6e6413e // indirect
|
||||
github.com/google/cel-go v0.28.0 // indirect
|
||||
github.com/google/go-cmp v0.7.0 // indirect
|
||||
github.com/gordonklaus/ineffassign v0.2.0 // indirect
|
||||
github.com/gostaticanalysis/analysisutil v0.7.1 // indirect
|
||||
github.com/gostaticanalysis/comment v1.5.0 // indirect
|
||||
github.com/gostaticanalysis/forcetypeassert v0.2.0 // indirect
|
||||
github.com/gostaticanalysis/nilerr v0.1.2 // indirect
|
||||
github.com/hashicorp/go-immutable-radix/v2 v2.1.0 // indirect
|
||||
github.com/hashicorp/go-version v1.9.0 // indirect
|
||||
github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
|
||||
github.com/hexops/gotextdiff v1.0.3 // indirect
|
||||
github.com/inconshreveable/mousetrap v1.1.0 // indirect
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
|
||||
github.com/jackc/pgx/v5 v5.13.0 // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.3 // indirect
|
||||
github.com/jgautheron/goconst v1.11.0 // indirect
|
||||
github.com/jinzhu/inflection v1.0.0 // indirect
|
||||
github.com/jjti/go-spancheck v0.6.5 // indirect
|
||||
github.com/joho/godotenv v1.5.1 // indirect
|
||||
github.com/jonboulle/clockwork v0.5.0 // indirect
|
||||
github.com/julz/importas v0.2.0 // indirect
|
||||
github.com/karamaru-alpha/copyloopvar v1.2.2 // indirect
|
||||
github.com/kisielk/errcheck v1.20.0 // indirect
|
||||
github.com/kkHAIKE/contextcheck v1.1.6 // indirect
|
||||
github.com/klauspost/compress v1.20.4 // indirect
|
||||
github.com/klauspost/cpuid/v2 v2.4.0 // indirect
|
||||
github.com/klauspost/crc32 v1.3.0 // indirect
|
||||
github.com/kulti/thelper v0.7.1 // indirect
|
||||
github.com/kunwardeep/paralleltest v1.0.15 // indirect
|
||||
github.com/kylelemons/godebug v1.1.0 // indirect
|
||||
github.com/ldez/exptostd v0.4.5 // indirect
|
||||
github.com/ldez/gomoddirectives v0.10.0 // indirect
|
||||
github.com/ldez/grignotin v0.10.1 // indirect
|
||||
github.com/ldez/structtags v0.6.1 // indirect
|
||||
github.com/ldez/tagliatelle v0.8.0 // indirect
|
||||
github.com/ldez/usetesting v0.5.0 // indirect
|
||||
github.com/leonklingele/grouper v1.1.2 // indirect
|
||||
github.com/lucasb-eyer/go-colorful v1.4.1 // indirect
|
||||
github.com/macabu/inamedparam v0.2.0 // indirect
|
||||
github.com/manuelarte/embeddedstructfieldcheck v0.4.0 // indirect
|
||||
github.com/manuelarte/funcorder v0.6.0 // indirect
|
||||
github.com/maratori/testableexamples v1.0.1 // indirect
|
||||
github.com/maratori/testpackage v1.1.2 // indirect
|
||||
github.com/matoous/godox v1.1.0 // indirect
|
||||
github.com/mattn/go-colorable v0.1.15 // indirect
|
||||
github.com/mattn/go-isatty v0.0.24 // indirect
|
||||
github.com/mattn/go-runewidth v0.0.24 // indirect
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
|
||||
github.com/mfridman/interpolate v0.0.2 // indirect
|
||||
github.com/mfridman/xflag v0.1.0 // indirect
|
||||
github.com/mgechev/revive v1.17.0 // indirect
|
||||
github.com/microsoft/go-mssqldb v1.11.2 // indirect
|
||||
github.com/minio/crc64nvme v1.1.1 // indirect
|
||||
github.com/minio/md5-simd v1.1.2 // indirect
|
||||
github.com/minio/minio-go/v7 v7.4.1 // indirect
|
||||
github.com/mitchellh/go-homedir v1.1.0 // indirect
|
||||
github.com/moricho/tparallel v0.3.2 // indirect
|
||||
github.com/muesli/cancelreader v0.2.2 // indirect
|
||||
github.com/nakabonne/nestif v0.3.1 // indirect
|
||||
github.com/ncruces/go-sqlite3 v0.32.0 // indirect
|
||||
github.com/ncruces/go-strftime v1.1.0 // indirect
|
||||
github.com/ncruces/julianday v1.0.0 // indirect
|
||||
github.com/nishanths/exhaustive v0.13.0 // indirect
|
||||
github.com/nishanths/predeclared v0.2.2 // indirect
|
||||
github.com/nunnatsa/ginkgolinter v0.24.0 // indirect
|
||||
github.com/oapi-codegen/oapi-codegen/v2 v2.8.0 // indirect
|
||||
github.com/oasdiff/yaml v0.1.1 // indirect
|
||||
github.com/oasdiff/yaml3 v0.0.14 // indirect
|
||||
github.com/paulmach/orb v0.14.0 // indirect
|
||||
github.com/pelletier/go-toml/v2 v2.4.3 // indirect
|
||||
github.com/pganalyze/pg_query_go/v6 v6.2.2 // indirect
|
||||
github.com/philhofer/fwd v1.2.0 // indirect
|
||||
github.com/pierrec/lz4/v4 v4.1.33 // indirect
|
||||
github.com/pingcap/errors v0.11.5-0.20250523034308-74f78ae071ee // indirect
|
||||
github.com/pingcap/failpoint v0.0.0-20240528011301-b51a646c7c86 // indirect
|
||||
github.com/pingcap/log v1.1.0 // indirect
|
||||
github.com/pingcap/tidb/pkg/parser v0.0.0-20260418072757-ce92298d1124 // indirect
|
||||
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
|
||||
github.com/pressly/goose/v3 v3.30.0 // indirect
|
||||
github.com/prometheus/client_golang v1.12.1 // indirect
|
||||
github.com/prometheus/client_model v0.2.0 // indirect
|
||||
github.com/prometheus/common v0.32.1 // indirect
|
||||
github.com/prometheus/procfs v0.23.0 // indirect
|
||||
github.com/quasilyte/go-ruleguard v0.4.5 // indirect
|
||||
github.com/quasilyte/go-ruleguard/dsl v0.3.23 // indirect
|
||||
github.com/quasilyte/gogrep v0.5.0 // indirect
|
||||
github.com/quasilyte/regex/syntax v0.0.0-20210819130434-b3f0c404a727 // indirect
|
||||
github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 // indirect
|
||||
github.com/raeperd/recvcheck v0.3.1 // indirect
|
||||
github.com/redis/go-redis/v9 v9.23.0 // indirect
|
||||
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
|
||||
github.com/rivo/uniseg v0.4.7 // indirect
|
||||
github.com/riza-io/grpc-go v0.2.0 // indirect
|
||||
github.com/rogpeppe/go-internal v1.16.0 // indirect
|
||||
github.com/rs/xid v1.6.0 // indirect
|
||||
github.com/ryancurrah/gomodguard v1.4.1 // indirect
|
||||
github.com/ryancurrah/gomodguard/v2 v2.1.3 // indirect
|
||||
github.com/ryanrolds/sqlclosecheck v0.6.0 // indirect
|
||||
github.com/sagikazarmark/locafero v0.11.0 // indirect
|
||||
github.com/sanposhiho/wastedassign/v2 v2.1.0 // indirect
|
||||
github.com/santhosh-tekuri/jsonschema/v6 v6.0.3 // indirect
|
||||
github.com/sashamelentyev/interfacebloat v1.1.0 // indirect
|
||||
github.com/sashamelentyev/usestdlibvars v1.29.0 // indirect
|
||||
github.com/securego/gosec/v2 v2.29.0 // indirect
|
||||
github.com/segmentio/asm v1.2.1 // indirect
|
||||
github.com/sethvargo/go-retry v0.5.0 // indirect
|
||||
github.com/shopspring/decimal v1.6.0 // indirect
|
||||
github.com/sirupsen/logrus v1.10.2 // indirect
|
||||
github.com/sivchari/containedctx v1.0.3 // indirect
|
||||
github.com/sonatard/noctx v0.5.1 // indirect
|
||||
github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
|
||||
github.com/sourcegraph/go-diff v0.9.0 // indirect
|
||||
github.com/speakeasy-api/jsonpath v0.6.3 // indirect
|
||||
github.com/speakeasy-api/openapi v1.24.0 // indirect
|
||||
github.com/spf13/afero v1.15.0 // indirect
|
||||
github.com/spf13/cast v1.10.0 // indirect
|
||||
github.com/spf13/cobra v1.10.2 // indirect
|
||||
github.com/spf13/pflag v1.0.10 // indirect
|
||||
github.com/sqlc-dev/doubleclick v1.0.0 // indirect
|
||||
github.com/sqlc-dev/sqlc v1.31.1 // indirect
|
||||
github.com/ssgreg/nlreturn/v2 v2.2.1 // indirect
|
||||
github.com/stbenjam/no-sprintf-host-port v0.3.1 // indirect
|
||||
github.com/stretchr/objx v0.5.3 // indirect
|
||||
github.com/stretchr/testify v1.12.1 // indirect
|
||||
github.com/subosito/gotenv v1.6.0 // indirect
|
||||
github.com/tetafro/godot v1.5.6 // indirect
|
||||
github.com/tetratelabs/wazero v1.11.0 // indirect
|
||||
github.com/timakin/bodyclose v0.0.0-20260723120731-857993a2939c // indirect
|
||||
github.com/timonwong/loggercheck v0.12.0 // indirect
|
||||
github.com/tinylib/msgp v1.6.4 // indirect
|
||||
github.com/tomarrell/wrapcheck/v2 v2.12.0 // indirect
|
||||
github.com/tommy-muehle/go-mnd/v2 v2.5.1 // indirect
|
||||
github.com/tursodatabase/libsql-client-go v0.0.0-20260528064733-9d5d30a29a60 // indirect
|
||||
github.com/ultraware/funlen v0.2.0 // indirect
|
||||
github.com/ultraware/whitespace v0.2.0 // indirect
|
||||
github.com/uudashr/gocognit v1.2.1 // indirect
|
||||
github.com/uudashr/iface v1.5.1 // indirect
|
||||
github.com/vertica/vertica-sql-go v1.3.9 // indirect
|
||||
github.com/vmware-labs/yaml-jsonpath v0.3.2 // indirect
|
||||
github.com/wasilibs/go-pgquery v0.0.0-20250409022910-10ac41983c07 // indirect
|
||||
github.com/wasilibs/wazero-helpers v0.0.0-20240620070341-3dff1577cd52 // indirect
|
||||
github.com/xen0n/gosmopolitan v1.3.0 // indirect
|
||||
github.com/xo/terminfo v1.0.0 // indirect
|
||||
github.com/yagipy/maintidx v1.0.0 // indirect
|
||||
github.com/yandex-cloud/go-genproto v0.137.0 // indirect
|
||||
github.com/ydb-platform/ydb-go-genproto v0.0.0-20260810123728-f0c151ab31b9 // indirect
|
||||
github.com/ydb-platform/ydb-go-sdk-auth-environ v0.5.3 // indirect
|
||||
github.com/ydb-platform/ydb-go-sdk/v3 v3.156.1 // indirect
|
||||
github.com/ydb-platform/ydb-go-yc v0.12.5 // indirect
|
||||
github.com/ydb-platform/ydb-go-yc-metadata v0.6.2 // indirect
|
||||
github.com/yeya24/promlinter v0.3.0 // indirect
|
||||
github.com/ykadowak/zerologlint v0.1.5 // indirect
|
||||
github.com/zeebo/xxh3 v1.1.0 // indirect
|
||||
github.com/ziutek/mymysql v1.5.4 // indirect
|
||||
gitlab.com/bosi/decorder v0.4.2 // indirect
|
||||
go-simpler.org/musttag v0.14.0 // indirect
|
||||
go-simpler.org/sloglint v0.12.0 // indirect
|
||||
go.augendre.info/arangolint v0.4.0 // indirect
|
||||
go.augendre.info/fatcontext v0.10.1 // indirect
|
||||
go.opentelemetry.io/otel v1.47.0 // indirect
|
||||
go.opentelemetry.io/otel/trace v1.47.0 // indirect
|
||||
go.uber.org/atomic v1.12.0 // indirect
|
||||
go.uber.org/multierr v1.11.0 // indirect
|
||||
go.uber.org/zap v1.28.0 // indirect
|
||||
go.yaml.in/yaml/v3 v3.0.6 // indirect
|
||||
golang.org/x/crypto v0.59.0 // indirect
|
||||
golang.org/x/exp v0.0.0-20261109185158-a52e3aef5920 // indirect
|
||||
golang.org/x/exp/typeparams v0.0.0-20260811152304-ee035b5b010f // indirect
|
||||
golang.org/x/mod v0.42.0 // indirect
|
||||
golang.org/x/net v0.62.0 // indirect
|
||||
golang.org/x/sync v0.25.0 // indirect
|
||||
golang.org/x/sys v0.50.0 // indirect
|
||||
golang.org/x/text v0.44.0 // indirect
|
||||
golang.org/x/tools v0.52.1-0.20261106145633-d407941a339a // indirect
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20261110000943-09e21b237f2c // indirect
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20261110000943-09e21b237f2c // indirect
|
||||
google.golang.org/grpc v1.85.0 // indirect
|
||||
google.golang.org/protobuf v1.36.12 // indirect
|
||||
gopkg.in/ini.v1 v1.67.3 // indirect
|
||||
gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
|
||||
gopkg.in/yaml.v3 v3.0.1 // indirect
|
||||
honnef.co/go/tools v0.8.1 // indirect
|
||||
howett.net/plist v1.0.1 // indirect
|
||||
modernc.org/libc v1.80.2 // indirect
|
||||
modernc.org/mathutil v1.7.1 // indirect
|
||||
modernc.org/memory v1.12.1 // indirect
|
||||
modernc.org/sqlite v1.62.0 // indirect
|
||||
mvdan.cc/gofumpt v0.12.0 // indirect
|
||||
mvdan.cc/unparam v0.0.0-20260823230713-2fa3d841b0c8 // indirect
|
||||
)
|
||||
+1302
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,67 @@
|
||||
package integration
|
||||
|
||||
import (
|
||||
"backend/internal/adapter/storage"
|
||||
"backend/internal/domain/port"
|
||||
"bytes"
|
||||
"context"
|
||||
"github.com/google/uuid"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestS3InventoryAndStatReturnComparableVersionMetadata(t *testing.T) {
|
||||
if os.Getenv("RUN_ISOLATED_RECONCILIATION") != "1" {
|
||||
t.Skip("explicit isolated stand required")
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
||||
defer cancel()
|
||||
cfg, e := storage.ReadConfig("/run/secrets/s3_credentials")
|
||||
if e != nil {
|
||||
t.Fatal("configuration unavailable")
|
||||
}
|
||||
s, e := storage.FromConfig(cfg)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
key := "originals/" + uuid.NewString()
|
||||
defer func() {
|
||||
if err := s.Remove(context.Background(), key); err != nil {
|
||||
t.Error("object fixture cleanup failed")
|
||||
}
|
||||
}()
|
||||
if e = s.Put(ctx, key, bytes.NewReader([]byte("synthetic-version-probe")), 23, "application/octet-stream"); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
stat, e := s.Stat(ctx, key)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
var listed port.Object
|
||||
after := ""
|
||||
found := false
|
||||
for page := 0; page < 10; page++ {
|
||||
rows, more, e := s.List(ctx, after)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
for _, row := range rows {
|
||||
if row.Key == key {
|
||||
listed = row
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if found || !more {
|
||||
break
|
||||
}
|
||||
after = rows[len(rows)-1].Key
|
||||
}
|
||||
if !found {
|
||||
t.Fatal("own object absent from bounded inventory")
|
||||
}
|
||||
if listed.ETag != stat.ETag || listed.Size != stat.Size || !listed.Modified.Equal(stat.Modified) {
|
||||
t.Fatalf("inconsistent version metadata: etag_equal=%t size_equal=%t list_time=%s stat_time=%s", listed.ETag == stat.ETag, listed.Size == stat.Size, listed.Modified.Format(time.RFC3339Nano), stat.Modified.Format(time.RFC3339Nano))
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,111 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/google/uuid"
|
||||
"net/http"
|
||||
|
||||
"backend/internal/domain/model"
|
||||
)
|
||||
|
||||
// Реализация StrictServerInterface: вызвать use-case и перевести результат в
|
||||
// API-модели. Ошибки уходят в writeError, он один решает про HTTP-статус.
|
||||
|
||||
func (h *API) Liveness(context.Context, LivenessRequestObject) (LivenessResponseObject, error) {
|
||||
return Liveness200JSONResponse{Body: Health{Status: Ok}}, nil
|
||||
}
|
||||
|
||||
// Readiness rejects draining instances and unavailable required dependencies.
|
||||
func (h *API) Readiness(ctx context.Context, _ ReadinessRequestObject) (ReadinessResponseObject, error) {
|
||||
if !h.ready.Load() {
|
||||
return nil, errDraining
|
||||
}
|
||||
if err := h.probe(ctx); err != nil {
|
||||
return nil, model.ErrUnavailable
|
||||
}
|
||||
return Readiness200JSONResponse{Body: Health{Status: Ok}}, nil
|
||||
}
|
||||
|
||||
func (h *API) RegisterUser(ctx context.Context, req RegisterUserRequestObject) (RegisterUserResponseObject, error) {
|
||||
if req.Body.Password == nil {
|
||||
return nil, &model.ValidationError{Message: "password is required"}
|
||||
}
|
||||
user, err := h.auth.Register(ctx, req.Body.Username, req.Body.DisplayName, *req.Body.Password)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return RegisterUser201JSONResponse{Body: toUser(user)}, nil
|
||||
}
|
||||
|
||||
func (h *API) CurrentUser(ctx context.Context, _ CurrentUserRequestObject) (CurrentUserResponseObject, error) {
|
||||
return CurrentUser200JSONResponse{Body: toUser(currentUser(ctx))}, nil
|
||||
}
|
||||
|
||||
func (h *API) CreateChat(ctx context.Context, req CreateChatRequestObject) (CreateChatResponseObject, error) {
|
||||
chat, err := h.app.CreateChat(ctx, currentUser(ctx).ID, req.Body.Title, req.Body.MemberIds)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return CreateChat201JSONResponse{Body: toChat(chat)}, nil
|
||||
}
|
||||
|
||||
func (h *API) ListChats(ctx context.Context, req ListChatsRequestObject) (ListChatsResponseObject, error) {
|
||||
page, err := h.app.ListChats(ctx, currentUser(ctx).ID, req.Params.Limit, req.Params.Cursor)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return ListChats200JSONResponse{Body: ChatPage{Items: mapAll(page.Items, toChat), NextCursor: page.NextCursor}}, nil
|
||||
}
|
||||
|
||||
func (h *API) GetChat(ctx context.Context, req GetChatRequestObject) (GetChatResponseObject, error) {
|
||||
chat, err := h.app.GetChat(ctx, currentUser(ctx).ID, req.ChatId)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return GetChat200JSONResponse{Body: toChat(chat)}, nil
|
||||
}
|
||||
|
||||
func (h *API) CreateMessage(ctx context.Context, req CreateMessageRequestObject) (CreateMessageResponseObject, error) {
|
||||
r := ctx.Value(sessionRequestKey{}).(*http.Request)
|
||||
ids := []uuid.UUID{}
|
||||
if req.Body.AttachmentIds != nil {
|
||||
ids = *req.Body.AttachmentIds
|
||||
}
|
||||
msg, err := h.app.SendMessage(ctx, currentUser(ctx).ID, req.ChatId, req.Body.Text, r.Header.Get("Idempotency-Key"), ids)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return CreateMessage201JSONResponse{Body: toMessage(msg)}, nil
|
||||
}
|
||||
|
||||
func (h *API) ListMessages(ctx context.Context, req ListMessagesRequestObject) (ListMessagesResponseObject, error) {
|
||||
page, err := h.app.ListMessages(ctx, currentUser(ctx).ID, req.ChatId, req.Params.Limit, req.Params.Cursor)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return ListMessages200JSONResponse{Body: MessagePage{Items: mapAll(page.Items, toMessage), NextCursor: page.NextCursor}}, nil
|
||||
}
|
||||
|
||||
func toUser(u model.User) User {
|
||||
return User{Id: u.ID, Username: u.Username, DisplayName: u.DisplayName, CreatedAt: Timestamp(u.CreatedAt)}
|
||||
}
|
||||
|
||||
func toChat(c model.Chat) Chat {
|
||||
return Chat{Id: c.ID, Title: c.Title, MemberIds: c.MemberIDs, CreatedAt: Timestamp(c.CreatedAt)}
|
||||
}
|
||||
|
||||
func toMessage(m model.Message) Message {
|
||||
ids := m.AttachmentIDs
|
||||
if ids == nil {
|
||||
ids = []uuid.UUID{}
|
||||
}
|
||||
return Message{Id: m.ID, ChatId: m.ChatID, SenderId: m.SenderID, Text: m.Text, CreatedAt: Timestamp(m.CreatedAt), AttachmentIds: ids}
|
||||
}
|
||||
|
||||
func mapAll[T, R any](items []T, f func(T) R) []R {
|
||||
out := make([]R, len(items))
|
||||
for i, item := range items {
|
||||
out[i] = f(item)
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"backend/internal/adapter/imagefile"
|
||||
"backend/internal/domain/model"
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
func toAttachment(a model.Attachment) Attachment {
|
||||
variants := make([]Variant, 0, len(a.Variants))
|
||||
for _, v := range a.Variants {
|
||||
variants = append(variants, Variant{Name: VariantName(v.Name), ContentType: VariantContentType(v.ContentType), SizeBytes: int(v.SizeBytes), Sha256: v.SHA256, Width: v.Width, Height: v.Height})
|
||||
}
|
||||
var code *string
|
||||
if a.ErrorCode != "" {
|
||||
code = &a.ErrorCode
|
||||
}
|
||||
return Attachment{Id: a.ID, ChatId: a.ChatID, OwnerId: a.OwnerID, Filename: a.Filename, ContentType: AttachmentContentType(a.ContentType), SizeBytes: int(a.SizeBytes), Sha256: a.SHA256, Status: AttachmentStatus(a.Status), Variants: variants, ErrorCode: code, CreatedAt: Timestamp(a.CreatedAt), UpdatedAt: Timestamp(a.UpdatedAt)}
|
||||
}
|
||||
func (h *API) UploadAttachment(ctx context.Context, req UploadAttachmentRequestObject) (UploadAttachmentResponseObject, error) {
|
||||
caller := currentUser(ctx).ID
|
||||
if _, err := h.app.GetChat(ctx, caller, req.ChatId); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
select {
|
||||
case h.uploadGate <- struct{}{}:
|
||||
defer func() { <-h.uploadGate }()
|
||||
case <-ctx.Done():
|
||||
return nil, errOverloaded
|
||||
}
|
||||
r := ctx.Value(sessionRequestKey{}).(*http.Request)
|
||||
if r.ContentLength > model.MaxImageBytes {
|
||||
return nil, errPayloadTooLarge
|
||||
}
|
||||
f, err := imagefile.Inspect(r.Body, req.Params.Filename, r.Header.Get("Content-Type"))
|
||||
if errors.Is(err, imagefile.ErrTooLarge) {
|
||||
return nil, errPayloadTooLarge
|
||||
}
|
||||
if errors.Is(err, imagefile.ErrUnsupported) {
|
||||
return nil, errUnsupportedImage
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer f.Dispose()
|
||||
a, err := h.attachments.Upload(ctx, caller, req.ChatId, req.Params.Filename, f.ContentType, f.SHA256, f.Size, f.File)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return UploadAttachment202JSONResponse{Body: toAttachment(a)}, nil
|
||||
}
|
||||
func (h *API) GetAttachment(ctx context.Context, req GetAttachmentRequestObject) (GetAttachmentResponseObject, error) {
|
||||
a, e := h.attachments.Get(ctx, currentUser(ctx).ID, req.AttachmentId)
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
return GetAttachment200JSONResponse{Body: toAttachment(a)}, nil
|
||||
}
|
||||
|
||||
// Closing in the response visitor keeps the S3 stream alive until serialization completes.
|
||||
type originalResponse struct {
|
||||
body io.ReadCloser
|
||||
size int64
|
||||
mime string
|
||||
}
|
||||
|
||||
func (r originalResponse) VisitDownloadAttachmentResponse(w http.ResponseWriter) error {
|
||||
defer r.body.Close()
|
||||
w.Header().Set("Content-Type", r.mime)
|
||||
w.Header().Set("Content-Length", strconv.FormatInt(r.size, 10))
|
||||
w.Header().Set("X-Content-Type-Options", "nosniff")
|
||||
w.WriteHeader(200)
|
||||
_, err := io.CopyN(w, r.body, r.size)
|
||||
if err != nil {
|
||||
panic(http.ErrAbortHandler)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (h *API) DownloadAttachment(ctx context.Context, req DownloadAttachmentRequestObject) (DownloadAttachmentResponseObject, error) {
|
||||
if _, e := h.attachments.Get(ctx, currentUser(ctx).ID, req.AttachmentId); e != nil {
|
||||
return nil, e
|
||||
}
|
||||
variant := "original"
|
||||
if req.Params.Variant != nil {
|
||||
variant = string(*req.Params.Variant)
|
||||
}
|
||||
a, r, e := h.attachments.Content(ctx, currentUser(ctx).ID, req.AttachmentId, variant)
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
return originalResponse{r, a.SizeBytes, a.ContentType}, nil
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"context"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
type sessionRequestKey struct{}
|
||||
|
||||
func (h *API) CreateSession(ctx context.Context, _ CreateSessionRequestObject) (CreateSessionResponseObject, error) {
|
||||
r := ctx.Value(sessionRequestKey{}).(*http.Request)
|
||||
username, password, ok := r.BasicAuth()
|
||||
if !ok || len(username) > 32 || len(password) > 512 || utf8.RuneCountInString(password) > 128 {
|
||||
return nil, model.ErrUnauthorized
|
||||
}
|
||||
s, err := h.auth.Login(ctx, username, password)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return CreateSession201JSONResponse{Body: Session{Token: s.Token, TokenType: Bearer, ExpiresAt: Timestamp(s.ExpiresAt), User: toUser(s.User)}}, nil
|
||||
}
|
||||
func (h *API) RevokeSession(ctx context.Context, _ RevokeSessionRequestObject) (RevokeSessionResponseObject, error) {
|
||||
r := ctx.Value(sessionRequestKey{}).(*http.Request)
|
||||
parts := strings.Fields(r.Header.Get("Authorization"))
|
||||
if err := h.auth.Logout(ctx, parts[1]); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return RevokeSession204Response{}, nil
|
||||
}
|
||||
func (h *API) requestContext(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
duration := 5 * time.Second
|
||||
if strings.HasSuffix(r.URL.Path, "/attachments") || strings.HasSuffix(r.URL.Path, "/content") {
|
||||
duration = 20 * time.Second
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(r.Context(), duration)
|
||||
defer cancel()
|
||||
if r.URL.Path == "/api/v1/auth/sessions" {
|
||||
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
|
||||
}
|
||||
next.ServeHTTP(w, r.WithContext(context.WithValue(ctx, sessionRequestKey{}, r)))
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"backend/internal/domain/model"
|
||||
)
|
||||
|
||||
var (
|
||||
errRouteNotFound = errors.New("route not found")
|
||||
errMethodNotAllowed = errors.New("method not allowed")
|
||||
errPayloadTooLarge = errors.New("payload too large")
|
||||
errOverloaded = errors.New("overloaded")
|
||||
errDraining = errors.New("draining")
|
||||
errUnsupportedImage = errors.New("unsupported image")
|
||||
)
|
||||
|
||||
type apiError struct {
|
||||
status int
|
||||
code ErrorErrorCode
|
||||
message string
|
||||
}
|
||||
|
||||
// classify — единственное место, где ошибка превращается в HTTP-статус.
|
||||
func classify(err error) apiError {
|
||||
var invalid *model.ValidationError
|
||||
switch {
|
||||
case errors.As(err, &invalid):
|
||||
return apiError{http.StatusBadRequest, InvalidRequest, invalid.Message}
|
||||
case errors.Is(err, model.ErrUnauthorized):
|
||||
return apiError{http.StatusUnauthorized, Unauthorized, "нужна действующая сессия"}
|
||||
case errors.Is(err, model.ErrNotFound), errors.Is(err, errRouteNotFound):
|
||||
return apiError{http.StatusNotFound, NotFound, "объект не найден"}
|
||||
case errors.Is(err, errMethodNotAllowed):
|
||||
return apiError{http.StatusMethodNotAllowed, InvalidRequest, "метод не поддерживается"}
|
||||
case errors.Is(err, model.ErrUsernameTaken):
|
||||
return apiError{http.StatusConflict, Conflict, "username уже занят"}
|
||||
case errors.Is(err, model.ErrConflict):
|
||||
return apiError{http.StatusConflict, Conflict, "конфликт запроса"}
|
||||
case errors.Is(err, model.ErrUnavailable):
|
||||
return apiError{http.StatusServiceUnavailable, Unavailable, "зависимость недоступна"}
|
||||
case errors.Is(err, errPayloadTooLarge):
|
||||
return apiError{http.StatusRequestEntityTooLarge, PayloadTooLarge, "тело запроса больше допустимого"}
|
||||
case errors.Is(err, errUnsupportedImage):
|
||||
return apiError{http.StatusUnsupportedMediaType, UnsupportedMediaType, "нужен корректный PNG или JPEG с верным Content-Type"}
|
||||
case errors.Is(err, model.ErrStorageFull):
|
||||
return apiError{http.StatusServiceUnavailable, Unavailable, "хранилище заполнено, запись невозможна; чтение работает"}
|
||||
case errors.Is(err, errOverloaded):
|
||||
return apiError{http.StatusServiceUnavailable, Unavailable, "сервер перегружен, повторите позже"}
|
||||
case errors.Is(err, errDraining):
|
||||
return apiError{http.StatusServiceUnavailable, Unavailable, "сервер останавливается"}
|
||||
default:
|
||||
return apiError{http.StatusInternalServerError, InternalError, "внутренняя ошибка"}
|
||||
}
|
||||
}
|
||||
|
||||
func (h *API) writeError(w http.ResponseWriter, r *http.Request, err error) {
|
||||
e := classify(err)
|
||||
if e.status == http.StatusInternalServerError {
|
||||
h.log.Error().Err(err).Str("request_id", requestIDFrom(r.Context())).Msg("unexpected error")
|
||||
}
|
||||
if errors.Is(err, errOverloaded) {
|
||||
w.Header().Set("Retry-After", "1")
|
||||
}
|
||||
var body Error
|
||||
body.Error.Code = e.code
|
||||
body.Error.Message = e.message
|
||||
body.Error.RequestId = requestIDFrom(r.Context())
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(e.status)
|
||||
_ = json.NewEncoder(w).Encode(body)
|
||||
}
|
||||
|
||||
// bodyError — JSON синтаксически верен (это проверил jsonBody), но не
|
||||
// подходит к схеме: лишнее поле или неверный тип.
|
||||
func (h *API) bodyError(w http.ResponseWriter, r *http.Request, _ error) {
|
||||
h.writeError(w, r, &model.ValidationError{Message: "тело запроса не соответствует схеме: лишнее поле или неверный тип"})
|
||||
}
|
||||
|
||||
// paramError — path или query параметр не разобрался (UUID, целое число).
|
||||
func (h *API) paramError(w http.ResponseWriter, r *http.Request, _ error) {
|
||||
h.writeError(w, r, &model.ValidationError{Message: "некорректный параметр запроса"})
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
)
|
||||
|
||||
// gate ограничивает одновременную обработку запросов API: не больше inflight
|
||||
// в работе и не больше queue в ожидании слота. Лишние сразу получают 503 с
|
||||
// Retry-After, ждавшие дольше timeout — тоже 503. Так перегрузка превращается
|
||||
// в быстрый предсказуемый отказ, а не в рост горутин, памяти и задержки.
|
||||
type gate struct {
|
||||
slots chan struct{} // nil — без лимита
|
||||
maxQueue int64
|
||||
timeout time.Duration
|
||||
waiting atomic.Int64
|
||||
rejected atomic.Int64
|
||||
}
|
||||
|
||||
func newGate(inflight, queue int, timeout time.Duration) *gate {
|
||||
g := &gate{maxQueue: int64(queue), timeout: timeout}
|
||||
if inflight > 0 {
|
||||
g.slots = make(chan struct{}, inflight)
|
||||
}
|
||||
return g
|
||||
}
|
||||
|
||||
func (g *gate) middleware(reject func(http.ResponseWriter, *http.Request, error)) func(http.Handler) http.Handler {
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if g.slots == nil {
|
||||
next.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
if !g.acquire(r) {
|
||||
g.rejected.Add(1)
|
||||
reject(w, r, errOverloaded)
|
||||
return
|
||||
}
|
||||
defer func() { <-g.slots }()
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func (g *gate) acquire(r *http.Request) bool {
|
||||
select {
|
||||
case g.slots <- struct{}{}:
|
||||
return true
|
||||
default:
|
||||
}
|
||||
if g.waiting.Add(1) > g.maxQueue {
|
||||
g.waiting.Add(-1)
|
||||
return false
|
||||
}
|
||||
defer g.waiting.Add(-1)
|
||||
timer := time.NewTimer(g.timeout)
|
||||
defer timer.Stop()
|
||||
select {
|
||||
case g.slots <- struct{}{}:
|
||||
return true
|
||||
case <-timer.C:
|
||||
return false
|
||||
case <-r.Context().Done():
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
type gateStats struct {
|
||||
Inflight int `json:"inflight"`
|
||||
Waiting int64 `json:"waiting"`
|
||||
Rejected int64 `json:"rejected"`
|
||||
}
|
||||
|
||||
func (g *gate) stats() gateStats {
|
||||
return gateStats{Inflight: len(g.slots), Waiting: g.waiting.Load(), Rejected: g.rejected.Load()}
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// gatedServer пропускает запросы через gate в обработчик, который держит слот,
|
||||
// пока тест не закроет release.
|
||||
func gatedServer(t *testing.T, g *gate) (*httptest.Server, chan struct{}, chan struct{}) {
|
||||
t.Helper()
|
||||
entered, release := make(chan struct{}, 10), make(chan struct{})
|
||||
reject := func(w http.ResponseWriter, _ *http.Request, err error) {
|
||||
if !errors.Is(err, errOverloaded) {
|
||||
t.Errorf("unexpected error %v", err)
|
||||
}
|
||||
w.Header().Set("Retry-After", "1")
|
||||
w.WriteHeader(http.StatusServiceUnavailable)
|
||||
}
|
||||
h := g.middleware(reject)(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
||||
entered <- struct{}{}
|
||||
<-release
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}))
|
||||
srv := httptest.NewServer(h)
|
||||
t.Cleanup(srv.Close)
|
||||
return srv, entered, release
|
||||
}
|
||||
|
||||
func get(t *testing.T, url string) int {
|
||||
t.Helper()
|
||||
resp, err := http.Get(url)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return 0
|
||||
}
|
||||
resp.Body.Close()
|
||||
return resp.StatusCode
|
||||
}
|
||||
|
||||
func waitFor(t *testing.T, cond func() bool) {
|
||||
t.Helper()
|
||||
deadline := time.Now().Add(2 * time.Second)
|
||||
for !cond() {
|
||||
if time.Now().After(deadline) {
|
||||
t.Fatal("condition not reached")
|
||||
}
|
||||
time.Sleep(time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGateRejectsBeyondQueueAndRecovers(t *testing.T) {
|
||||
t.Parallel()
|
||||
g := newGate(1, 1, time.Minute)
|
||||
srv, entered, release := gatedServer(t, g)
|
||||
|
||||
statuses := make(chan int, 2)
|
||||
var wg sync.WaitGroup
|
||||
wg.Go(func() { statuses <- get(t, srv.URL) }) // занимает слот
|
||||
<-entered
|
||||
wg.Go(func() { statuses <- get(t, srv.URL) }) // ждёт в очереди
|
||||
waitFor(t, func() bool { return g.waiting.Load() == 1 })
|
||||
|
||||
if code := get(t, srv.URL); code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("third request: %d, want 503", code)
|
||||
}
|
||||
close(release)
|
||||
wg.Wait()
|
||||
close(statuses)
|
||||
for code := range statuses {
|
||||
if code != http.StatusOK {
|
||||
t.Fatalf("admitted request got %d", code)
|
||||
}
|
||||
}
|
||||
if code := get(t, srv.URL); code != http.StatusOK {
|
||||
t.Fatalf("after load: %d, want recovery to 200", code)
|
||||
}
|
||||
if g.stats().Rejected != 1 {
|
||||
t.Fatalf("rejected %d", g.stats().Rejected)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGateTimesOutQueuedRequest(t *testing.T) {
|
||||
t.Parallel()
|
||||
g := newGate(1, 10, 20*time.Millisecond)
|
||||
srv, entered, release := gatedServer(t, g)
|
||||
defer close(release)
|
||||
|
||||
go get(t, srv.URL)
|
||||
<-entered
|
||||
start := time.Now()
|
||||
if code := get(t, srv.URL); code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("queued request: %d, want 503 after timeout", code)
|
||||
}
|
||||
if time.Since(start) > time.Second {
|
||||
t.Fatal("queue timeout not applied")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"backend/internal/application/usecase"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
"github.com/rs/zerolog"
|
||||
)
|
||||
|
||||
// Limits — защитные лимиты HTTP-слоя (трек 5 «управляемая деградация»).
|
||||
// Нулевое значение отключает лимит.
|
||||
type Limits struct {
|
||||
MaxBodyBytes int64 // больше — 413
|
||||
MaxInflight int // одновременно обрабатываемые запросы API
|
||||
MaxQueue int // ждущие свободного слота; больше — сразу 503
|
||||
QueueTimeout time.Duration // дольше ждал слот — 503
|
||||
}
|
||||
|
||||
// API — driving HTTP-адаптер: реализует StrictServerInterface из api.gen.go.
|
||||
//
|
||||
//go:generate go tool oapi-codegen -config ../../../codegen.yaml ../../../../contracts/openapi.json
|
||||
type API struct {
|
||||
app *usecase.Messenger
|
||||
auth *usecase.Auth
|
||||
attachments *usecase.Attachments
|
||||
uploadGate chan struct{}
|
||||
probe func(context.Context) error
|
||||
limits Limits
|
||||
gate *gate
|
||||
storeStats func() any
|
||||
ready atomic.Bool
|
||||
log *zerolog.Logger
|
||||
}
|
||||
|
||||
// New собирает HTTP-адаптер. storeStats отдаёт состояние хранилища для
|
||||
// /debug/stats.
|
||||
func New(app *usecase.Messenger, auth *usecase.Auth, attachments *usecase.Attachments, probe func(context.Context) error, limits Limits, storeStats func() any, log *zerolog.Logger) *API {
|
||||
h := &API{
|
||||
app: app,
|
||||
auth: auth,
|
||||
attachments: attachments,
|
||||
uploadGate: make(chan struct{}, 1),
|
||||
probe: probe,
|
||||
limits: limits,
|
||||
gate: newGate(limits.MaxInflight, limits.MaxQueue, limits.QueueTimeout),
|
||||
storeStats: storeStats,
|
||||
log: log,
|
||||
}
|
||||
h.ready.Store(true)
|
||||
return h
|
||||
}
|
||||
|
||||
// Drain переводит /health/ready в 503 перед остановкой сервера.
|
||||
func (h *API) Drain() { h.ready.Store(false) }
|
||||
|
||||
func (h *API) Router() http.Handler {
|
||||
r := chi.NewRouter()
|
||||
r.Use(requestID, h.recoverer, h.accessLog, h.requestContext)
|
||||
r.NotFound(func(w http.ResponseWriter, r *http.Request) {
|
||||
h.writeError(w, r, errRouteNotFound)
|
||||
})
|
||||
r.MethodNotAllowed(func(w http.ResponseWriter, r *http.Request) {
|
||||
h.writeError(w, r, errMethodNotAllowed)
|
||||
})
|
||||
|
||||
strict := NewStrictHandlerWithOptions(h, nil, StrictHTTPServerOptions{
|
||||
RequestErrorHandlerFunc: h.bodyError,
|
||||
ResponseErrorHandlerFunc: h.writeError,
|
||||
})
|
||||
api := ServerInterfaceWrapper{Handler: strict, ErrorHandlerFunc: h.paramError}
|
||||
|
||||
// Health и статистика — мимо очереди: под перегрузкой они должны отвечать.
|
||||
r.Get("/health/live", api.Liveness)
|
||||
r.Get("/health/ready", api.Readiness)
|
||||
r.Get("/debug/stats", h.stats)
|
||||
|
||||
r.Route("/api/v1", func(r chi.Router) {
|
||||
r.Use(h.gate.middleware(h.writeError))
|
||||
r.With(h.jsonBody).Post("/users", api.RegisterUser)
|
||||
r.Post("/auth/sessions", api.CreateSession)
|
||||
// Сначала аутентификация, потом тело и доступ к ресурсу.
|
||||
r.Group(func(r chi.Router) {
|
||||
r.Use(h.authenticate, h.validQuery, h.jsonBody)
|
||||
r.Delete("/auth/sessions/current", api.RevokeSession)
|
||||
r.Get("/users/me", api.CurrentUser)
|
||||
r.Post("/chats", api.CreateChat)
|
||||
r.Get("/chats", api.ListChats)
|
||||
r.Get("/chats/{chat_id}", api.GetChat)
|
||||
r.Post("/chats/{chat_id}/messages", api.CreateMessage)
|
||||
r.Get("/chats/{chat_id}/messages", api.ListMessages)
|
||||
r.Post("/chats/{chat_id}/attachments", api.UploadAttachment)
|
||||
r.Get("/attachments/{attachment_id}", api.GetAttachment)
|
||||
r.Get("/attachments/{attachment_id}/content", api.DownloadAttachment)
|
||||
})
|
||||
})
|
||||
return r
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Timestamp подставляется кодогенератором вместо time.Time (codegen.yaml,
|
||||
// type-mapping): RFC 3339 UTC с ровно шестью цифрами дробной части.
|
||||
// time.Time срезает хвостовые нули, а fromisoformat в Python 3.9–3.10
|
||||
// (на нём публичные тесты) понимает дробную часть только из 3 или 6 цифр.
|
||||
type Timestamp time.Time
|
||||
|
||||
const timestampLayout = "2006-01-02T15:04:05.000000Z"
|
||||
|
||||
func (t Timestamp) MarshalJSON() ([]byte, error) {
|
||||
return []byte(`"` + time.Time(t).UTC().Format(timestampLayout) + `"`), nil
|
||||
}
|
||||
|
||||
func (t *Timestamp) UnmarshalJSON(data []byte) error {
|
||||
var parsed time.Time
|
||||
if err := json.Unmarshal(data, &parsed); err != nil {
|
||||
return err
|
||||
}
|
||||
*t = Timestamp(parsed)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Тела запросов с лишними полями — 400 по контракту, а сгенерированный
|
||||
// декодер их молча игнорирует. Строгий разбор подключается методами на
|
||||
// сгенерированных типах.
|
||||
|
||||
func (c *CreateUser) UnmarshalJSON(data []byte) error {
|
||||
type plain CreateUser
|
||||
return decodeStrict(data, (*plain)(c))
|
||||
}
|
||||
|
||||
func (c *CreateChat) UnmarshalJSON(data []byte) error {
|
||||
type plain CreateChat
|
||||
return decodeStrict(data, (*plain)(c))
|
||||
}
|
||||
|
||||
func (c *CreateMessage) UnmarshalJSON(data []byte) error {
|
||||
var fields map[string]json.RawMessage
|
||||
if err := json.Unmarshal(data, &fields); err != nil {
|
||||
return err
|
||||
}
|
||||
raw, ok := fields["text"]
|
||||
if !ok || bytes.Equal(bytes.TrimSpace(raw), []byte("null")) {
|
||||
return fmt.Errorf("text must be a present string")
|
||||
}
|
||||
if ids, ok := fields["attachment_ids"]; ok && bytes.Equal(bytes.TrimSpace(ids), []byte("null")) {
|
||||
return fmt.Errorf("attachment_ids must be an array")
|
||||
}
|
||||
type plain CreateMessage
|
||||
return decodeStrict(data, (*plain)(c))
|
||||
}
|
||||
|
||||
func decodeStrict(data []byte, dst any) error {
|
||||
dec := json.NewDecoder(bytes.NewReader(data))
|
||||
dec.DisallowUnknownFields()
|
||||
return dec.Decode(dst)
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestMessageJSONRequiresStringTextAndArrayIDs(t *testing.T) {
|
||||
for _, body := range []string{`{"attachment_ids":[]}`, `{"text":null,"attachment_ids":[]}`, `{"text":"ok","attachment_ids":null}`} {
|
||||
t.Run(body, func(t *testing.T) {
|
||||
var message CreateMessage
|
||||
if err := json.Unmarshal([]byte(body), &message); err == nil {
|
||||
t.Fatal("accepted a missing/null required field")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"runtime/debug"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"backend/internal/domain/model"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
"github.com/go-chi/chi/v5/middleware"
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type ctxKey int
|
||||
|
||||
const (
|
||||
requestIDKey ctxKey = iota
|
||||
userKey
|
||||
)
|
||||
|
||||
// requestID ставит X-Request-Id в каждый ответ, включая ошибки и health.
|
||||
func requestID(next http.Handler) http.Handler {
|
||||
instance, _ := os.Hostname()
|
||||
if instance == "" {
|
||||
instance = uuid.NewString()
|
||||
}
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
id := uuid.NewString()
|
||||
w.Header().Set("X-Request-Id", id)
|
||||
w.Header().Set("X-Instance-Id", instance)
|
||||
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), requestIDKey, id)))
|
||||
})
|
||||
}
|
||||
|
||||
func requestIDFrom(ctx context.Context) string {
|
||||
id, _ := ctx.Value(requestIDKey).(string)
|
||||
return id
|
||||
}
|
||||
|
||||
// recoverer превращает панику в 500 без деталей; стек — только в лог.
|
||||
func (h *API) recoverer(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
defer func() {
|
||||
rec := recover()
|
||||
if rec == nil {
|
||||
return
|
||||
}
|
||||
if rec == http.ErrAbortHandler {
|
||||
panic(rec)
|
||||
}
|
||||
h.log.Error().Interface("panic", rec).Bytes("stack", debug.Stack()).
|
||||
Str("request_id", requestIDFrom(r.Context())).Msg("panic")
|
||||
h.writeError(w, r, errors.New("panic"))
|
||||
}()
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
// accessLog пишет метод, шаблон маршрута, статус и длительность. Тело, query
|
||||
// и заголовки не логируются: там текст сообщений и идентификаторы.
|
||||
func (h *API) accessLog(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
start := time.Now()
|
||||
ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
|
||||
next.ServeHTTP(ww, r)
|
||||
route := chi.RouteContext(r.Context()).RoutePattern()
|
||||
if route == "" {
|
||||
route = "unmatched"
|
||||
}
|
||||
event := h.log.Info()
|
||||
if ww.Status() >= http.StatusInternalServerError {
|
||||
event = h.log.Warn()
|
||||
}
|
||||
event.Str("request_id", requestIDFrom(r.Context())).
|
||||
Str("method", r.Method).
|
||||
Str("route", route).
|
||||
Int("status", ww.Status()).
|
||||
Dur("duration", time.Since(start)).
|
||||
Msg("request")
|
||||
})
|
||||
}
|
||||
|
||||
// authenticate verifies persisted Bearer sessions for protected business routes.
|
||||
// The session-creation endpoint separately validates Basic credentials.
|
||||
func (h *API) authenticate(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
parts := strings.Fields(r.Header.Get("Authorization"))
|
||||
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
|
||||
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
|
||||
h.writeError(w, r, model.ErrUnauthorized)
|
||||
return
|
||||
}
|
||||
user, err := h.auth.Authenticate(r.Context(), parts[1])
|
||||
if err != nil {
|
||||
if errors.Is(err, model.ErrUnauthorized) {
|
||||
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
|
||||
}
|
||||
h.writeError(w, r, err)
|
||||
return
|
||||
}
|
||||
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), userKey, user)))
|
||||
})
|
||||
}
|
||||
|
||||
// validQuery отсекает query с битым %-экранированием: url.Values молча
|
||||
// выбросил бы такой параметр, и cursor=%%% превратился бы в «с начала».
|
||||
func (h *API) validQuery(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if _, err := url.ParseQuery(r.URL.RawQuery); err != nil {
|
||||
h.writeError(w, r, &model.ValidationError{Message: "некорректная строка запроса"})
|
||||
return
|
||||
}
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
func currentUser(ctx context.Context) model.User {
|
||||
user, _ := ctx.Value(userKey).(model.User)
|
||||
return user
|
||||
}
|
||||
|
||||
// jsonBody читает тело POST с лимитом размера (иначе 413) и отсекает
|
||||
// синтаксически неверный JSON (400) до кодогенерированного декодера: тот
|
||||
// читает только первое JSON-значение и пропустил бы мусор после него.
|
||||
func (h *API) jsonBody(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != http.MethodPost || strings.HasSuffix(r.URL.Path, "/attachments") {
|
||||
next.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
reader := io.Reader(r.Body)
|
||||
if h.limits.MaxBodyBytes > 0 {
|
||||
reader = http.MaxBytesReader(w, r.Body, h.limits.MaxBodyBytes)
|
||||
}
|
||||
body, err := io.ReadAll(reader)
|
||||
var tooLarge *http.MaxBytesError
|
||||
switch {
|
||||
case errors.As(err, &tooLarge):
|
||||
h.writeError(w, r, errPayloadTooLarge)
|
||||
return
|
||||
case err != nil:
|
||||
h.writeError(w, r, &model.ValidationError{Message: "тело запроса не прочитано"})
|
||||
return
|
||||
case !utf8.Valid(body) || !json.Valid(body):
|
||||
h.writeError(w, r, &model.ValidationError{Message: "некорректный JSON"})
|
||||
return
|
||||
}
|
||||
r.Body = io.NopCloser(bytes.NewReader(body))
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"os"
|
||||
"runtime"
|
||||
"runtime/debug"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// stats — расширение за пределами контракта (contracts/extensions.md): память
|
||||
// процесса, учтённый объём хранилища и очередь. Нужен для графиков трека 5.
|
||||
func (h *API) stats(w http.ResponseWriter, _ *http.Request) {
|
||||
var mem runtime.MemStats
|
||||
runtime.ReadMemStats(&mem)
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||||
"rss_bytes": rssBytes(),
|
||||
"heap_alloc": mem.HeapAlloc,
|
||||
"heap_sys": mem.HeapSys,
|
||||
"go_memory_limit": debug.SetMemoryLimit(-1),
|
||||
"num_gc": mem.NumGC,
|
||||
"goroutines": runtime.NumGoroutine(),
|
||||
"gate": h.gate.stats(),
|
||||
"store": h.storeStats(),
|
||||
})
|
||||
}
|
||||
|
||||
// rssBytes читает VmRSS из /proc (только Linux, то есть в контейнере); иначе 0.
|
||||
func rssBytes() int64 {
|
||||
f, err := os.Open("/proc/self/status")
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
defer f.Close()
|
||||
sc := bufio.NewScanner(f)
|
||||
for sc.Scan() {
|
||||
if kb, ok := strings.CutPrefix(sc.Text(), "VmRSS:"); ok {
|
||||
n, _ := strconv.ParseInt(strings.TrimSpace(strings.TrimSuffix(kb, "kB")), 10, 64)
|
||||
return n * 1024
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestRejectsInvalidUTF8BeforeJSONDecoding(t *testing.T) {
|
||||
body := append([]byte(`{"display_name":"`), 0xff)
|
||||
body = append(body, []byte(`"}`)...)
|
||||
request := httptest.NewRequest(http.MethodPost, "/api/v1/users", bytes.NewReader(body))
|
||||
response := httptest.NewRecorder()
|
||||
h := &API{limits: Limits{MaxBodyBytes: 65536}}
|
||||
called := false
|
||||
requestID(h.jsonBody(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { called = true; w.WriteHeader(204) }))).ServeHTTP(response, request)
|
||||
if response.Code != 400 || called {
|
||||
t.Fatalf("invalid UTF-8 reached decoder: status=%d called=%t", response.Code, called)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package imagefile
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"image"
|
||||
_ "image/jpeg"
|
||||
_ "image/png"
|
||||
"io"
|
||||
"os"
|
||||
)
|
||||
|
||||
var ErrTooLarge = errors.New("image too large")
|
||||
var ErrUnsupported = errors.New("invalid image or MIME")
|
||||
|
||||
type File struct {
|
||||
*os.File
|
||||
Size int64
|
||||
SHA256, ContentType string
|
||||
}
|
||||
|
||||
func (f *File) Dispose() { _ = f.Close(); _ = os.Remove(f.Name()) }
|
||||
func Inspect(body io.Reader, filename, mime string) (out *File, err error) {
|
||||
if err = model.ValidateFilename(filename); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if mime != "image/png" && mime != "image/jpeg" {
|
||||
return nil, ErrUnsupported
|
||||
}
|
||||
f, e := os.CreateTemp("", "messenger-upload-*")
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
defer func() {
|
||||
if err != nil {
|
||||
_ = f.Close()
|
||||
_ = os.Remove(f.Name())
|
||||
}
|
||||
}()
|
||||
hash := sha256.New()
|
||||
n, e := io.Copy(io.MultiWriter(f, hash), io.LimitReader(body, model.MaxImageBytes+1))
|
||||
if e != nil {
|
||||
return nil, &model.ValidationError{Message: "incomplete image upload"}
|
||||
}
|
||||
if n > model.MaxImageBytes {
|
||||
return nil, ErrTooLarge
|
||||
}
|
||||
if _, e = f.Seek(0, io.SeekStart); e != nil {
|
||||
return nil, e
|
||||
}
|
||||
cfg, format, e := image.DecodeConfig(f)
|
||||
if e != nil || "image/"+format != mime {
|
||||
return nil, ErrUnsupported
|
||||
}
|
||||
pixels := int64(cfg.Width) * int64(cfg.Height)
|
||||
if cfg.Width < 1 || cfg.Height < 1 || pixels > model.MaxImagePixels {
|
||||
return nil, ErrTooLarge
|
||||
}
|
||||
if _, e = f.Seek(0, io.SeekStart); e != nil {
|
||||
return nil, e
|
||||
}
|
||||
decoded, actual, e := image.Decode(f)
|
||||
if e != nil || actual != format || decoded.Bounds().Dx() != cfg.Width || decoded.Bounds().Dy() != cfg.Height {
|
||||
return nil, ErrUnsupported
|
||||
}
|
||||
if _, e = f.Seek(0, io.SeekStart); e != nil {
|
||||
return nil, e
|
||||
}
|
||||
return &File{f, n, hex.EncodeToString(hash.Sum(nil)), mime}, nil
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package imagefile
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"hash/crc32"
|
||||
"image"
|
||||
"image/png"
|
||||
"io"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func pngBytes(t *testing.T) []byte {
|
||||
t.Helper()
|
||||
var b bytes.Buffer
|
||||
if e := png.Encode(&b, image.NewNRGBA(image.Rect(0, 0, 3, 2))); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
return b.Bytes()
|
||||
}
|
||||
func TestOriginalBytesArePreserved(t *testing.T) {
|
||||
raw := pngBytes(t)
|
||||
f, e := Inspect(bytes.NewReader(raw), "пример.png", "image/png")
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
defer f.Dispose()
|
||||
got, e := io.ReadAll(f)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if !bytes.Equal(got, raw) {
|
||||
t.Fatal("original changed")
|
||||
}
|
||||
}
|
||||
func TestRejectsInvalidImageAndFilename(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name, mime string
|
||||
body []byte
|
||||
want error
|
||||
}{
|
||||
{"a.png", "image/jpeg", pngBytes(t), ErrUnsupported},
|
||||
{"a.png", "image/png", []byte("not an image"), ErrUnsupported},
|
||||
{"a.png", "application/octet-stream", pngBytes(t), ErrUnsupported},
|
||||
{"a.png", "image/png", append(pngBytes(t)[:20], 0), ErrUnsupported},
|
||||
} {
|
||||
t.Run(tc.mime+string(tc.body[:1]), func(t *testing.T) {
|
||||
_, e := Inspect(bytes.NewReader(tc.body), tc.name, tc.mime)
|
||||
if !errors.Is(e, tc.want) {
|
||||
t.Fatalf("got %v, want %v", e, tc.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
for _, name := range []string{"../x.png", "a\\b", "a\x00b", "a\nb", ""} {
|
||||
if _, e := Inspect(bytes.NewReader(pngBytes(t)), name, "image/png"); e == nil {
|
||||
t.Fatalf("accepted unsafe filename %q", name)
|
||||
}
|
||||
}
|
||||
}
|
||||
func TestRejectsOversizedStreamBeforeDecoding(t *testing.T) {
|
||||
_, e := Inspect(io.LimitReader(zeroReader{}, model.MaxImageBytes+1), "a.png", "image/png")
|
||||
if !errors.Is(e, ErrTooLarge) {
|
||||
t.Fatalf("got %v", e)
|
||||
}
|
||||
}
|
||||
|
||||
type zeroReader struct{}
|
||||
|
||||
func (zeroReader) Read(p []byte) (int, error) { clear(p); return len(p), nil }
|
||||
func TestRejectsPixelBombBeforeDecoding(t *testing.T) {
|
||||
raw := pngBytes(t)
|
||||
binary.BigEndian.PutUint32(raw[16:20], 50000)
|
||||
binary.BigEndian.PutUint32(raw[20:24], 50000)
|
||||
binary.BigEndian.PutUint32(raw[29:33], crc32.ChecksumIEEE(raw[12:29]))
|
||||
_, e := Inspect(bytes.NewReader(raw), "huge.png", "image/png")
|
||||
if !errors.Is(e, ErrTooLarge) {
|
||||
t.Fatalf("pixel limit did not apply before decode: %v", e)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
package imagefile
|
||||
|
||||
import (
|
||||
"backend/internal/adapter/password"
|
||||
"bytes"
|
||||
"compress/zlib"
|
||||
"encoding/binary"
|
||||
"hash/crc32"
|
||||
"io"
|
||||
"os"
|
||||
"runtime"
|
||||
"runtime/debug"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// A normal PNG encoder allocates several full-width filter rows itself.
|
||||
// Construct a tiny, highly compressible adversarial fixture as a stream instead.
|
||||
func extremePNG(t *testing.T, interlaced bool) []byte {
|
||||
t.Helper()
|
||||
const width = 40_000_000
|
||||
const height = 1
|
||||
var idat bytes.Buffer
|
||||
z := zlib.NewWriter(&idat)
|
||||
passes := [][4]int{{0, 0, 1, 1}}
|
||||
if interlaced {
|
||||
passes = [][4]int{{0, 0, 8, 8}, {4, 0, 8, 8}, {0, 4, 4, 8}, {2, 0, 4, 4}, {0, 2, 2, 4}, {1, 0, 2, 2}, {0, 1, 1, 2}}
|
||||
}
|
||||
for _, p := range passes {
|
||||
w := (width - p[0] + p[2] - 1) / p[2]
|
||||
h := (height - p[1] + p[3] - 1) / p[3]
|
||||
if width <= p[0] || height <= p[1] || w <= 0 || h <= 0 {
|
||||
continue
|
||||
}
|
||||
for row := 0; row < h; row++ {
|
||||
if _, e := z.Write([]byte{0}); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if _, e := io.CopyN(z, zeroReader{}, int64(w)*8); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
if e := z.Close(); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
var out bytes.Buffer
|
||||
out.Write([]byte{137, 80, 78, 71, 13, 10, 26, 10})
|
||||
chunk := func(kind string, data []byte) {
|
||||
var word [4]byte
|
||||
binary.BigEndian.PutUint32(word[:], uint32(len(data)))
|
||||
out.Write(word[:])
|
||||
out.WriteString(kind)
|
||||
out.Write(data)
|
||||
crc := crc32.NewIEEE()
|
||||
_, _ = crc.Write([]byte(kind))
|
||||
_, _ = crc.Write(data)
|
||||
binary.BigEndian.PutUint32(word[:], crc.Sum32())
|
||||
out.Write(word[:])
|
||||
}
|
||||
header := make([]byte, 13)
|
||||
binary.BigEndian.PutUint32(header[:4], width)
|
||||
binary.BigEndian.PutUint32(header[4:8], height)
|
||||
header[8] = 16
|
||||
header[9] = 6
|
||||
if interlaced {
|
||||
header[12] = 1
|
||||
}
|
||||
chunk("IHDR", header)
|
||||
chunk("IDAT", idat.Bytes())
|
||||
chunk("IEND", nil)
|
||||
return out.Bytes()
|
||||
}
|
||||
func TestWorstCaseImagesWithinBudget(t *testing.T) {
|
||||
if os.Getenv("RUN_IMAGE_STRESS") != "1" {
|
||||
t.Skip("explicit isolated memory experiment required")
|
||||
}
|
||||
old := debug.SetMemoryLimit(1536 * 1024 * 1024)
|
||||
defer debug.SetMemoryLimit(old)
|
||||
for _, interlaced := range []bool{false, true} {
|
||||
raw := extremePNG(t, interlaced)
|
||||
runtime.GC()
|
||||
stop := make(chan struct{})
|
||||
var workers sync.WaitGroup
|
||||
for i := 0; i < 3; i++ {
|
||||
workers.Add(1)
|
||||
go func() {
|
||||
defer workers.Done()
|
||||
for {
|
||||
select {
|
||||
case <-stop:
|
||||
return
|
||||
default:
|
||||
if _, e := password.New().Hash("synthetic-concurrent-KDF"); e != nil {
|
||||
t.Error(e)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
for repeat := 0; repeat < 2; repeat++ {
|
||||
f, e := Inspect(bytes.NewReader(raw), "wide.png", "image/png")
|
||||
if e != nil {
|
||||
close(stop)
|
||||
workers.Wait()
|
||||
t.Fatal(e)
|
||||
}
|
||||
f.Dispose()
|
||||
}
|
||||
close(stop)
|
||||
workers.Wait()
|
||||
runtime.GC()
|
||||
}
|
||||
raw, e := os.ReadFile("/proc/self/status")
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
peak := int64(0)
|
||||
for _, line := range strings.Split(string(raw), "\n") {
|
||||
if strings.HasPrefix(line, "VmHWM:") {
|
||||
fields := strings.Fields(line)
|
||||
peak, e = strconv.ParseInt(fields[1], 10, 64)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
if peak <= 0 || peak >= 2*1024*1024 {
|
||||
t.Fatalf("RSS high-water mark out of budget: %d KiB", peak)
|
||||
}
|
||||
t.Logf("PASS native RGBA64 40000000x1, normal+Adam7, two sequential validations each, 3 concurrent Argon2 workers; peak_rss_kib=%d hard_limit_kib=2097152", peak)
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
package imagefile
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"image"
|
||||
"io"
|
||||
"os"
|
||||
"os/exec"
|
||||
)
|
||||
|
||||
func FitDimensions(w, h, max int) (int, int) {
|
||||
if w <= max && h <= max {
|
||||
return w, h
|
||||
}
|
||||
if w >= h {
|
||||
return max, maxInt(1, h*max/w)
|
||||
}
|
||||
return maxInt(1, w*max/h), max
|
||||
}
|
||||
func maxInt(a, b int) int {
|
||||
if a > b {
|
||||
return a
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
type Transformer struct{}
|
||||
|
||||
func NewTransformer() port.Transformer { return Transformer{} }
|
||||
|
||||
// ImageMagick is a constrained subprocess; no input names or shell fragments are accepted.
|
||||
func (Transformer) Transform(ctx context.Context, r io.Reader) ([]port.ProcessedVariant, error) {
|
||||
input, err := os.CreateTemp("", "pipeline-original-*")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer func() { _ = input.Close(); _ = os.Remove(input.Name()) }()
|
||||
n, err := io.Copy(input, io.LimitReader(r, model.MaxImageBytes+1))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if n > model.MaxImageBytes {
|
||||
return nil, model.ErrInvalidImage
|
||||
}
|
||||
if _, err = input.Seek(0, 0); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
config, _, err := image.DecodeConfig(input)
|
||||
if err != nil || int64(config.Width)*int64(config.Height) > model.MaxImagePixels {
|
||||
return nil, model.ErrInvalidImage
|
||||
}
|
||||
probe := exec.CommandContext(ctx, "convert", "-limit", "memory", "256MiB", "-limit", "map", "256MiB", "-limit", "disk", "0", input.Name()+"[0]", "-auto-orient", "-format", "%w %h", "info:")
|
||||
raw, err := probe.Output()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("image subprocess unavailable: %w", err)
|
||||
}
|
||||
var originalW, originalH int
|
||||
if _, err = fmt.Sscanf(string(raw), "%d %d", &originalW, &originalH); err != nil || int64(originalW)*int64(originalH) > model.MaxImagePixels {
|
||||
return nil, model.ErrInvalidImage
|
||||
}
|
||||
var variants []port.ProcessedVariant
|
||||
for _, v := range []struct {
|
||||
name, mime, geometry, format string
|
||||
crop bool
|
||||
}{{"thumbnail", "image/jpeg", "256x256>", "jpeg", false}, {"crop", "image/jpeg", "128x128^", "jpeg", true}, {"optimized", "image/webp", "1280x1280>", "webp", false}} {
|
||||
geometry := v.geometry
|
||||
if !v.crop {
|
||||
max := 256
|
||||
if v.name == "optimized" {
|
||||
max = 1280
|
||||
}
|
||||
w, h := FitDimensions(originalW, originalH, max)
|
||||
geometry = fmt.Sprintf("%dx%d!", w, h)
|
||||
}
|
||||
args := []string{"-limit", "memory", "256MiB", "-limit", "map", "256MiB", "-limit", "disk", "0", "-limit", "thread", "1", input.Name() + "[0]", "-auto-orient", "-background", "white", "-alpha", "remove", "-alpha", "off", "-strip", "-resize", geometry}
|
||||
if v.crop {
|
||||
args = append(args, "-gravity", "center", "-extent", "128x128")
|
||||
}
|
||||
args = append(args, "-quality", "82", v.format+":-")
|
||||
cmd := exec.CommandContext(ctx, "convert", args...)
|
||||
var out limitedBuffer
|
||||
cmd.Stdout = &out
|
||||
if err = cmd.Run(); err != nil {
|
||||
return nil, fmt.Errorf("image subprocess failed: %w", err)
|
||||
}
|
||||
b := out.Bytes()
|
||||
if len(b) == 0 {
|
||||
return nil, fmt.Errorf("empty variant")
|
||||
}
|
||||
w, h := 0, 0
|
||||
if v.format == "webp" {
|
||||
// Read only geometry through the native decoder; never dump diagnostics/payload.
|
||||
probe := exec.CommandContext(ctx, "identify", "-format", "%w %h", "webp:-")
|
||||
probe.Stdin = bytes.NewReader(b)
|
||||
raw, e := probe.Output()
|
||||
if e != nil {
|
||||
return nil, fmt.Errorf("invalid generated WebP")
|
||||
}
|
||||
if _, e = fmt.Sscanf(string(raw), "%d %d", &w, &h); e != nil {
|
||||
return nil, e
|
||||
}
|
||||
} else {
|
||||
// JPEG dimensions are read through the same strict decoder used for uploads.
|
||||
cfg, _, e := image.DecodeConfig(bytes.NewReader(b))
|
||||
if e != nil {
|
||||
return nil, e
|
||||
}
|
||||
w, h = cfg.Width, cfg.Height
|
||||
}
|
||||
sum := sha256.Sum256(b)
|
||||
variants = append(variants, port.ProcessedVariant{Metadata: model.Variant{Name: v.name, ContentType: v.mime, SHA256: hex.EncodeToString(sum[:]), SizeBytes: int64(len(b)), Width: w, Height: h}, Bytes: b})
|
||||
}
|
||||
return variants, nil
|
||||
}
|
||||
|
||||
type limitedBuffer struct{ bytes.Buffer }
|
||||
|
||||
func (b *limitedBuffer) Write(p []byte) (int, error) {
|
||||
if b.Len()+len(p) > 16*1024*1024 {
|
||||
return 0, fmt.Errorf("variant too large")
|
||||
}
|
||||
return b.Buffer.Write(p)
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
package imagefile
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"image"
|
||||
"image/color"
|
||||
"image/jpeg"
|
||||
"image/png"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestActualVariantsHonorDimensionsAlphaAndEXIF(t *testing.T) {
|
||||
if os.Getenv("RUN_VARIANT_TESTS") != "1" {
|
||||
t.Skip("requires actual ImageMagick runtime")
|
||||
}
|
||||
for _, c := range []struct {
|
||||
name string
|
||||
w, h int
|
||||
orientation bool
|
||||
}{{"landscape", 320, 200, false}, {"tiny", 1, 1, false}, {"portrait", 23, 67, false}, {"exif", 40, 20, true}} {
|
||||
t.Run(c.name, func(t *testing.T) {
|
||||
img := image.NewNRGBA(image.Rect(0, 0, c.w, c.h))
|
||||
img.Set(0, 0, color.NRGBA{R: 255, A: 0})
|
||||
var encoded bytes.Buffer
|
||||
if c.orientation {
|
||||
if e := jpeg.Encode(&encoded, img, &jpeg.Options{Quality: 82}); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
} else {
|
||||
if e := png.Encode(&encoded, img); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
input := encoded.Bytes()
|
||||
if c.orientation {
|
||||
payload := []byte{'E', 'x', 'i', 'f', 0, 0, 'I', 'I', 42, 0, 8, 0, 0, 0, 1, 0, 18, 1, 3, 0, 1, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0}
|
||||
marker := append([]byte{255, 225, 0, byte(len(payload) + 2)}, payload...)
|
||||
input = append(append(append([]byte{}, input[:2]...), marker...), input[2:]...)
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
variants, e := NewTransformer().Transform(ctx, bytes.NewReader(input))
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if len(variants) != 3 {
|
||||
t.Fatalf("want three variants, got %d", len(variants))
|
||||
}
|
||||
w, h := c.w, c.h
|
||||
if c.orientation {
|
||||
w, h = h, w
|
||||
}
|
||||
for _, v := range variants {
|
||||
s := sha256.Sum256(v.Bytes)
|
||||
if v.Metadata.SHA256 != hex.EncodeToString(s[:]) || v.Metadata.SizeBytes != int64(len(v.Bytes)) {
|
||||
t.Fatal("content digest/size mismatch")
|
||||
}
|
||||
wantW, wantH := w, h
|
||||
if v.Metadata.Name == "thumbnail" {
|
||||
wantW, wantH = FitDimensions(w, h, 256)
|
||||
}
|
||||
if v.Metadata.Name == "crop" {
|
||||
wantW, wantH = 128, 128
|
||||
}
|
||||
if v.Metadata.Width != wantW || v.Metadata.Height != wantH {
|
||||
t.Fatalf("%s: got %dx%d want %dx%d", v.Metadata.Name, v.Metadata.Width, v.Metadata.Height, wantW, wantH)
|
||||
}
|
||||
if v.Metadata.ContentType == "image/jpeg" {
|
||||
decoded, e := jpeg.Decode(bytes.NewReader(v.Bytes))
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if decoded.Bounds().Dx() != wantW || decoded.Bounds().Dy() != wantH {
|
||||
t.Fatal("actual JPEG geometry mismatch")
|
||||
}
|
||||
if !c.orientation {
|
||||
r, g, b, _ := decoded.At(0, 0).RGBA()
|
||||
if r < 64000 || g < 64000 || b < 64000 {
|
||||
t.Fatal("alpha was not composited on white")
|
||||
}
|
||||
}
|
||||
} else if len(v.Bytes) < 16 || string(v.Bytes[:4]) != "RIFF" || string(v.Bytes[8:12]) != "WEBP" {
|
||||
t.Fatal("optimized file is not WebP")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package imagefile
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestFitDimensionsPreservesAspectAndDoesNotUpscale(t *testing.T) {
|
||||
for _, c := range []struct{ w, h, max, wantW, wantH int }{{320, 200, 256, 256, 160}, {1, 1, 256, 1, 1}, {1, 400, 256, 1, 256}, {400, 1, 256, 256, 1}, {200, 320, 256, 160, 256}, {1280, 1280, 1280, 1280, 1280}} {
|
||||
w, h := FitDimensions(c.w, c.h, c.max)
|
||||
if w != c.wantW || h != c.wantH {
|
||||
t.Errorf("%+v: got %dx%d", c, w, h)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package password
|
||||
|
||||
import (
|
||||
"backend/internal/domain/port"
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"golang.org/x/crypto/argon2"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type Argon struct{}
|
||||
|
||||
func New() port.Passwords { return Argon{} }
|
||||
func (Argon) Hash(password string) (string, error) {
|
||||
salt := make([]byte, 16)
|
||||
if _, err := rand.Read(salt); err != nil {
|
||||
return "", err
|
||||
}
|
||||
hash := argon2.IDKey([]byte(password), salt, 2, 32*1024, 1, 32)
|
||||
return fmt.Sprintf("argon2id$v19$m32768t2p1$%s$%s", base64.RawStdEncoding.EncodeToString(salt), base64.RawStdEncoding.EncodeToString(hash)), nil
|
||||
}
|
||||
func (Argon) Verify(password, encoded string) bool {
|
||||
parts := strings.Split(encoded, "$")
|
||||
if len(parts) != 5 || parts[0] != "argon2id" || parts[1] != "v19" || parts[2] != "m32768t2p1" {
|
||||
return false
|
||||
}
|
||||
salt, e1 := base64.RawStdEncoding.DecodeString(parts[3])
|
||||
want, e2 := base64.RawStdEncoding.DecodeString(parts[4])
|
||||
if e1 != nil || e2 != nil || len(salt) != 16 || len(want) != 32 {
|
||||
return false
|
||||
}
|
||||
got := argon2.IDKey([]byte(password), salt, 2, 32*1024, 1, 32)
|
||||
return subtle.ConstantTimeCompare(got, want) == 1
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
package queue
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"github.com/google/uuid"
|
||||
"github.com/redis/go-redis/v9"
|
||||
"time"
|
||||
)
|
||||
|
||||
const stream = "attachment-jobs"
|
||||
|
||||
type Broker struct {
|
||||
client *redis.Client
|
||||
store port.PipelineStore
|
||||
consumer string
|
||||
}
|
||||
|
||||
func New(client *redis.Client, store port.PipelineStore, consumer string) *Broker {
|
||||
return &Broker{client, store, consumer}
|
||||
}
|
||||
func (b *Broker) Publish(ctx context.Context) error {
|
||||
jobs, e := b.store.PendingJobs(ctx)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
for _, j := range jobs {
|
||||
j.Attempt++
|
||||
payload := struct {
|
||||
Schema int `json:"schema_version"`
|
||||
Type string `json:"type"`
|
||||
model.Job
|
||||
}{1, "attachment.process.v1", j}
|
||||
raw, e := json.Marshal(payload)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if e = b.client.XAdd(ctx, &redis.XAddArgs{Stream: stream, MaxLen: 10000, Approx: true, Values: map[string]any{"job": string(raw)}}).Err(); e != nil {
|
||||
return e
|
||||
}
|
||||
if e = b.store.Published(ctx, j.ID); e != nil {
|
||||
return e
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (b *Broker) RunPublisher(ctx context.Context, onError func(error)) {
|
||||
tick := time.NewTicker(500 * time.Millisecond)
|
||||
defer tick.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-tick.C:
|
||||
if e := b.Publish(ctx); e != nil {
|
||||
onError(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
func (b *Broker) ack(ctx context.Context, id string) {
|
||||
if b.client.XAck(ctx, stream, "workers", id).Err() == nil {
|
||||
_ = b.client.XDel(ctx, stream, id).Err()
|
||||
}
|
||||
}
|
||||
func (b *Broker) consume(ctx context.Context, m redis.XMessage, process func(context.Context, model.Job) error, onError func(error)) {
|
||||
raw, ok := m.Values["job"].(string)
|
||||
if !ok || len(raw) > 2048 {
|
||||
b.ack(ctx, m.ID)
|
||||
return
|
||||
}
|
||||
var envelope struct {
|
||||
Schema int `json:"schema_version"`
|
||||
Type string `json:"type"`
|
||||
model.Job
|
||||
}
|
||||
decoder := json.NewDecoder(bytes.NewBufferString(raw))
|
||||
decoder.DisallowUnknownFields()
|
||||
if decoder.Decode(&envelope) != nil || envelope.Schema != 1 || envelope.Type != "attachment.process.v1" || envelope.ID == uuid.Nil || envelope.AttachmentID == uuid.Nil || envelope.PipelineVersion < 1 || envelope.Attempt < 1 {
|
||||
b.ack(ctx, m.ID)
|
||||
return
|
||||
}
|
||||
work, cancel := context.WithTimeout(ctx, 20*time.Second)
|
||||
e := process(work, envelope.Job)
|
||||
cancel()
|
||||
if e != nil {
|
||||
onError(e)
|
||||
} else {
|
||||
b.ack(ctx, m.ID)
|
||||
}
|
||||
}
|
||||
func (b *Broker) RunWorker(ctx context.Context, process func(context.Context, model.Job) error, onError func(error)) {
|
||||
for ctx.Err() == nil {
|
||||
e := b.client.XGroupCreateMkStream(ctx, stream, "workers", "0").Err()
|
||||
if e != nil && e.Error() != "BUSYGROUP Consumer Group name already exists" {
|
||||
onError(e)
|
||||
pause(ctx)
|
||||
continue
|
||||
}
|
||||
// Reclaim abandoned PEL entries; the DB lease and version fence are authoritative.
|
||||
claimed, _, e := b.client.XAutoClaim(ctx, &redis.XAutoClaimArgs{Stream: stream, Group: "workers", Consumer: b.consumer, MinIdle: 30 * time.Second, Start: "0-0", Count: 1}).Result()
|
||||
if e == nil && len(claimed) > 0 {
|
||||
for _, m := range claimed {
|
||||
b.consume(ctx, m, process, onError)
|
||||
}
|
||||
continue
|
||||
}
|
||||
rows, e := b.client.XReadGroup(ctx, &redis.XReadGroupArgs{Group: "workers", Consumer: b.consumer, Streams: []string{stream, ">"}, Count: 1, Block: time.Second}).Result()
|
||||
if errors.Is(e, redis.Nil) {
|
||||
continue
|
||||
}
|
||||
if e != nil {
|
||||
onError(e)
|
||||
pause(ctx)
|
||||
continue
|
||||
}
|
||||
for _, row := range rows {
|
||||
for _, m := range row.Messages {
|
||||
b.consume(ctx, m, process, onError)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
func pause(ctx context.Context) {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
case <-time.After(200 * time.Millisecond):
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
package postgres
|
||||
|
||||
import (
|
||||
"backend/internal/adapter/repository/postgres/queries"
|
||||
"backend/internal/domain/model"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
func attachment(r queries.Attachment) model.Attachment {
|
||||
var variants []model.Variant
|
||||
_ = json.Unmarshal(r.Variants, &variants)
|
||||
return model.Attachment{ID: r.ID, ChatID: r.ChatID, OwnerID: r.OwnerID, Filename: r.Filename, ContentType: r.ContentType, SizeBytes: r.SizeBytes, SHA256: r.Sha256, Status: r.Status, CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt, PipelineVersion: r.PipelineVersion, ErrorCode: r.ErrorCode, Variants: variants, StagingExpired: r.StagingExpired, StagingCleaned: r.StagingCleaned}
|
||||
}
|
||||
func (s *Store) ReserveAttachment(ctx context.Context, a model.Attachment) (model.Attachment, error) {
|
||||
tx, e := s.pool.Begin(ctx)
|
||||
if e != nil {
|
||||
return model.Attachment{}, mapErr(e)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
if _, e = q.ChargeAttachment(ctx, a.OwnerID); e != nil {
|
||||
return model.Attachment{}, model.ErrStorageFull
|
||||
}
|
||||
r, e := q.InsertAttachment(ctx, queries.InsertAttachmentParams{ID: a.ID, ChatID: a.ChatID, OwnerID: a.OwnerID, Filename: a.Filename, ContentType: a.ContentType, SizeBytes: a.SizeBytes, Sha256: a.SHA256})
|
||||
if e != nil {
|
||||
return model.Attachment{}, mapErr(e)
|
||||
}
|
||||
if e = tx.Commit(ctx); e != nil {
|
||||
return model.Attachment{}, mapErr(e)
|
||||
}
|
||||
return attachment(r), nil
|
||||
}
|
||||
func (s *Store) GetAttachment(ctx context.Context, id uuid.UUID) (model.Attachment, error) {
|
||||
r, e := s.q.GetAttachment(ctx, id)
|
||||
return attachment(r), mapErr(e)
|
||||
}
|
||||
func (s *Store) SetAttachmentStatus(ctx context.Context, id uuid.UUID, from, to string) (bool, error) {
|
||||
n, e := s.q.SetAttachmentStatus(ctx, queries.SetAttachmentStatusParams{ID: id, Status: to, Status_2: from})
|
||||
return n == 1, mapErr(e)
|
||||
}
|
||||
func (s *Store) ReconcileAttachments(ctx context.Context, after uuid.UUID) ([]model.Attachment, bool, error) {
|
||||
rows, e := s.q.ReconcileAttachments(ctx, after)
|
||||
if e != nil {
|
||||
return nil, false, mapErr(e)
|
||||
}
|
||||
more := len(rows) > 100
|
||||
if more {
|
||||
rows = rows[:100]
|
||||
}
|
||||
out := make([]model.Attachment, len(rows))
|
||||
for i, r := range rows {
|
||||
out[i] = attachment(r)
|
||||
}
|
||||
return out, more, nil
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
package postgres
|
||||
|
||||
import (
|
||||
"backend/internal/adapter/repository/postgres/queries"
|
||||
"backend/internal/domain/model"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"time"
|
||||
)
|
||||
|
||||
func job(r queries.AttachmentJob) model.Job {
|
||||
return model.Job{ID: r.ID, AttachmentID: r.AttachmentID, PipelineVersion: r.PipelineVersion, Attempt: r.Attempt, CreatedAt: r.CreatedAt, Traceparent: r.Traceparent, Tracestate: r.Tracestate}
|
||||
}
|
||||
func (s *Store) QueueAttachment(ctx context.Context, a model.Attachment, tp, ts string) (model.Attachment, error) {
|
||||
tx, e := s.pool.Begin(ctx)
|
||||
if e != nil {
|
||||
return model.Attachment{}, mapErr(e)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
r, e := q.QueueAttachment(ctx, a.ID)
|
||||
if e != nil {
|
||||
return model.Attachment{}, mapErr(e)
|
||||
}
|
||||
if e = q.InsertJob(ctx, queries.InsertJobParams{JobID: uuid.New(), AttachmentID: r.ID, PipelineVersion: r.PipelineVersion, Traceparent: tp, Tracestate: ts}); e != nil {
|
||||
return model.Attachment{}, mapErr(e)
|
||||
}
|
||||
if e = tx.Commit(ctx); e != nil {
|
||||
return model.Attachment{}, mapErr(e)
|
||||
}
|
||||
return attachment(r), nil
|
||||
}
|
||||
func (s *Store) PendingJobs(ctx context.Context) ([]model.Job, error) {
|
||||
rows, e := s.q.PendingJobs(ctx)
|
||||
if e != nil {
|
||||
return nil, mapErr(e)
|
||||
}
|
||||
out := make([]model.Job, len(rows))
|
||||
for i, r := range rows {
|
||||
out[i] = job(r)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
func (s *Store) Published(ctx context.Context, id uuid.UUID) error {
|
||||
return mapErr(s.q.Published(ctx, id))
|
||||
}
|
||||
func (s *Store) AcquireJob(ctx context.Context, j model.Job, lease uuid.UUID, d time.Duration) (model.Job, model.Attachment, bool, error) {
|
||||
tx, e := s.pool.Begin(ctx)
|
||||
if e != nil {
|
||||
return j, model.Attachment{}, false, mapErr(e)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
r, e := q.AcquireJob(ctx, queries.AcquireJobParams{LeaseID: lease, LeaseSeconds: int32(d / time.Second), JobID: j.ID, PipelineVersion: j.PipelineVersion})
|
||||
if errors.Is(e, pgx.ErrNoRows) {
|
||||
return j, model.Attachment{}, false, nil
|
||||
}
|
||||
if e != nil {
|
||||
return j, model.Attachment{}, false, mapErr(e)
|
||||
}
|
||||
a, e := q.ProcessingAttachment(ctx, queries.ProcessingAttachmentParams{AttachmentID: r.AttachmentID, PipelineVersion: r.PipelineVersion})
|
||||
if e != nil {
|
||||
return j, model.Attachment{}, false, mapErr(e)
|
||||
}
|
||||
if e = tx.Commit(ctx); e != nil {
|
||||
return j, model.Attachment{}, false, mapErr(e)
|
||||
}
|
||||
return job(r), attachment(a), true, nil
|
||||
}
|
||||
func (s *Store) CompleteJob(ctx context.Context, j model.Job, lease uuid.UUID, v []model.Variant) (bool, error) {
|
||||
raw, e := json.Marshal(v)
|
||||
if e != nil {
|
||||
return false, e
|
||||
}
|
||||
tx, e := s.pool.Begin(ctx)
|
||||
if e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
n, e := q.CompleteAttachment(ctx, queries.CompleteAttachmentParams{Variants: raw, JobID: j.ID, LeaseID: lease})
|
||||
if e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
if n != 1 {
|
||||
return false, nil
|
||||
}
|
||||
if e = q.CompleteJob(ctx, queries.CompleteJobParams{JobID: j.ID, LeaseID: lease}); e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
return true, mapErr(tx.Commit(ctx))
|
||||
}
|
||||
func (s *Store) RetryJob(ctx context.Context, j model.Job, lease uuid.UUID, code string, delay time.Duration, failed bool) error {
|
||||
status := "queued"
|
||||
if failed {
|
||||
status = "failed"
|
||||
}
|
||||
tx, e := s.pool.Begin(ctx)
|
||||
if e != nil {
|
||||
return mapErr(e)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
n, e := q.RetryAttachment(ctx, queries.RetryAttachmentParams{NextStatus: status, ErrorCode: code, JobID: j.ID, LeaseID: lease})
|
||||
if e != nil {
|
||||
return mapErr(e)
|
||||
}
|
||||
if n == 0 {
|
||||
return nil
|
||||
}
|
||||
if e = q.RetryJob(ctx, queries.RetryJobParams{DelayMs: int32(delay / time.Millisecond), Completed: failed, JobID: j.ID, LeaseID: lease}); e != nil {
|
||||
return mapErr(e)
|
||||
}
|
||||
return mapErr(tx.Commit(ctx))
|
||||
}
|
||||
func (s *Store) ReplayJob(ctx context.Context, id uuid.UUID) (bool, error) {
|
||||
tx, e := s.pool.Begin(ctx)
|
||||
if e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
a, e := q.ReplayAttachment(ctx, id)
|
||||
if errors.Is(e, pgx.ErrNoRows) {
|
||||
return false, nil
|
||||
}
|
||||
if e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
if e = q.ReplayJobs(ctx, queries.ReplayJobsParams{AttachmentID: id, PipelineVersion: a.PipelineVersion}); e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
return true, mapErr(tx.Commit(ctx))
|
||||
}
|
||||
func (s *Store) AdvancePipeline(ctx context.Context, id uuid.UUID) (bool, error) {
|
||||
tx, e := s.pool.Begin(ctx)
|
||||
if e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
a, e := q.AdvancePipeline(ctx, id)
|
||||
if errors.Is(e, pgx.ErrNoRows) {
|
||||
return false, nil
|
||||
}
|
||||
if e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
if e = q.InsertJob(ctx, queries.InsertJobParams{JobID: uuid.New(), AttachmentID: id, PipelineVersion: a.PipelineVersion}); e != nil {
|
||||
return false, mapErr(e)
|
||||
}
|
||||
return true, mapErr(tx.Commit(ctx))
|
||||
}
|
||||
|
||||
func (s *Store) StagingCleanup(ctx context.Context) ([]model.Attachment, error) {
|
||||
rows, e := s.q.StagingCleanup(ctx)
|
||||
if e != nil {
|
||||
return nil, mapErr(e)
|
||||
}
|
||||
out := make([]model.Attachment, len(rows))
|
||||
for i, r := range rows {
|
||||
out[i] = attachment(r)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
func (s *Store) StagingCleaned(ctx context.Context, id uuid.UUID) error {
|
||||
return mapErr(s.q.StagingCleaned(ctx, id))
|
||||
}
|
||||
@@ -0,0 +1,331 @@
|
||||
package postgres
|
||||
|
||||
import (
|
||||
"backend/internal/adapter/storage"
|
||||
"backend/internal/application/usecase"
|
||||
"backend/internal/config"
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
"io"
|
||||
"os"
|
||||
"reflect"
|
||||
"sync"
|
||||
"syscall"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestReplayAfterCompletedPreviousVersionCleanup(t *testing.T) {
|
||||
if os.Getenv("RUN_PIPELINE_DB_TESTS") != "1" {
|
||||
t.Skip("explicit isolated database required")
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
||||
defer cancel()
|
||||
raw, e := config.ReadSecret("/run/secrets/database_url")
|
||||
if e != nil {
|
||||
t.Fatal("database file unavailable")
|
||||
}
|
||||
pool, e := pgxpool.New(ctx, raw)
|
||||
if e != nil {
|
||||
t.Fatal("database connection unavailable")
|
||||
}
|
||||
defer pool.Close()
|
||||
s := New(pool, nil)
|
||||
user, e := s.CreateUser(ctx, model.UserDraft{Username: "v2_" + uuid.NewString()[:8], DisplayName: "Synthetic version test", PasswordHash: "disabled-synthetic"})
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
var chatID, attachmentID uuid.UUID
|
||||
defer func() {
|
||||
cleanup, c := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer c()
|
||||
for _, q := range []struct {
|
||||
sql string
|
||||
id uuid.UUID
|
||||
}{{"DELETE FROM attachment_jobs WHERE attachment_id=$1", attachmentID}, {"DELETE FROM attachments WHERE id=$1", attachmentID}, {"DELETE FROM chat_members WHERE chat_id=$1", chatID}, {"DELETE FROM chats WHERE id=$1", chatID}, {"DELETE FROM users WHERE id=$1", user.ID}} {
|
||||
if _, e := pool.Exec(cleanup, q.sql, q.id); e != nil {
|
||||
t.Error("version fixture cleanup failed")
|
||||
}
|
||||
}
|
||||
}()
|
||||
chat, e := s.CreateChat(ctx, model.ChatDraft{Title: "Owned version fixture", Creator: user.ID, MemberIDs: []uuid.UUID{user.ID}})
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
chatID = chat.ID
|
||||
attachmentID = uuid.New()
|
||||
a, e := s.ReserveAttachment(ctx, model.Attachment{ID: attachmentID, ChatID: chatID, OwnerID: user.ID, Filename: "test.png", ContentType: "image/png", SizeBytes: 3, SHA256: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"})
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if _, e = s.QueueAttachment(ctx, a, "", ""); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
jobs, e := s.PendingJobs(ctx)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
var j model.Job
|
||||
for _, candidate := range jobs {
|
||||
if candidate.AttachmentID == attachmentID {
|
||||
j = candidate
|
||||
}
|
||||
}
|
||||
lease := uuid.New()
|
||||
j, _, ok, e := s.AcquireJob(ctx, j, lease, 30*time.Second)
|
||||
if e != nil || !ok {
|
||||
t.Fatal("version1 acquisition failed")
|
||||
}
|
||||
if ok, e = s.CompleteJob(ctx, j, lease, []model.Variant{}); e != nil || !ok {
|
||||
t.Fatal("version1 completion failed")
|
||||
}
|
||||
if _, e = s.StagingCleanup(ctx); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if e = s.StagingCleaned(ctx, attachmentID); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if ok, e = s.AdvancePipeline(ctx, attachmentID); e != nil || !ok {
|
||||
t.Fatal("version2 advance failed")
|
||||
}
|
||||
jobs, e = s.PendingJobs(ctx)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
for _, candidate := range jobs {
|
||||
if candidate.AttachmentID == attachmentID && candidate.PipelineVersion == 2 {
|
||||
j = candidate
|
||||
}
|
||||
}
|
||||
lease = uuid.New()
|
||||
j, _, ok, e = s.AcquireJob(ctx, j, lease, 30*time.Second)
|
||||
if e != nil || !ok {
|
||||
t.Fatal("version2 acquisition failed")
|
||||
}
|
||||
if e = s.RetryJob(ctx, j, lease, "retry_exhausted", 0, true); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
ok, e = s.ReplayJob(ctx, attachmentID)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if !ok {
|
||||
t.Fatal("ready version1 staging cleanup permanently blocked replay of failed version2 despite retained original")
|
||||
}
|
||||
var replays int
|
||||
var replayed time.Time
|
||||
if e = pool.QueryRow(ctx, "SELECT replay_count,replayed_at FROM attachment_jobs WHERE attachment_id=$1 AND pipeline_version=2", attachmentID).Scan(&replays, &replayed); e != nil || replays != 1 || replayed.IsZero() {
|
||||
t.Fatal("explicit replay has no durable audit count/timestamp")
|
||||
}
|
||||
}
|
||||
|
||||
// This deterministic transformer makes v1/v2 effects distinguishable; the Store,
|
||||
// pipeline ownership/leases, transactions and S3 operations remain real.
|
||||
type versionTransformer struct {
|
||||
body string
|
||||
err error
|
||||
}
|
||||
|
||||
func (v versionTransformer) Transform(context.Context, io.Reader) ([]port.ProcessedVariant, error) {
|
||||
if v.err != nil {
|
||||
return nil, v.err
|
||||
}
|
||||
out := []port.ProcessedVariant{}
|
||||
for _, name := range []string{"thumbnail", "crop", "optimized"} {
|
||||
body := []byte(v.body + name)
|
||||
sum := sha256.Sum256(body)
|
||||
out = append(out, port.ProcessedVariant{Metadata: model.Variant{Name: name, ContentType: "image/jpeg", SHA256: hex.EncodeToString(sum[:]), SizeBytes: int64(len(body)), Width: 1, Height: 1}, Bytes: body})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
func TestVersionedPipelineDuplicateReorderRetryAndCleanup(t *testing.T) {
|
||||
if os.Getenv("RUN_PIPELINE_DB_TESTS") != "1" {
|
||||
t.Skip("explicit isolated database and S3 required")
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 40*time.Second)
|
||||
defer cancel()
|
||||
raw, e := config.ReadSecret("/run/secrets/database_url")
|
||||
if e != nil {
|
||||
t.Fatal("database file unavailable")
|
||||
}
|
||||
pool, e := pgxpool.New(ctx, raw)
|
||||
if e != nil {
|
||||
t.Fatal("database unavailable")
|
||||
}
|
||||
defer pool.Close()
|
||||
s := New(pool, nil)
|
||||
cfg, e := storage.ReadConfig("/run/secrets/s3_credentials")
|
||||
if e != nil {
|
||||
t.Fatal("S3 config unavailable")
|
||||
}
|
||||
objects, e := storage.FromConfig(cfg)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
user, e := s.CreateUser(ctx, model.UserDraft{Username: "matrix_" + uuid.NewString()[:8], DisplayName: "Synthetic fault matrix", PasswordHash: "disabled"})
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
chat, e := s.CreateChat(ctx, model.ChatDraft{Title: "Owned pipeline matrix", Creator: user.ID, MemberIDs: []uuid.UUID{user.ID}})
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
id := uuid.New()
|
||||
body := []byte("immutable-original")
|
||||
sum := sha256.Sum256(body)
|
||||
defer func() {
|
||||
c, stop := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer stop()
|
||||
for _, key := range []string{"staging/" + id.String(), usecase.ObjectKey(id)} {
|
||||
if e := objects.Remove(c, key); e != nil {
|
||||
t.Error("object fixture cleanup failed")
|
||||
}
|
||||
}
|
||||
for version := int32(1); version <= 3; version++ {
|
||||
for _, name := range []string{"thumbnail", "crop", "optimized"} {
|
||||
if e := objects.Remove(c, usecase.VariantKey(id, version, name)); e != nil {
|
||||
t.Error("variant fixture cleanup failed")
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, q := range []struct {
|
||||
sql string
|
||||
id uuid.UUID
|
||||
}{{"DELETE FROM attachment_jobs WHERE attachment_id=$1", id}, {"DELETE FROM attachments WHERE id=$1", id}, {"DELETE FROM chat_members WHERE chat_id=$1", chat.ID}, {"DELETE FROM chats WHERE id=$1", chat.ID}, {"DELETE FROM users WHERE id=$1", user.ID}} {
|
||||
if _, e := pool.Exec(c, q.sql, q.id); e != nil {
|
||||
t.Error("database fixture cleanup failed")
|
||||
}
|
||||
}
|
||||
}()
|
||||
a, e := s.ReserveAttachment(ctx, model.Attachment{ID: id, ChatID: chat.ID, OwnerID: user.ID, Filename: "matrix.png", ContentType: "image/png", SizeBytes: int64(len(body)), SHA256: hex.EncodeToString(sum[:])})
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if e = objects.Put(ctx, "staging/"+id.String(), bytes.NewReader(body), int64(len(body)), "image/png"); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if _, e = s.QueueAttachment(ctx, a, "", ""); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
next := func(version int32) model.Job {
|
||||
t.Helper()
|
||||
jobs, e := s.PendingJobs(ctx)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
for _, j := range jobs {
|
||||
if j.AttachmentID == id && j.PipelineVersion == version {
|
||||
return j
|
||||
}
|
||||
}
|
||||
t.Fatal("owned current job not found")
|
||||
return model.Job{}
|
||||
}
|
||||
j1 := next(1)
|
||||
p1 := usecase.NewPipeline(s, objects, versionTransformer{body: "version1-"}, 5)
|
||||
p1.Fault = func(point string) error {
|
||||
if point == "after_commit" {
|
||||
return errors.New("synthetic crash after commit")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
if e = p1.Process(ctx, j1); e == nil {
|
||||
t.Fatal("fault did not interrupt after commit")
|
||||
}
|
||||
a, e = s.GetAttachment(ctx, id)
|
||||
if e != nil || a.Status != "ready" || a.StagingCleaned {
|
||||
t.Fatal("commit fault did not preserve ready/pending cleanup")
|
||||
}
|
||||
if e = p1.Process(ctx, j1); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if _, e = objects.Get(ctx, "staging/"+id.String()); !errors.Is(e, model.ErrNotFound) {
|
||||
t.Fatal("completed redelivery did not remove staging")
|
||||
}
|
||||
if ok, e := s.AdvancePipeline(ctx, id); e != nil || !ok {
|
||||
t.Fatal("advance v2 failed")
|
||||
}
|
||||
j2 := next(2)
|
||||
// Old delivery arriving before v2 and a fabricated future delivery are no-ops.
|
||||
if e = p1.Process(ctx, j1); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
future := j2
|
||||
future.PipelineVersion = 3
|
||||
if e = p1.Process(ctx, future); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
p2 := usecase.NewPipeline(s, objects, versionTransformer{body: "version2-"}, 5)
|
||||
var group sync.WaitGroup
|
||||
errs := make(chan error, 2)
|
||||
for i := 0; i < 2; i++ {
|
||||
group.Add(1)
|
||||
go func() { defer group.Done(); errs <- p2.Process(ctx, j2) }()
|
||||
}
|
||||
group.Wait()
|
||||
close(errs)
|
||||
for e := range errs {
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
a, e = s.GetAttachment(ctx, id)
|
||||
if e != nil || a.PipelineVersion != 2 || a.Status != "ready" || len(a.Variants) != 3 {
|
||||
t.Fatal("duplicate current job lost result")
|
||||
}
|
||||
snapshot := a.Variants
|
||||
for _, j := range []model.Job{j1, j2, j1, future, j2} {
|
||||
if e = p1.Process(ctx, j); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
a, e = s.GetAttachment(ctx, id)
|
||||
if e != nil || !reflect.DeepEqual(snapshot, a.Variants) {
|
||||
t.Fatal("stale or duplicate job overwrote current metadata")
|
||||
}
|
||||
for _, v := range a.Variants {
|
||||
r, e := objects.Get(ctx, usecase.VariantKey(id, 2, v.Name))
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
got, e := io.ReadAll(r)
|
||||
r.Close()
|
||||
if e != nil || string(got) != "version2-"+v.Name {
|
||||
t.Fatal("old transformation overwrote v2 objects")
|
||||
}
|
||||
}
|
||||
if ok, e := s.AdvancePipeline(ctx, id); e != nil || !ok {
|
||||
t.Fatal("advance v3 failed")
|
||||
}
|
||||
j3 := next(3)
|
||||
broken := usecase.NewPipeline(s, objects, versionTransformer{err: syscall.ENOSPC}, 5)
|
||||
for i := 0; i < 5; i++ {
|
||||
if _, e = pool.Exec(ctx, "UPDATE attachment_jobs SET next_attempt='epoch' WHERE id=$1", j3.ID); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if e = broken.Process(ctx, j3); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
}
|
||||
a, e = s.GetAttachment(ctx, id)
|
||||
if e != nil || a.Status != "failed" || a.ErrorCode != "retry_exhausted" {
|
||||
t.Fatal("transient infrastructure failure did not exhaust bounded retry")
|
||||
}
|
||||
if ok, e := s.ReplayJob(ctx, id); e != nil || !ok {
|
||||
t.Fatal("explicit replay blocked despite retained immutable source")
|
||||
}
|
||||
if e = p2.Process(ctx, j3); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
a, e = s.GetAttachment(ctx, id)
|
||||
if e != nil || a.Status != "ready" || a.PipelineVersion != 3 {
|
||||
t.Fatal("replayed job did not recover")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
// source: attachments.sql
|
||||
|
||||
package queries
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const chargeAttachment = `-- name: ChargeAttachment :one
|
||||
UPDATE users SET attachment_count=attachment_count+1 WHERE id=$1 AND attachment_count<10000 RETURNING id
|
||||
`
|
||||
|
||||
func (q *Queries) ChargeAttachment(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
|
||||
row := q.db.QueryRow(ctx, chargeAttachment, id)
|
||||
var id_2 uuid.UUID
|
||||
err := row.Scan(&id_2)
|
||||
return id_2, err
|
||||
}
|
||||
|
||||
const getAttachment = `-- name: GetAttachment :one
|
||||
SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, pipeline_version, error_code, variants, staging_expired, staging_cleaned, created_at, updated_at FROM attachments WHERE id=$1 FOR SHARE
|
||||
`
|
||||
|
||||
func (q *Queries) GetAttachment(ctx context.Context, id uuid.UUID) (Attachment, error) {
|
||||
row := q.db.QueryRow(ctx, getAttachment, id)
|
||||
var i Attachment
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.OwnerID,
|
||||
&i.Filename,
|
||||
&i.ContentType,
|
||||
&i.SizeBytes,
|
||||
&i.Sha256,
|
||||
&i.Status,
|
||||
&i.PipelineVersion,
|
||||
&i.ErrorCode,
|
||||
&i.Variants,
|
||||
&i.StagingExpired,
|
||||
&i.StagingCleaned,
|
||||
&i.CreatedAt,
|
||||
&i.UpdatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const insertAttachment = `-- name: InsertAttachment :one
|
||||
INSERT INTO attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,status)
|
||||
VALUES($1,$2,$3,$4,$5,$6,$7,'uploading') RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, pipeline_version, error_code, variants, staging_expired, staging_cleaned, created_at, updated_at
|
||||
`
|
||||
|
||||
type InsertAttachmentParams struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
OwnerID uuid.UUID
|
||||
Filename string
|
||||
ContentType string
|
||||
SizeBytes int64
|
||||
Sha256 string
|
||||
}
|
||||
|
||||
func (q *Queries) InsertAttachment(ctx context.Context, arg InsertAttachmentParams) (Attachment, error) {
|
||||
row := q.db.QueryRow(ctx, insertAttachment,
|
||||
arg.ID,
|
||||
arg.ChatID,
|
||||
arg.OwnerID,
|
||||
arg.Filename,
|
||||
arg.ContentType,
|
||||
arg.SizeBytes,
|
||||
arg.Sha256,
|
||||
)
|
||||
var i Attachment
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.OwnerID,
|
||||
&i.Filename,
|
||||
&i.ContentType,
|
||||
&i.SizeBytes,
|
||||
&i.Sha256,
|
||||
&i.Status,
|
||||
&i.PipelineVersion,
|
||||
&i.ErrorCode,
|
||||
&i.Variants,
|
||||
&i.StagingExpired,
|
||||
&i.StagingCleaned,
|
||||
&i.CreatedAt,
|
||||
&i.UpdatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const insertMessageAttachment = `-- name: InsertMessageAttachment :exec
|
||||
INSERT INTO message_attachments(message_id,attachment_id,ordinal) VALUES($1,$2,$3)
|
||||
`
|
||||
|
||||
type InsertMessageAttachmentParams struct {
|
||||
MessageID uuid.UUID
|
||||
AttachmentID uuid.UUID
|
||||
Ordinal int32
|
||||
}
|
||||
|
||||
func (q *Queries) InsertMessageAttachment(ctx context.Context, arg InsertMessageAttachmentParams) error {
|
||||
_, err := q.db.Exec(ctx, insertMessageAttachment, arg.MessageID, arg.AttachmentID, arg.Ordinal)
|
||||
return err
|
||||
}
|
||||
|
||||
const messageAttachments = `-- name: MessageAttachments :many
|
||||
SELECT attachment_id FROM message_attachments WHERE message_id=$1 ORDER BY ordinal LIMIT 10
|
||||
`
|
||||
|
||||
func (q *Queries) MessageAttachments(ctx context.Context, messageID uuid.UUID) ([]uuid.UUID, error) {
|
||||
rows, err := q.db.Query(ctx, messageAttachments, messageID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []uuid.UUID{}
|
||||
for rows.Next() {
|
||||
var attachment_id uuid.UUID
|
||||
if err := rows.Scan(&attachment_id); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, attachment_id)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const reconcileAttachments = `-- name: ReconcileAttachments :many
|
||||
SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, pipeline_version, error_code, variants, staging_expired, staging_cleaned, created_at, updated_at FROM attachments WHERE id>$1 ORDER BY id LIMIT 101
|
||||
`
|
||||
|
||||
func (q *Queries) ReconcileAttachments(ctx context.Context, id uuid.UUID) ([]Attachment, error) {
|
||||
rows, err := q.db.Query(ctx, reconcileAttachments, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []Attachment{}
|
||||
for rows.Next() {
|
||||
var i Attachment
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.OwnerID,
|
||||
&i.Filename,
|
||||
&i.ContentType,
|
||||
&i.SizeBytes,
|
||||
&i.Sha256,
|
||||
&i.Status,
|
||||
&i.PipelineVersion,
|
||||
&i.ErrorCode,
|
||||
&i.Variants,
|
||||
&i.StagingExpired,
|
||||
&i.StagingCleaned,
|
||||
&i.CreatedAt,
|
||||
&i.UpdatedAt,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const setAttachmentStatus = `-- name: SetAttachmentStatus :execrows
|
||||
UPDATE attachments SET status=$2,updated_at=clock_timestamp() WHERE id=$1 AND status=$3 AND pipeline_version=0
|
||||
`
|
||||
|
||||
type SetAttachmentStatusParams struct {
|
||||
ID uuid.UUID
|
||||
Status string
|
||||
Status_2 string
|
||||
}
|
||||
|
||||
func (q *Queries) SetAttachmentStatus(ctx context.Context, arg SetAttachmentStatusParams) (int64, error) {
|
||||
result, err := q.db.Exec(ctx, setAttachmentStatus, arg.ID, arg.Status, arg.Status_2)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return result.RowsAffected(), nil
|
||||
}
|
||||
@@ -0,0 +1,358 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
// source: core.sql
|
||||
|
||||
package queries
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const authenticateSession = `-- name: AuthenticateSession :one
|
||||
SELECT user_id FROM sessions WHERE token_hash=$1 AND expires_at>clock_timestamp()
|
||||
`
|
||||
|
||||
func (q *Queries) AuthenticateSession(ctx context.Context, tokenHash string) (uuid.UUID, error) {
|
||||
row := q.db.QueryRow(ctx, authenticateSession, tokenHash)
|
||||
var user_id uuid.UUID
|
||||
err := row.Scan(&user_id)
|
||||
return user_id, err
|
||||
}
|
||||
|
||||
const chargeChat = `-- name: ChargeChat :one
|
||||
UPDATE users SET chat_count=chat_count+1 WHERE id=$1 AND chat_count<1000 RETURNING id
|
||||
`
|
||||
|
||||
func (q *Queries) ChargeChat(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
|
||||
row := q.db.QueryRow(ctx, chargeChat, id)
|
||||
var id_2 uuid.UUID
|
||||
err := row.Scan(&id_2)
|
||||
return id_2, err
|
||||
}
|
||||
|
||||
const chargeMessage = `-- name: ChargeMessage :one
|
||||
UPDATE users SET message_count=message_count+1 WHERE id=$1 AND message_count<1000000 RETURNING id
|
||||
`
|
||||
|
||||
func (q *Queries) ChargeMessage(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
|
||||
row := q.db.QueryRow(ctx, chargeMessage, id)
|
||||
var id_2 uuid.UUID
|
||||
err := row.Scan(&id_2)
|
||||
return id_2, err
|
||||
}
|
||||
|
||||
const createUser = `-- name: CreateUser :one
|
||||
INSERT INTO users(id,username,display_name,password_hash) VALUES($1,$2,$3,$4)
|
||||
RETURNING id,username,display_name,created_at
|
||||
`
|
||||
|
||||
type CreateUserParams struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
PasswordHash string
|
||||
}
|
||||
|
||||
type CreateUserRow struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (CreateUserRow, error) {
|
||||
row := q.db.QueryRow(ctx, createUser,
|
||||
arg.ID,
|
||||
arg.Username,
|
||||
arg.DisplayName,
|
||||
arg.PasswordHash,
|
||||
)
|
||||
var i CreateUserRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.Username,
|
||||
&i.DisplayName,
|
||||
&i.CreatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const credentials = `-- name: Credentials :one
|
||||
SELECT id,password_hash FROM users WHERE username=$1
|
||||
`
|
||||
|
||||
type CredentialsRow struct {
|
||||
ID uuid.UUID
|
||||
PasswordHash string
|
||||
}
|
||||
|
||||
func (q *Queries) Credentials(ctx context.Context, username string) (CredentialsRow, error) {
|
||||
row := q.db.QueryRow(ctx, credentials, username)
|
||||
var i CredentialsRow
|
||||
err := row.Scan(&i.ID, &i.PasswordHash)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const deleteExpiredSessions = `-- name: DeleteExpiredSessions :exec
|
||||
DELETE FROM sessions WHERE user_id=$1 AND expires_at<=clock_timestamp()
|
||||
`
|
||||
|
||||
func (q *Queries) DeleteExpiredSessions(ctx context.Context, userID uuid.UUID) error {
|
||||
_, err := q.db.Exec(ctx, deleteExpiredSessions, userID)
|
||||
return err
|
||||
}
|
||||
|
||||
const getChat = `-- name: GetChat :one
|
||||
SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id)::uuid[] AS members
|
||||
FROM chats c WHERE c.id=$1
|
||||
`
|
||||
|
||||
type GetChatRow struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
CreatedAt time.Time
|
||||
Members []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) GetChat(ctx context.Context, id uuid.UUID) (GetChatRow, error) {
|
||||
row := q.db.QueryRow(ctx, getChat, id)
|
||||
var i GetChatRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.Title,
|
||||
&i.CreatedAt,
|
||||
&i.Members,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const getUser = `-- name: GetUser :one
|
||||
SELECT id,username,display_name,created_at FROM users WHERE id=$1
|
||||
`
|
||||
|
||||
type GetUserRow struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
func (q *Queries) GetUser(ctx context.Context, id uuid.UUID) (GetUserRow, error) {
|
||||
row := q.db.QueryRow(ctx, getUser, id)
|
||||
var i GetUserRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.Username,
|
||||
&i.DisplayName,
|
||||
&i.CreatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const insertChat = `-- name: InsertChat :one
|
||||
INSERT INTO chats(id,title) VALUES($1,$2) RETURNING id,title,created_at
|
||||
`
|
||||
|
||||
type InsertChatParams struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
}
|
||||
|
||||
func (q *Queries) InsertChat(ctx context.Context, arg InsertChatParams) (Chat, error) {
|
||||
row := q.db.QueryRow(ctx, insertChat, arg.ID, arg.Title)
|
||||
var i Chat
|
||||
err := row.Scan(&i.ID, &i.Title, &i.CreatedAt)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const insertMembers = `-- name: InsertMembers :exec
|
||||
INSERT INTO chat_members(chat_id,user_id) SELECT $1,unnest($2::uuid[])
|
||||
`
|
||||
|
||||
type InsertMembersParams struct {
|
||||
ChatID uuid.UUID
|
||||
Column2 []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) InsertMembers(ctx context.Context, arg InsertMembersParams) error {
|
||||
_, err := q.db.Exec(ctx, insertMembers, arg.ChatID, arg.Column2)
|
||||
return err
|
||||
}
|
||||
|
||||
const insertMessage = `-- name: InsertMessage :one
|
||||
INSERT INTO messages(id,chat_id,sender_id,text) VALUES($1,$2,$3,$4) RETURNING id,chat_id,sender_id,text,created_at
|
||||
`
|
||||
|
||||
type InsertMessageParams struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
}
|
||||
|
||||
func (q *Queries) InsertMessage(ctx context.Context, arg InsertMessageParams) (Message, error) {
|
||||
row := q.db.QueryRow(ctx, insertMessage,
|
||||
arg.ID,
|
||||
arg.ChatID,
|
||||
arg.SenderID,
|
||||
arg.Text,
|
||||
)
|
||||
var i Message
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.SenderID,
|
||||
&i.Text,
|
||||
&i.CreatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const insertSession = `-- name: InsertSession :one
|
||||
INSERT INTO sessions(token_hash,user_id,expires_at)
|
||||
SELECT $1,$2,$3 WHERE (SELECT count(*) FROM sessions WHERE user_id=$2)<100
|
||||
RETURNING user_id
|
||||
`
|
||||
|
||||
type InsertSessionParams struct {
|
||||
TokenHash string
|
||||
UserID uuid.UUID
|
||||
ExpiresAt time.Time
|
||||
}
|
||||
|
||||
func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) (uuid.UUID, error) {
|
||||
row := q.db.QueryRow(ctx, insertSession, arg.TokenHash, arg.UserID, arg.ExpiresAt)
|
||||
var user_id uuid.UUID
|
||||
err := row.Scan(&user_id)
|
||||
return user_id, err
|
||||
}
|
||||
|
||||
const listChats = `-- name: ListChats :many
|
||||
SELECT c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id)::uuid[] AS members
|
||||
FROM chats c JOIN chat_members m ON m.chat_id=c.id
|
||||
WHERE m.user_id=$1 AND (c.created_at,c.id)>($2::timestamptz,$3::uuid)
|
||||
ORDER BY c.created_at,c.id LIMIT $4
|
||||
`
|
||||
|
||||
type ListChatsParams struct {
|
||||
MemberID uuid.UUID
|
||||
AfterTime time.Time
|
||||
AfterID uuid.UUID
|
||||
PageLimit int32
|
||||
}
|
||||
|
||||
type ListChatsRow struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
CreatedAt time.Time
|
||||
Members []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) ListChats(ctx context.Context, arg ListChatsParams) ([]ListChatsRow, error) {
|
||||
rows, err := q.db.Query(ctx, listChats,
|
||||
arg.MemberID,
|
||||
arg.AfterTime,
|
||||
arg.AfterID,
|
||||
arg.PageLimit,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListChatsRow{}
|
||||
for rows.Next() {
|
||||
var i ListChatsRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.Title,
|
||||
&i.CreatedAt,
|
||||
&i.Members,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listMessages = `-- name: ListMessages :many
|
||||
SELECT m.id,m.chat_id,m.sender_id,m.text,m.created_at,
|
||||
ARRAY(SELECT attachment_id FROM message_attachments WHERE message_id=m.id ORDER BY ordinal LIMIT 10)::uuid[] AS attachment_ids
|
||||
FROM messages m WHERE m.chat_id=$1 AND (m.created_at,m.id)>($2::timestamptz,$3::uuid)
|
||||
ORDER BY m.created_at,m.id LIMIT $4
|
||||
`
|
||||
|
||||
type ListMessagesParams struct {
|
||||
ChatID uuid.UUID
|
||||
AfterTime time.Time
|
||||
AfterID uuid.UUID
|
||||
PageLimit int32
|
||||
}
|
||||
|
||||
type ListMessagesRow struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
CreatedAt time.Time
|
||||
AttachmentIds []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) ListMessages(ctx context.Context, arg ListMessagesParams) ([]ListMessagesRow, error) {
|
||||
rows, err := q.db.Query(ctx, listMessages,
|
||||
arg.ChatID,
|
||||
arg.AfterTime,
|
||||
arg.AfterID,
|
||||
arg.PageLimit,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListMessagesRow{}
|
||||
for rows.Next() {
|
||||
var i ListMessagesRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.SenderID,
|
||||
&i.Text,
|
||||
&i.CreatedAt,
|
||||
&i.AttachmentIds,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const lockSessionOwner = `-- name: LockSessionOwner :one
|
||||
SELECT id FROM users WHERE id=$1 FOR UPDATE
|
||||
`
|
||||
|
||||
func (q *Queries) LockSessionOwner(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
|
||||
row := q.db.QueryRow(ctx, lockSessionOwner, id)
|
||||
var id_2 uuid.UUID
|
||||
err := row.Scan(&id_2)
|
||||
return id_2, err
|
||||
}
|
||||
|
||||
const revokeSession = `-- name: RevokeSession :exec
|
||||
DELETE FROM sessions WHERE token_hash=$1
|
||||
`
|
||||
|
||||
func (q *Queries) RevokeSession(ctx context.Context, tokenHash string) error {
|
||||
_, err := q.db.Exec(ctx, revokeSession, tokenHash)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
|
||||
package queries
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
)
|
||||
|
||||
type DBTX interface {
|
||||
Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
|
||||
Query(context.Context, string, ...interface{}) (pgx.Rows, error)
|
||||
QueryRow(context.Context, string, ...interface{}) pgx.Row
|
||||
}
|
||||
|
||||
func New(db DBTX) *Queries {
|
||||
return &Queries{db: db}
|
||||
}
|
||||
|
||||
type Queries struct {
|
||||
db DBTX
|
||||
}
|
||||
|
||||
func (q *Queries) WithTx(tx pgx.Tx) *Queries {
|
||||
return &Queries{
|
||||
db: tx,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
// source: idempotency.sql
|
||||
|
||||
package queries
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const replayMessage = `-- name: ReplayMessage :one
|
||||
SELECT m.id,m.chat_id,m.sender_id,m.text,m.created_at,i.payload_hash,
|
||||
ARRAY(SELECT attachment_id FROM message_attachments WHERE message_id=m.id ORDER BY ordinal LIMIT 10)::uuid[] AS attachment_ids
|
||||
FROM idempotency i JOIN messages m ON m.id=i.message_id
|
||||
WHERE i.user_id=$1 AND i.chat_id=$2 AND i.key=$3
|
||||
`
|
||||
|
||||
type ReplayMessageParams struct {
|
||||
UserID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
Key string
|
||||
}
|
||||
|
||||
type ReplayMessageRow struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
CreatedAt time.Time
|
||||
PayloadHash string
|
||||
AttachmentIds []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) ReplayMessage(ctx context.Context, arg ReplayMessageParams) (ReplayMessageRow, error) {
|
||||
row := q.db.QueryRow(ctx, replayMessage, arg.UserID, arg.ChatID, arg.Key)
|
||||
var i ReplayMessageRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.SenderID,
|
||||
&i.Text,
|
||||
&i.CreatedAt,
|
||||
&i.PayloadHash,
|
||||
&i.AttachmentIds,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const reserveKey = `-- name: ReserveKey :one
|
||||
INSERT INTO idempotency(user_id,chat_id,key,payload_hash,message_id,expires_at)
|
||||
VALUES($1,$2,$3,$4,$5,clock_timestamp()+interval '24 hours')
|
||||
ON CONFLICT(user_id,chat_id,key) DO UPDATE SET payload_hash=excluded.payload_hash,
|
||||
message_id=excluded.message_id,expires_at=excluded.expires_at
|
||||
WHERE idempotency.expires_at<=clock_timestamp()
|
||||
RETURNING message_id
|
||||
`
|
||||
|
||||
type ReserveKeyParams struct {
|
||||
UserID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
Key string
|
||||
PayloadHash string
|
||||
MessageID uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) ReserveKey(ctx context.Context, arg ReserveKeyParams) (uuid.UUID, error) {
|
||||
row := q.db.QueryRow(ctx, reserveKey,
|
||||
arg.UserID,
|
||||
arg.ChatID,
|
||||
arg.Key,
|
||||
arg.PayloadHash,
|
||||
arg.MessageID,
|
||||
)
|
||||
var message_id uuid.UUID
|
||||
err := row.Scan(&message_id)
|
||||
return message_id, err
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
|
||||
package queries
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type Attachment struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
OwnerID uuid.UUID
|
||||
Filename string
|
||||
ContentType string
|
||||
SizeBytes int64
|
||||
Sha256 string
|
||||
Status string
|
||||
PipelineVersion int32
|
||||
ErrorCode string
|
||||
Variants []byte
|
||||
StagingExpired bool
|
||||
StagingCleaned bool
|
||||
CreatedAt time.Time
|
||||
UpdatedAt time.Time
|
||||
}
|
||||
|
||||
type AttachmentJob struct {
|
||||
ID uuid.UUID
|
||||
AttachmentID uuid.UUID
|
||||
PipelineVersion int32
|
||||
Attempt int32
|
||||
Traceparent string
|
||||
Tracestate string
|
||||
LeaseID uuid.UUID
|
||||
LeaseUntil time.Time
|
||||
NextAttempt time.Time
|
||||
PublishedAt time.Time
|
||||
Completed bool
|
||||
CreatedAt time.Time
|
||||
ReplayCount int64
|
||||
ReplayedAt time.Time
|
||||
}
|
||||
|
||||
type Chat struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
type ChatMember struct {
|
||||
ChatID uuid.UUID
|
||||
UserID uuid.UUID
|
||||
}
|
||||
|
||||
type Idempotency struct {
|
||||
UserID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
Key string
|
||||
PayloadHash string
|
||||
MessageID uuid.UUID
|
||||
ExpiresAt time.Time
|
||||
}
|
||||
|
||||
type Message struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
type MessageAttachment struct {
|
||||
MessageID uuid.UUID
|
||||
AttachmentID uuid.UUID
|
||||
Ordinal int32
|
||||
}
|
||||
|
||||
type Session struct {
|
||||
TokenHash string
|
||||
UserID uuid.UUID
|
||||
ExpiresAt time.Time
|
||||
}
|
||||
|
||||
type User struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
PasswordHash string
|
||||
CreatedAt time.Time
|
||||
ChatCount int32
|
||||
MessageCount int32
|
||||
AttachmentCount int32
|
||||
}
|
||||
@@ -0,0 +1,393 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
// source: pipeline.sql
|
||||
|
||||
package queries
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const acquireJob = `-- name: AcquireJob :one
|
||||
UPDATE attachment_jobs j SET attempt=j.attempt+1,lease_id=$1,lease_until=clock_timestamp()+$2::int*interval '1 second'
|
||||
WHERE j.id=$3 AND j.pipeline_version=$4 AND NOT j.completed
|
||||
AND j.next_attempt<=clock_timestamp() AND j.lease_until<clock_timestamp()
|
||||
AND EXISTS(SELECT 1 FROM attachments a WHERE a.id=j.attachment_id AND a.pipeline_version=j.pipeline_version AND a.status IN ('queued','processing'))
|
||||
RETURNING j.id, j.attachment_id, j.pipeline_version, j.attempt, j.traceparent, j.tracestate, j.lease_id, j.lease_until, j.next_attempt, j.published_at, j.completed, j.created_at, j.replay_count, j.replayed_at
|
||||
`
|
||||
|
||||
type AcquireJobParams struct {
|
||||
LeaseID uuid.UUID
|
||||
LeaseSeconds int32
|
||||
JobID uuid.UUID
|
||||
PipelineVersion int32
|
||||
}
|
||||
|
||||
func (q *Queries) AcquireJob(ctx context.Context, arg AcquireJobParams) (AttachmentJob, error) {
|
||||
row := q.db.QueryRow(ctx, acquireJob,
|
||||
arg.LeaseID,
|
||||
arg.LeaseSeconds,
|
||||
arg.JobID,
|
||||
arg.PipelineVersion,
|
||||
)
|
||||
var i AttachmentJob
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.AttachmentID,
|
||||
&i.PipelineVersion,
|
||||
&i.Attempt,
|
||||
&i.Traceparent,
|
||||
&i.Tracestate,
|
||||
&i.LeaseID,
|
||||
&i.LeaseUntil,
|
||||
&i.NextAttempt,
|
||||
&i.PublishedAt,
|
||||
&i.Completed,
|
||||
&i.CreatedAt,
|
||||
&i.ReplayCount,
|
||||
&i.ReplayedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const advancePipeline = `-- name: AdvancePipeline :one
|
||||
UPDATE attachments SET status='queued',error_code='',variants='[]',pipeline_version=pipeline_version+1,staging_expired=false,updated_at=clock_timestamp() WHERE id=$1 AND (status='ready' OR (status='failed' AND NOT staging_expired)) RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, pipeline_version, error_code, variants, staging_expired, staging_cleaned, created_at, updated_at
|
||||
`
|
||||
|
||||
func (q *Queries) AdvancePipeline(ctx context.Context, id uuid.UUID) (Attachment, error) {
|
||||
row := q.db.QueryRow(ctx, advancePipeline, id)
|
||||
var i Attachment
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.OwnerID,
|
||||
&i.Filename,
|
||||
&i.ContentType,
|
||||
&i.SizeBytes,
|
||||
&i.Sha256,
|
||||
&i.Status,
|
||||
&i.PipelineVersion,
|
||||
&i.ErrorCode,
|
||||
&i.Variants,
|
||||
&i.StagingExpired,
|
||||
&i.StagingCleaned,
|
||||
&i.CreatedAt,
|
||||
&i.UpdatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const completeAttachment = `-- name: CompleteAttachment :execrows
|
||||
UPDATE attachments a SET status='ready',variants=$1::jsonb,error_code='',updated_at=clock_timestamp()
|
||||
FROM attachment_jobs j WHERE j.id=$2 AND j.attachment_id=a.id AND j.pipeline_version=a.pipeline_version
|
||||
AND j.lease_id=$3 AND j.lease_until>clock_timestamp() AND NOT j.completed AND a.status='processing'
|
||||
`
|
||||
|
||||
type CompleteAttachmentParams struct {
|
||||
Variants []byte
|
||||
JobID uuid.UUID
|
||||
LeaseID uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) CompleteAttachment(ctx context.Context, arg CompleteAttachmentParams) (int64, error) {
|
||||
result, err := q.db.Exec(ctx, completeAttachment, arg.Variants, arg.JobID, arg.LeaseID)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return result.RowsAffected(), nil
|
||||
}
|
||||
|
||||
const completeJob = `-- name: CompleteJob :exec
|
||||
UPDATE attachment_jobs SET completed=true,lease_until='epoch' WHERE id=$1 AND lease_id=$2
|
||||
`
|
||||
|
||||
type CompleteJobParams struct {
|
||||
JobID uuid.UUID
|
||||
LeaseID uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) CompleteJob(ctx context.Context, arg CompleteJobParams) error {
|
||||
_, err := q.db.Exec(ctx, completeJob, arg.JobID, arg.LeaseID)
|
||||
return err
|
||||
}
|
||||
|
||||
const insertJob = `-- name: InsertJob :exec
|
||||
INSERT INTO attachment_jobs(id,attachment_id,pipeline_version,traceparent,tracestate)
|
||||
VALUES($1,$2,$3,$4,$5)
|
||||
`
|
||||
|
||||
type InsertJobParams struct {
|
||||
JobID uuid.UUID
|
||||
AttachmentID uuid.UUID
|
||||
PipelineVersion int32
|
||||
Traceparent string
|
||||
Tracestate string
|
||||
}
|
||||
|
||||
func (q *Queries) InsertJob(ctx context.Context, arg InsertJobParams) error {
|
||||
_, err := q.db.Exec(ctx, insertJob,
|
||||
arg.JobID,
|
||||
arg.AttachmentID,
|
||||
arg.PipelineVersion,
|
||||
arg.Traceparent,
|
||||
arg.Tracestate,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
const pendingJobs = `-- name: PendingJobs :many
|
||||
SELECT j.id, j.attachment_id, j.pipeline_version, j.attempt, j.traceparent, j.tracestate, j.lease_id, j.lease_until, j.next_attempt, j.published_at, j.completed, j.created_at, j.replay_count, j.replayed_at FROM attachment_jobs j JOIN attachments a ON a.id=j.attachment_id AND a.pipeline_version=j.pipeline_version
|
||||
WHERE NOT j.completed AND a.status IN ('queued','processing') AND j.next_attempt<=clock_timestamp()
|
||||
AND j.lease_until<clock_timestamp() AND j.published_at<clock_timestamp()-interval '2 seconds'
|
||||
ORDER BY j.created_at,j.id LIMIT 100
|
||||
`
|
||||
|
||||
func (q *Queries) PendingJobs(ctx context.Context) ([]AttachmentJob, error) {
|
||||
rows, err := q.db.Query(ctx, pendingJobs)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []AttachmentJob{}
|
||||
for rows.Next() {
|
||||
var i AttachmentJob
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.AttachmentID,
|
||||
&i.PipelineVersion,
|
||||
&i.Attempt,
|
||||
&i.Traceparent,
|
||||
&i.Tracestate,
|
||||
&i.LeaseID,
|
||||
&i.LeaseUntil,
|
||||
&i.NextAttempt,
|
||||
&i.PublishedAt,
|
||||
&i.Completed,
|
||||
&i.CreatedAt,
|
||||
&i.ReplayCount,
|
||||
&i.ReplayedAt,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const processingAttachment = `-- name: ProcessingAttachment :one
|
||||
UPDATE attachments SET status='processing',updated_at=clock_timestamp()
|
||||
WHERE id=$1 AND pipeline_version=$2 AND status IN ('queued','processing') RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, pipeline_version, error_code, variants, staging_expired, staging_cleaned, created_at, updated_at
|
||||
`
|
||||
|
||||
type ProcessingAttachmentParams struct {
|
||||
AttachmentID uuid.UUID
|
||||
PipelineVersion int32
|
||||
}
|
||||
|
||||
func (q *Queries) ProcessingAttachment(ctx context.Context, arg ProcessingAttachmentParams) (Attachment, error) {
|
||||
row := q.db.QueryRow(ctx, processingAttachment, arg.AttachmentID, arg.PipelineVersion)
|
||||
var i Attachment
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.OwnerID,
|
||||
&i.Filename,
|
||||
&i.ContentType,
|
||||
&i.SizeBytes,
|
||||
&i.Sha256,
|
||||
&i.Status,
|
||||
&i.PipelineVersion,
|
||||
&i.ErrorCode,
|
||||
&i.Variants,
|
||||
&i.StagingExpired,
|
||||
&i.StagingCleaned,
|
||||
&i.CreatedAt,
|
||||
&i.UpdatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const published = `-- name: Published :exec
|
||||
UPDATE attachment_jobs SET published_at=clock_timestamp() WHERE id=$1
|
||||
`
|
||||
|
||||
func (q *Queries) Published(ctx context.Context, id uuid.UUID) error {
|
||||
_, err := q.db.Exec(ctx, published, id)
|
||||
return err
|
||||
}
|
||||
|
||||
const queueAttachment = `-- name: QueueAttachment :one
|
||||
UPDATE attachments SET status='queued',updated_at=clock_timestamp() WHERE id=$1 AND status='uploading' AND NOT staging_expired RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, pipeline_version, error_code, variants, staging_expired, staging_cleaned, created_at, updated_at
|
||||
`
|
||||
|
||||
func (q *Queries) QueueAttachment(ctx context.Context, id uuid.UUID) (Attachment, error) {
|
||||
row := q.db.QueryRow(ctx, queueAttachment, id)
|
||||
var i Attachment
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.OwnerID,
|
||||
&i.Filename,
|
||||
&i.ContentType,
|
||||
&i.SizeBytes,
|
||||
&i.Sha256,
|
||||
&i.Status,
|
||||
&i.PipelineVersion,
|
||||
&i.ErrorCode,
|
||||
&i.Variants,
|
||||
&i.StagingExpired,
|
||||
&i.StagingCleaned,
|
||||
&i.CreatedAt,
|
||||
&i.UpdatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const replayAttachment = `-- name: ReplayAttachment :one
|
||||
UPDATE attachments SET status='queued',error_code='',updated_at=clock_timestamp() WHERE id=$1 AND status='failed' AND NOT staging_expired RETURNING id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status, pipeline_version, error_code, variants, staging_expired, staging_cleaned, created_at, updated_at
|
||||
`
|
||||
|
||||
func (q *Queries) ReplayAttachment(ctx context.Context, id uuid.UUID) (Attachment, error) {
|
||||
row := q.db.QueryRow(ctx, replayAttachment, id)
|
||||
var i Attachment
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.OwnerID,
|
||||
&i.Filename,
|
||||
&i.ContentType,
|
||||
&i.SizeBytes,
|
||||
&i.Sha256,
|
||||
&i.Status,
|
||||
&i.PipelineVersion,
|
||||
&i.ErrorCode,
|
||||
&i.Variants,
|
||||
&i.StagingExpired,
|
||||
&i.StagingCleaned,
|
||||
&i.CreatedAt,
|
||||
&i.UpdatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const replayJobs = `-- name: ReplayJobs :exec
|
||||
UPDATE attachment_jobs SET replay_count=replay_count+1,replayed_at=clock_timestamp(),completed=false,attempt=0,lease_until='epoch',next_attempt='epoch',published_at='epoch' WHERE attachment_id=$1 AND pipeline_version=$2
|
||||
`
|
||||
|
||||
type ReplayJobsParams struct {
|
||||
AttachmentID uuid.UUID
|
||||
PipelineVersion int32
|
||||
}
|
||||
|
||||
func (q *Queries) ReplayJobs(ctx context.Context, arg ReplayJobsParams) error {
|
||||
_, err := q.db.Exec(ctx, replayJobs, arg.AttachmentID, arg.PipelineVersion)
|
||||
return err
|
||||
}
|
||||
|
||||
const retryAttachment = `-- name: RetryAttachment :execrows
|
||||
UPDATE attachments a SET status=$1,error_code=$2,updated_at=clock_timestamp()
|
||||
FROM attachment_jobs j WHERE j.id=$3 AND j.attachment_id=a.id AND j.pipeline_version=a.pipeline_version
|
||||
AND j.lease_id=$4 AND j.lease_until>clock_timestamp() AND NOT j.completed AND a.status='processing'
|
||||
`
|
||||
|
||||
type RetryAttachmentParams struct {
|
||||
NextStatus string
|
||||
ErrorCode string
|
||||
JobID uuid.UUID
|
||||
LeaseID uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) RetryAttachment(ctx context.Context, arg RetryAttachmentParams) (int64, error) {
|
||||
result, err := q.db.Exec(ctx, retryAttachment,
|
||||
arg.NextStatus,
|
||||
arg.ErrorCode,
|
||||
arg.JobID,
|
||||
arg.LeaseID,
|
||||
)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return result.RowsAffected(), nil
|
||||
}
|
||||
|
||||
const retryJob = `-- name: RetryJob :exec
|
||||
UPDATE attachment_jobs SET lease_until='epoch',next_attempt=clock_timestamp()+$1::int*interval '1 millisecond',completed=$2
|
||||
WHERE id=$3 AND lease_id=$4
|
||||
`
|
||||
|
||||
type RetryJobParams struct {
|
||||
DelayMs int32
|
||||
Completed bool
|
||||
JobID uuid.UUID
|
||||
LeaseID uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) RetryJob(ctx context.Context, arg RetryJobParams) error {
|
||||
_, err := q.db.Exec(ctx, retryJob,
|
||||
arg.DelayMs,
|
||||
arg.Completed,
|
||||
arg.JobID,
|
||||
arg.LeaseID,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
const stagingCleaned = `-- name: StagingCleaned :exec
|
||||
UPDATE attachments SET staging_cleaned=true WHERE id=$1 AND (staging_expired OR status='ready')
|
||||
`
|
||||
|
||||
func (q *Queries) StagingCleaned(ctx context.Context, id uuid.UUID) error {
|
||||
_, err := q.db.Exec(ctx, stagingCleaned, id)
|
||||
return err
|
||||
}
|
||||
|
||||
const stagingCleanup = `-- name: StagingCleanup :many
|
||||
WITH candidates AS (
|
||||
SELECT id FROM attachments WHERE NOT staging_cleaned AND (status='ready' OR (status IN ('failed','uploading') AND updated_at<clock_timestamp()-interval '24 hours'))
|
||||
ORDER BY updated_at,id LIMIT 20
|
||||
)
|
||||
UPDATE attachments a SET staging_expired=(a.status<>'ready') FROM candidates c WHERE a.id=c.id AND NOT a.staging_cleaned
|
||||
AND (a.status='ready' OR (a.status IN ('failed','uploading') AND a.updated_at<clock_timestamp()-interval '24 hours')) RETURNING a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, a.status, a.pipeline_version, a.error_code, a.variants, a.staging_expired, a.staging_cleaned, a.created_at, a.updated_at
|
||||
`
|
||||
|
||||
func (q *Queries) StagingCleanup(ctx context.Context) ([]Attachment, error) {
|
||||
rows, err := q.db.Query(ctx, stagingCleanup)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []Attachment{}
|
||||
for rows.Next() {
|
||||
var i Attachment
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.OwnerID,
|
||||
&i.Filename,
|
||||
&i.ContentType,
|
||||
&i.SizeBytes,
|
||||
&i.Sha256,
|
||||
&i.Status,
|
||||
&i.PipelineVersion,
|
||||
&i.ErrorCode,
|
||||
&i.Variants,
|
||||
&i.StagingExpired,
|
||||
&i.StagingCleaned,
|
||||
&i.CreatedAt,
|
||||
&i.UpdatedAt,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
@@ -0,0 +1,243 @@
|
||||
package postgres
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"backend/internal/adapter/repository/postgres/queries"
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/repository"
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
//go:generate go tool sqlc generate -f ../../../../db/sqlc/sqlc.yaml
|
||||
type Store struct {
|
||||
pool *pgxpool.Pool
|
||||
q *queries.Queries
|
||||
cache *redis.Client
|
||||
}
|
||||
|
||||
func New(pool *pgxpool.Pool, cache *redis.Client) repository.Persistent {
|
||||
return &Store{pool, queries.New(pool), cache}
|
||||
}
|
||||
func mapErr(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return model.ErrNotFound
|
||||
}
|
||||
var pg *pgconn.PgError
|
||||
if errors.As(err, &pg) {
|
||||
switch pg.Code {
|
||||
case "23505":
|
||||
return model.ErrUsernameTaken
|
||||
case "23503":
|
||||
return model.ErrUnknownMember
|
||||
case "23514":
|
||||
return &model.ValidationError{Message: "constraint violation"}
|
||||
}
|
||||
}
|
||||
return model.ErrUnavailable
|
||||
}
|
||||
func (s *Store) CreateUser(ctx context.Context, d model.UserDraft) (model.User, error) {
|
||||
row, err := s.q.CreateUser(ctx, queries.CreateUserParams{ID: uuid.New(), Username: d.Username, DisplayName: d.DisplayName, PasswordHash: d.PasswordHash})
|
||||
return model.User{ID: row.ID, Username: row.Username, DisplayName: row.DisplayName, CreatedAt: row.CreatedAt}, mapErr(err)
|
||||
}
|
||||
func (s *Store) GetUser(ctx context.Context, id uuid.UUID) (model.User, error) {
|
||||
key := "profile:" + id.String()
|
||||
if s.cache != nil {
|
||||
c, cancel := context.WithTimeout(ctx, 80*time.Millisecond)
|
||||
raw, err := s.cache.Get(c, key).Bytes()
|
||||
cancel()
|
||||
if err == nil {
|
||||
var u model.User
|
||||
if json.Unmarshal(raw, &u) == nil && u.ID == id {
|
||||
return u, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
row, err := s.q.GetUser(ctx, id)
|
||||
if err != nil {
|
||||
return model.User{}, mapErr(err)
|
||||
}
|
||||
user := model.User{ID: row.ID, Username: row.Username, DisplayName: row.DisplayName, CreatedAt: row.CreatedAt}
|
||||
if s.cache != nil {
|
||||
raw, e := json.Marshal(user)
|
||||
if e == nil {
|
||||
c, cancel := context.WithTimeout(ctx, 80*time.Millisecond)
|
||||
_ = s.cache.Set(c, key, raw, time.Minute).Err()
|
||||
cancel()
|
||||
}
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
func (s *Store) CreateChat(ctx context.Context, d model.ChatDraft) (model.Chat, error) {
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return model.Chat{}, mapErr(err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
if _, err = q.ChargeChat(ctx, d.Creator); err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return model.Chat{}, model.ErrStorageFull
|
||||
}
|
||||
return model.Chat{}, mapErr(err)
|
||||
}
|
||||
row, err := q.InsertChat(ctx, queries.InsertChatParams{ID: uuid.New(), Title: d.Title})
|
||||
if err != nil {
|
||||
return model.Chat{}, mapErr(err)
|
||||
}
|
||||
if err = q.InsertMembers(ctx, queries.InsertMembersParams{ChatID: row.ID, Column2: d.MemberIDs}); err != nil {
|
||||
return model.Chat{}, mapErr(err)
|
||||
}
|
||||
if err = tx.Commit(ctx); err != nil {
|
||||
return model.Chat{}, mapErr(err)
|
||||
}
|
||||
return model.Chat{ID: row.ID, Title: row.Title, CreatedAt: row.CreatedAt, MemberIDs: d.MemberIDs}, nil
|
||||
}
|
||||
func (s *Store) GetChat(ctx context.Context, id uuid.UUID) (model.Chat, error) {
|
||||
r, e := s.q.GetChat(ctx, id)
|
||||
return model.Chat{ID: r.ID, Title: r.Title, CreatedAt: r.CreatedAt, MemberIDs: r.Members}, mapErr(e)
|
||||
}
|
||||
func position(q model.PageQuery) (time.Time, uuid.UUID) {
|
||||
if q.After == nil {
|
||||
return time.Unix(0, 0).UTC(), uuid.Nil
|
||||
}
|
||||
return q.After.CreatedAt, q.After.ID
|
||||
}
|
||||
func (s *Store) ListChats(ctx context.Context, id uuid.UUID, p model.PageQuery) ([]model.Chat, bool, error) {
|
||||
at, aid := position(p)
|
||||
rows, err := s.q.ListChats(ctx, queries.ListChatsParams{MemberID: id, AfterTime: at, AfterID: aid, PageLimit: int32(p.Limit + 1)})
|
||||
if err != nil {
|
||||
return nil, false, mapErr(err)
|
||||
}
|
||||
more := len(rows) > p.Limit
|
||||
if more {
|
||||
rows = rows[:p.Limit]
|
||||
}
|
||||
out := make([]model.Chat, len(rows))
|
||||
for i, r := range rows {
|
||||
out[i] = model.Chat{ID: r.ID, Title: r.Title, CreatedAt: r.CreatedAt, MemberIDs: r.Members}
|
||||
}
|
||||
return out, more, nil
|
||||
}
|
||||
func (s *Store) CreateMessage(ctx context.Context, d model.MessageDraft) (model.Message, error) {
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return model.Message{}, mapErr(err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
messageID := uuid.New()
|
||||
reserved, e := q.ReserveKey(ctx, queries.ReserveKeyParams{UserID: d.SenderID, ChatID: d.ChatID, Key: d.Key, PayloadHash: d.PayloadHash, MessageID: messageID})
|
||||
if errors.Is(e, pgx.ErrNoRows) {
|
||||
r, e := q.ReplayMessage(ctx, queries.ReplayMessageParams{UserID: d.SenderID, ChatID: d.ChatID, Key: d.Key})
|
||||
if e != nil {
|
||||
return model.Message{}, mapErr(e)
|
||||
}
|
||||
if r.PayloadHash != d.PayloadHash {
|
||||
return model.Message{}, model.ErrConflict
|
||||
}
|
||||
return model.Message{ID: r.ID, ChatID: r.ChatID, SenderID: r.SenderID, Text: r.Text, CreatedAt: r.CreatedAt, AttachmentIDs: r.AttachmentIds}, nil
|
||||
}
|
||||
if e != nil {
|
||||
return model.Message{}, mapErr(e)
|
||||
}
|
||||
messageID = reserved
|
||||
for _, id := range d.AttachmentIDs {
|
||||
a, e := q.GetAttachment(ctx, id)
|
||||
if errors.Is(e, pgx.ErrNoRows) {
|
||||
return model.Message{}, model.ErrNotFound
|
||||
}
|
||||
if e != nil {
|
||||
return model.Message{}, mapErr(e)
|
||||
}
|
||||
if a.ChatID != d.ChatID {
|
||||
return model.Message{}, model.ErrNotFound
|
||||
}
|
||||
if a.Status != "ready" && a.Status != "queued" && a.Status != "processing" {
|
||||
return model.Message{}, model.ErrConflict
|
||||
}
|
||||
}
|
||||
if _, err = q.ChargeMessage(ctx, d.SenderID); err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return model.Message{}, model.ErrStorageFull
|
||||
}
|
||||
return model.Message{}, mapErr(err)
|
||||
}
|
||||
r, err := q.InsertMessage(ctx, queries.InsertMessageParams{ID: messageID, ChatID: d.ChatID, SenderID: d.SenderID, Text: d.Text})
|
||||
if err != nil {
|
||||
return model.Message{}, mapErr(err)
|
||||
}
|
||||
for i, id := range d.AttachmentIDs {
|
||||
if e := q.InsertMessageAttachment(ctx, queries.InsertMessageAttachmentParams{MessageID: messageID, AttachmentID: id, Ordinal: int32(i)}); e != nil {
|
||||
return model.Message{}, mapErr(e)
|
||||
}
|
||||
}
|
||||
if err = tx.Commit(ctx); err != nil {
|
||||
return model.Message{}, mapErr(err)
|
||||
}
|
||||
return model.Message{ID: r.ID, ChatID: r.ChatID, SenderID: r.SenderID, Text: r.Text, CreatedAt: r.CreatedAt, AttachmentIDs: d.AttachmentIDs}, nil
|
||||
}
|
||||
func (s *Store) ListMessages(ctx context.Context, id uuid.UUID, p model.PageQuery) ([]model.Message, bool, error) {
|
||||
at, aid := position(p)
|
||||
rows, err := s.q.ListMessages(ctx, queries.ListMessagesParams{ChatID: id, AfterTime: at, AfterID: aid, PageLimit: int32(p.Limit + 1)})
|
||||
if err != nil {
|
||||
return nil, false, mapErr(err)
|
||||
}
|
||||
more := len(rows) > p.Limit
|
||||
if more {
|
||||
rows = rows[:p.Limit]
|
||||
}
|
||||
out := make([]model.Message, len(rows))
|
||||
for i, r := range rows {
|
||||
out[i] = model.Message{ID: r.ID, ChatID: r.ChatID, SenderID: r.SenderID, Text: r.Text, CreatedAt: r.CreatedAt, AttachmentIDs: r.AttachmentIds}
|
||||
}
|
||||
return out, more, nil
|
||||
}
|
||||
func (s *Store) Credentials(ctx context.Context, name string) (uuid.UUID, string, error) {
|
||||
r, e := s.q.Credentials(ctx, name)
|
||||
if errors.Is(e, pgx.ErrNoRows) {
|
||||
return uuid.Nil, "", model.ErrUnauthorized
|
||||
}
|
||||
return r.ID, r.PasswordHash, mapErr(e)
|
||||
}
|
||||
func (s *Store) CreateSession(ctx context.Context, hash string, id uuid.UUID, expiry time.Time) error {
|
||||
tx, e := s.pool.Begin(ctx)
|
||||
if e != nil {
|
||||
return mapErr(e)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
q := s.q.WithTx(tx)
|
||||
if _, e = q.LockSessionOwner(ctx, id); e != nil {
|
||||
return mapErr(e)
|
||||
}
|
||||
if e = q.DeleteExpiredSessions(ctx, id); e != nil {
|
||||
return mapErr(e)
|
||||
}
|
||||
if _, e = q.InsertSession(ctx, queries.InsertSessionParams{TokenHash: hash, UserID: id, ExpiresAt: expiry}); e != nil {
|
||||
if errors.Is(e, pgx.ErrNoRows) {
|
||||
return model.ErrStorageFull
|
||||
}
|
||||
return mapErr(e)
|
||||
}
|
||||
return mapErr(tx.Commit(ctx))
|
||||
}
|
||||
func (s *Store) AuthenticateSession(ctx context.Context, hash string) (uuid.UUID, error) {
|
||||
r, e := s.q.AuthenticateSession(ctx, hash)
|
||||
if errors.Is(e, pgx.ErrNoRows) {
|
||||
return uuid.Nil, model.ErrUnauthorized
|
||||
}
|
||||
return r, mapErr(e)
|
||||
}
|
||||
func (s *Store) RevokeSession(ctx context.Context, hash string) error {
|
||||
return mapErr(s.q.RevokeSession(ctx, hash))
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/signer"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Config struct{ Endpoint, Access, Secret, Bucket string }
|
||||
|
||||
func ReadConfig(path string) (Config, error) {
|
||||
var c Config
|
||||
b, e := os.ReadFile(path)
|
||||
if e != nil {
|
||||
return c, fmt.Errorf("S3 credentials unavailable")
|
||||
}
|
||||
if e = json.Unmarshal(b, &c); e != nil {
|
||||
return c, fmt.Errorf("invalid S3 credentials format")
|
||||
}
|
||||
if c.Endpoint == "" || c.Access == "" || c.Secret == "" || c.Bucket == "" {
|
||||
return c, fmt.Errorf("incomplete S3 configuration")
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
func FromConfig(c Config) (*S3, error) { return New(c.Endpoint, c.Access, c.Secret, c.Bucket) }
|
||||
|
||||
// RustFS provides S3 SDKs, but its documented administrative API is separate.
|
||||
// Use the SDK's SigV4 signer; do not implement signing or persist credentials in command arguments.
|
||||
func admin(ctx context.Context, c Config, path string, body []byte) error {
|
||||
r, e := http.NewRequestWithContext(ctx, http.MethodPut, "http://"+c.Endpoint+"/rustfs/admin/v3/"+path, bytes.NewReader(body))
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
sum := sha256.Sum256(body)
|
||||
r.Header.Set("X-Amz-Content-Sha256", hex.EncodeToString(sum[:]))
|
||||
r.Header.Set("Content-Type", "application/json")
|
||||
signed := signer.SignV4(*r, c.Access, c.Secret, "", "us-east-1")
|
||||
response, e := (&http.Client{Timeout: 5 * time.Second}).Do(signed)
|
||||
if e != nil {
|
||||
return fmt.Errorf("S3 admin transport failed")
|
||||
}
|
||||
defer response.Body.Close()
|
||||
_, _ = io.Copy(io.Discard, io.LimitReader(response.Body, 64*1024))
|
||||
if response.StatusCode != 200 && response.StatusCode != 204 {
|
||||
return fmt.Errorf("S3 admin operation rejected: HTTP %d", response.StatusCode)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func Bootstrap(ctx context.Context, root, app Config) error {
|
||||
s, e := FromConfig(root)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
exists, e := s.Client.BucketExists(ctx, root.Bucket)
|
||||
if e != nil {
|
||||
return fmt.Errorf("bucket availability check failed")
|
||||
}
|
||||
if !exists {
|
||||
if e = s.Client.MakeBucket(ctx, root.Bucket, minio.MakeBucketOptions{Region: "us-east-1"}); e != nil {
|
||||
return fmt.Errorf("bucket creation failed")
|
||||
}
|
||||
}
|
||||
policy := map[string]any{"Version": "2012-10-17", "Statement": []any{
|
||||
map[string]any{"Effect": "Allow", "Action": []string{"s3:GetBucketLocation", "s3:ListBucket"}, "Resource": []string{"arn:aws:s3:::" + app.Bucket}},
|
||||
map[string]any{"Effect": "Allow", "Action": []string{"s3:PutObject", "s3:GetObject", "s3:DeleteObject"}, "Resource": []string{"arn:aws:s3:::" + app.Bucket + "/originals/*", "arn:aws:s3:::" + app.Bucket + "/staging/*", "arn:aws:s3:::" + app.Bucket + "/variants/*"}},
|
||||
}}
|
||||
raw, _ := json.Marshal(policy)
|
||||
if e = admin(ctx, root, "add-canned-policy?name=messenger", raw); e != nil {
|
||||
return e
|
||||
}
|
||||
raw, _ = json.Marshal(map[string]string{"secretKey": app.Secret, "status": "enabled"})
|
||||
if e = admin(ctx, root, "add-user?accessKey="+url.QueryEscape(app.Access), raw); e != nil {
|
||||
return e
|
||||
}
|
||||
return admin(ctx, root, "set-user-or-group-policy?policyName=messenger&userOrGroup="+url.QueryEscape(app.Access)+"&isGroup=false", nil)
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestMissingBucketFailsReadiness(t *testing.T) {
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(404) }))
|
||||
defer server.Close()
|
||||
store, err := New(strings.TrimPrefix(server.URL, "http://"), "synthetic-access", "synthetic-secret", "missing")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err = store.Ready(context.Background()); err == nil {
|
||||
t.Fatal("missing bucket reported ready")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"context"
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/credentials"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
type S3 struct {
|
||||
Client *minio.Client
|
||||
Bucket string
|
||||
}
|
||||
|
||||
func New(endpoint, access, secret, bucket string) (*S3, error) {
|
||||
client, err := minio.New(endpoint, &minio.Options{Creds: credentials.NewStaticV4(access, secret, ""), Secure: false, Region: "us-east-1", Transport: &http.Transport{DialContext: (&net.Dialer{Timeout: time.Second}).DialContext, ResponseHeaderTimeout: 3 * time.Second, MaxIdleConnsPerHost: 8}})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &S3{client, bucket}, nil
|
||||
}
|
||||
func mapError(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
r := minio.ToErrorResponse(err)
|
||||
if r.Code == "NoSuchKey" || r.Code == "NoSuchObject" || r.Code == "NotFound" {
|
||||
return model.ErrNotFound
|
||||
}
|
||||
return model.ErrUnavailable
|
||||
}
|
||||
func (s *S3) Put(ctx context.Context, key string, r io.Reader, size int64, mime string) error {
|
||||
_, err := s.Client.PutObject(ctx, s.Bucket, key, r, size, minio.PutObjectOptions{ContentType: mime, DisableMultipart: true})
|
||||
return mapError(err)
|
||||
}
|
||||
func (s *S3) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
obj, err := s.Client.GetObject(ctx, s.Bucket, key, minio.GetObjectOptions{})
|
||||
if err != nil {
|
||||
return nil, mapError(err)
|
||||
}
|
||||
if _, err = obj.Stat(); err != nil {
|
||||
_ = obj.Close()
|
||||
return nil, mapError(err)
|
||||
}
|
||||
return obj, nil
|
||||
}
|
||||
func (s *S3) Stat(ctx context.Context, key string) (port.Object, error) {
|
||||
r, e := s.Client.StatObject(ctx, s.Bucket, key, minio.StatObjectOptions{})
|
||||
return port.Object{Key: key, ETag: r.ETag, Size: r.Size, Modified: r.LastModified.UTC().Truncate(time.Second)}, mapError(e)
|
||||
}
|
||||
func (s *S3) Remove(ctx context.Context, key string) error {
|
||||
return mapError(s.Client.RemoveObject(ctx, s.Bucket, key, minio.RemoveObjectOptions{}))
|
||||
}
|
||||
func (s *S3) List(ctx context.Context, after string) ([]port.Object, bool, error) {
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
defer cancel()
|
||||
out := []port.Object{}
|
||||
for r := range s.Client.ListObjects(ctx, s.Bucket, minio.ListObjectsOptions{Prefix: "originals/", StartAfter: after, Recursive: true, MaxKeys: 100}) {
|
||||
if r.Err != nil {
|
||||
return nil, false, mapError(r.Err)
|
||||
}
|
||||
// HTTP Last-Modified has second precision; RustFS inventory also carries milliseconds.
|
||||
out = append(out, port.Object{Key: r.Key, ETag: r.ETag, Size: r.Size, Modified: r.LastModified.UTC().Truncate(time.Second)})
|
||||
if len(out) > 100 {
|
||||
return out[:100], true, nil
|
||||
}
|
||||
}
|
||||
return out, false, nil
|
||||
}
|
||||
func (s *S3) Ready(ctx context.Context) error {
|
||||
exists, err := s.Client.BucketExists(ctx, s.Bucket)
|
||||
if err != nil || !exists {
|
||||
return model.ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
package usecase
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"backend/internal/domain/repository"
|
||||
"context"
|
||||
"github.com/google/uuid"
|
||||
"io"
|
||||
)
|
||||
|
||||
type Attachments struct {
|
||||
repo repository.AsyncAttachments
|
||||
messenger *Messenger
|
||||
objects port.Objects
|
||||
}
|
||||
|
||||
func NewAttachments(r repository.AsyncAttachments, m *Messenger, o port.Objects) *Attachments {
|
||||
return &Attachments{r, m, o}
|
||||
}
|
||||
func ObjectKey(id uuid.UUID) string { return "originals/" + id.String() }
|
||||
func (a *Attachments) Upload(ctx context.Context, caller, chat uuid.UUID, name, mime, sha string, size int64, body io.Reader) (model.Attachment, error) {
|
||||
if _, e := a.messenger.GetChat(ctx, caller, chat); e != nil {
|
||||
return model.Attachment{}, e
|
||||
}
|
||||
row, e := a.repo.ReserveAttachment(ctx, model.Attachment{ID: uuid.New(), ChatID: chat, OwnerID: caller, Filename: name, ContentType: mime, SHA256: sha, SizeBytes: size})
|
||||
if e != nil {
|
||||
return model.Attachment{}, e
|
||||
}
|
||||
if e = a.objects.Put(ctx, "staging/"+row.ID.String(), body, size, mime); e != nil {
|
||||
return model.Attachment{}, model.ErrUnavailable
|
||||
}
|
||||
return a.repo.QueueAttachment(ctx, row, "", "")
|
||||
}
|
||||
func (a *Attachments) Get(ctx context.Context, caller, id uuid.UUID) (model.Attachment, error) {
|
||||
row, e := a.repo.GetAttachment(ctx, id)
|
||||
if e != nil {
|
||||
return model.Attachment{}, e
|
||||
}
|
||||
if _, e = a.messenger.GetChat(ctx, caller, row.ChatID); e != nil {
|
||||
return model.Attachment{}, e
|
||||
}
|
||||
return row, nil
|
||||
}
|
||||
func (a *Attachments) Content(ctx context.Context, caller, id uuid.UUID, variant string) (model.Attachment, io.ReadCloser, error) {
|
||||
row, e := a.Get(ctx, caller, id)
|
||||
if e != nil {
|
||||
return row, nil, e
|
||||
}
|
||||
if row.Status != "ready" {
|
||||
return row, nil, model.ErrConflict
|
||||
}
|
||||
key := ObjectKey(id)
|
||||
if variant != "original" {
|
||||
found := false
|
||||
for _, v := range row.Variants {
|
||||
if v.Name == variant {
|
||||
found = true
|
||||
key = VariantKey(id, row.PipelineVersion, variant)
|
||||
row.SizeBytes = v.SizeBytes
|
||||
row.ContentType = v.ContentType
|
||||
row.SHA256 = v.SHA256
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
return row, nil, model.ErrNotFound
|
||||
}
|
||||
}
|
||||
info, e := a.objects.Stat(ctx, key)
|
||||
if e != nil || info.Size != row.SizeBytes {
|
||||
return row, nil, model.ErrUnavailable
|
||||
}
|
||||
r, e := a.objects.Get(ctx, key)
|
||||
if e != nil {
|
||||
return row, nil, model.ErrUnavailable
|
||||
}
|
||||
return row, r, nil
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
package usecase
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
)
|
||||
|
||||
type Auth struct {
|
||||
sessions port.Sessions
|
||||
passwords port.Passwords
|
||||
messenger *Messenger
|
||||
ttl time.Duration
|
||||
now func() time.Time
|
||||
}
|
||||
type Session struct {
|
||||
Token string
|
||||
ExpiresAt time.Time
|
||||
User model.User
|
||||
}
|
||||
|
||||
func NewAuth(s port.Sessions, p port.Passwords, m *Messenger, ttl time.Duration, now func() time.Time) *Auth {
|
||||
return &Auth{s, p, m, ttl, now}
|
||||
}
|
||||
func (a *Auth) Register(ctx context.Context, username, name, password string) (model.User, error) {
|
||||
if n := utf8.RuneCountInString(password); n < 12 || n > 128 || !utf8.ValidString(password) {
|
||||
return model.User{}, &model.ValidationError{Message: "password: 12–128 Unicode characters"}
|
||||
}
|
||||
draft, err := model.NewUserDraft(username, name)
|
||||
if err != nil {
|
||||
return model.User{}, err
|
||||
}
|
||||
hash, err := a.passwords.Hash(password)
|
||||
if err != nil {
|
||||
return model.User{}, err
|
||||
}
|
||||
draft.PasswordHash = hash
|
||||
return a.messenger.repo.CreateUser(ctx, draft)
|
||||
}
|
||||
func (a *Auth) Login(ctx context.Context, username, password string) (Session, error) {
|
||||
id, hash, err := a.sessions.Credentials(ctx, username)
|
||||
if err != nil {
|
||||
return Session{}, err
|
||||
}
|
||||
if !a.passwords.Verify(password, hash) {
|
||||
return Session{}, model.ErrUnauthorized
|
||||
}
|
||||
user, err := a.messenger.repo.GetUser(ctx, id)
|
||||
if err != nil {
|
||||
return Session{}, err
|
||||
}
|
||||
raw := make([]byte, 32)
|
||||
if _, err = rand.Read(raw); err != nil {
|
||||
return Session{}, err
|
||||
}
|
||||
token := base64.RawURLEncoding.EncodeToString(raw)
|
||||
expires := a.now().UTC().Add(a.ttl)
|
||||
if err = a.sessions.CreateSession(ctx, TokenHash(token), id, expires); err != nil {
|
||||
return Session{}, err
|
||||
}
|
||||
return Session{token, expires, user}, nil
|
||||
}
|
||||
func TokenHash(token string) string {
|
||||
sum := sha256.Sum256([]byte(token))
|
||||
return hex.EncodeToString(sum[:])
|
||||
}
|
||||
func (a *Auth) Authenticate(ctx context.Context, token string) (model.User, error) {
|
||||
if len(token) != 43 {
|
||||
return model.User{}, model.ErrUnauthorized
|
||||
}
|
||||
id, err := a.sessions.AuthenticateSession(ctx, TokenHash(token))
|
||||
if err != nil {
|
||||
return model.User{}, err
|
||||
}
|
||||
return a.messenger.repo.GetUser(ctx, id)
|
||||
}
|
||||
func (a *Auth) Logout(ctx context.Context, token string) error {
|
||||
return a.sessions.RevokeSession(ctx, TokenHash(token))
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
package usecase
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/repository"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const chatsCursorScope = "chats"
|
||||
|
||||
// Page — страница списка; NextCursor == nil, если следующей записи нет.
|
||||
type Page[T any] struct {
|
||||
Items []T
|
||||
NextCursor *string
|
||||
}
|
||||
|
||||
type Messenger struct {
|
||||
repo repository.Repository
|
||||
}
|
||||
|
||||
func NewMessenger(repo repository.Repository) *Messenger {
|
||||
return &Messenger{repo: repo}
|
||||
}
|
||||
|
||||
func (m *Messenger) CreateChat(ctx context.Context, caller uuid.UUID, title string, memberIDs []uuid.UUID) (model.Chat, error) {
|
||||
draft, err := model.NewChatDraft(caller, title, memberIDs)
|
||||
if err != nil {
|
||||
return model.Chat{}, err
|
||||
}
|
||||
return m.repo.CreateChat(ctx, draft)
|
||||
}
|
||||
|
||||
func (m *Messenger) ListChats(ctx context.Context, caller uuid.UUID, limit *int, cursor *string) (Page[model.Chat], error) {
|
||||
q, err := model.NewPageQuery(limit, cursor, chatsCursorScope)
|
||||
if err != nil {
|
||||
return Page[model.Chat]{}, err
|
||||
}
|
||||
chats, more, err := m.repo.ListChats(ctx, caller, q)
|
||||
if err != nil {
|
||||
return Page[model.Chat]{}, err
|
||||
}
|
||||
return newPage(chats, more, chatsCursorScope, model.Chat.Position), nil
|
||||
}
|
||||
|
||||
// GetChat отдаёт чат только участнику; постороннему — ErrNotFound, чтобы не
|
||||
// раскрывать существование чужого чата.
|
||||
func (m *Messenger) GetChat(ctx context.Context, caller, chatID uuid.UUID) (model.Chat, error) {
|
||||
chat, err := m.repo.GetChat(ctx, chatID)
|
||||
if err != nil {
|
||||
return model.Chat{}, err
|
||||
}
|
||||
if !chat.HasMember(caller) {
|
||||
return model.Chat{}, model.ErrNotFound
|
||||
}
|
||||
return chat, nil
|
||||
}
|
||||
|
||||
// SendMessage сначала проверяет доступ, затем тело: посторонний получает 404
|
||||
// даже на невалидное сообщение. Проверка членства и запись не атомарны, но
|
||||
// участники чата неизменяемы, а чаты не удаляются, поэтому гонки здесь нет.
|
||||
func (m *Messenger) SendMessage(ctx context.Context, caller, chatID uuid.UUID, text, key string, attachments []uuid.UUID) (model.Message, error) {
|
||||
if _, err := m.GetChat(ctx, caller, chatID); err != nil {
|
||||
return model.Message{}, err
|
||||
}
|
||||
draft, err := model.NewMessageDraft(chatID, caller, text, attachments)
|
||||
if err != nil {
|
||||
return model.Message{}, err
|
||||
}
|
||||
draft, err = model.WithKey(draft, key)
|
||||
if err != nil {
|
||||
return model.Message{}, err
|
||||
}
|
||||
return m.repo.CreateMessage(ctx, draft)
|
||||
}
|
||||
|
||||
func (m *Messenger) ListMessages(ctx context.Context, caller, chatID uuid.UUID, limit *int, cursor *string) (Page[model.Message], error) {
|
||||
if _, err := m.GetChat(ctx, caller, chatID); err != nil {
|
||||
return Page[model.Message]{}, err
|
||||
}
|
||||
scope := "messages:" + chatID.String()
|
||||
q, err := model.NewPageQuery(limit, cursor, scope)
|
||||
if err != nil {
|
||||
return Page[model.Message]{}, err
|
||||
}
|
||||
messages, more, err := m.repo.ListMessages(ctx, chatID, q)
|
||||
if err != nil {
|
||||
return Page[model.Message]{}, err
|
||||
}
|
||||
return newPage(messages, more, scope, model.Message.Position), nil
|
||||
}
|
||||
|
||||
func newPage[T any](items []T, more bool, scope string, position func(T) model.Position) Page[T] {
|
||||
page := Page[T]{Items: items}
|
||||
if more && len(items) > 0 {
|
||||
next := model.EncodeCursor(scope, position(items[len(items)-1]))
|
||||
page.NextCursor = &next
|
||||
}
|
||||
return page
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
package usecase
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"github.com/google/uuid"
|
||||
"io"
|
||||
"math/rand/v2"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Pipeline struct {
|
||||
store port.PipelineStore
|
||||
objects port.Objects
|
||||
transform port.Transformer
|
||||
MaxAttempts int32
|
||||
Fault func(string) error
|
||||
}
|
||||
|
||||
func NewPipeline(s port.PipelineStore, o port.Objects, t port.Transformer, max int32) *Pipeline {
|
||||
return &Pipeline{store: s, objects: o, transform: t, MaxAttempts: max, Fault: func(string) error { return nil }}
|
||||
}
|
||||
func VariantKey(id uuid.UUID, version int32, name string) string {
|
||||
return fmt.Sprintf("variants/%s/v%d/%s", id, version, name)
|
||||
}
|
||||
func (p *Pipeline) Process(ctx context.Context, j model.Job) error {
|
||||
lease := uuid.New()
|
||||
owned, a, ok, e := p.store.AcquireJob(ctx, j, lease, 30*time.Second)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if !ok {
|
||||
return p.Cleanup(ctx)
|
||||
}
|
||||
j = owned
|
||||
if j.Attempt > p.MaxAttempts {
|
||||
return p.store.RetryJob(ctx, j, lease, "retry_exhausted", 0, true)
|
||||
}
|
||||
// Reprocessing uses the immutable original after staging was safely removed.
|
||||
key := "staging/" + a.ID.String()
|
||||
r, e := p.objects.Get(ctx, key)
|
||||
if errors.Is(e, model.ErrNotFound) {
|
||||
r, e = p.objects.Get(ctx, ObjectKey(a.ID))
|
||||
}
|
||||
if e != nil {
|
||||
return p.retry(ctx, j, lease, e)
|
||||
}
|
||||
original, e := io.ReadAll(io.LimitReader(r, model.MaxImageBytes+1))
|
||||
_ = r.Close()
|
||||
if e != nil || int64(len(original)) != a.SizeBytes {
|
||||
return p.retry(ctx, j, lease, model.ErrUnavailable)
|
||||
}
|
||||
sum := sha256.Sum256(original)
|
||||
if hex.EncodeToString(sum[:]) != a.SHA256 {
|
||||
return p.retry(ctx, j, lease, model.ErrInvalidImage)
|
||||
}
|
||||
if e = p.objects.Put(ctx, ObjectKey(a.ID), bytes.NewReader(original), a.SizeBytes, a.ContentType); e != nil {
|
||||
return p.retry(ctx, j, lease, e)
|
||||
}
|
||||
if e = p.Fault("after_original"); e != nil {
|
||||
return e
|
||||
}
|
||||
variants, e := p.transform.Transform(ctx, bytes.NewReader(original))
|
||||
if e != nil {
|
||||
return p.retry(ctx, j, lease, e)
|
||||
}
|
||||
result := make([]model.Variant, 0, len(variants))
|
||||
for _, v := range variants {
|
||||
if e = p.objects.Put(ctx, VariantKey(a.ID, j.PipelineVersion, v.Metadata.Name), bytes.NewReader(v.Bytes), int64(len(v.Bytes)), v.Metadata.ContentType); e != nil {
|
||||
return p.retry(ctx, j, lease, e)
|
||||
}
|
||||
result = append(result, v.Metadata)
|
||||
}
|
||||
if e = p.Fault("after_objects"); e != nil {
|
||||
return e
|
||||
}
|
||||
ok, e = p.store.CompleteJob(ctx, j, lease, result)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
if e = p.Fault("after_commit"); e != nil {
|
||||
return e
|
||||
}
|
||||
// Cleanup has its own durable marker and cannot change a published ready result.
|
||||
return p.Cleanup(ctx)
|
||||
}
|
||||
func (p *Pipeline) retry(ctx context.Context, j model.Job, lease uuid.UUID, cause error) error {
|
||||
failed := j.Attempt >= p.MaxAttempts
|
||||
code := "processing_failed"
|
||||
if failed {
|
||||
code = "retry_exhausted"
|
||||
}
|
||||
if errors.Is(cause, model.ErrInvalidImage) {
|
||||
failed = true
|
||||
code = "invalid_image"
|
||||
}
|
||||
delay := time.Duration((1<<min(j.Attempt, 5))*100+rand.IntN(100)) * time.Millisecond
|
||||
if e := p.store.RetryJob(ctx, j, lease, code, delay, failed); e != nil {
|
||||
return e
|
||||
}
|
||||
// This delivery has durably recorded its retry/failed effect. Ack it; the
|
||||
// transactional outbox schedules the next attempt instead of retaining a PEL entry.
|
||||
return nil
|
||||
}
|
||||
|
||||
func (p *Pipeline) Cleanup(ctx context.Context) error {
|
||||
rows, e := p.store.StagingCleanup(ctx)
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
for _, a := range rows {
|
||||
if a.Status == "ready" {
|
||||
info, e := p.objects.Stat(ctx, ObjectKey(a.ID))
|
||||
if e != nil {
|
||||
return e
|
||||
}
|
||||
if info.Size != a.SizeBytes {
|
||||
return model.ErrUnavailable
|
||||
}
|
||||
}
|
||||
if e = p.objects.Remove(ctx, "staging/"+a.ID.String()); e != nil {
|
||||
return e
|
||||
}
|
||||
if e = p.store.StagingCleaned(ctx, a.ID); e != nil {
|
||||
return e
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
package usecase
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"github.com/google/uuid"
|
||||
"io"
|
||||
"syscall"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
type pipelineStoreFixture struct {
|
||||
failed bool
|
||||
code string
|
||||
complete bool
|
||||
a model.Attachment
|
||||
cleaned int
|
||||
}
|
||||
|
||||
func (f *pipelineStoreFixture) PendingJobs(context.Context) ([]model.Job, error) { return nil, nil }
|
||||
func (f *pipelineStoreFixture) Published(context.Context, uuid.UUID) error { return nil }
|
||||
func (f *pipelineStoreFixture) AcquireJob(_ context.Context, j model.Job, _ uuid.UUID, _ time.Duration) (model.Job, model.Attachment, bool, error) {
|
||||
j.Attempt = 1
|
||||
return j, f.a, !f.complete, nil
|
||||
}
|
||||
func (f *pipelineStoreFixture) CompleteJob(context.Context, model.Job, uuid.UUID, []model.Variant) (bool, error) {
|
||||
f.complete = true
|
||||
f.a.Status = "ready"
|
||||
return true, nil
|
||||
}
|
||||
func (f *pipelineStoreFixture) RetryJob(_ context.Context, _ model.Job, _ uuid.UUID, code string, _ time.Duration, failed bool) error {
|
||||
f.failed = failed
|
||||
f.code = code
|
||||
return nil
|
||||
}
|
||||
func (f *pipelineStoreFixture) ReplayJob(context.Context, uuid.UUID) (bool, error) { return false, nil }
|
||||
func (f *pipelineStoreFixture) AdvancePipeline(context.Context, uuid.UUID) (bool, error) {
|
||||
return false, nil
|
||||
}
|
||||
func (f *pipelineStoreFixture) StagingCleanup(context.Context) ([]model.Attachment, error) {
|
||||
if f.complete && f.cleaned == 0 {
|
||||
return []model.Attachment{f.a}, nil
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
func (f *pipelineStoreFixture) StagingCleaned(context.Context, uuid.UUID) error {
|
||||
f.cleaned++
|
||||
return nil
|
||||
}
|
||||
|
||||
type pipelineObjectsFixture struct {
|
||||
content []byte
|
||||
removeErr error
|
||||
removed int
|
||||
}
|
||||
|
||||
func (f *pipelineObjectsFixture) Get(context.Context, string) (io.ReadCloser, error) {
|
||||
return io.NopCloser(bytes.NewReader(f.content)), nil
|
||||
}
|
||||
func (f *pipelineObjectsFixture) Put(context.Context, string, io.Reader, int64, string) error {
|
||||
return nil
|
||||
}
|
||||
func (f *pipelineObjectsFixture) Stat(context.Context, string) (port.Object, error) {
|
||||
return port.Object{Size: int64(len(f.content))}, nil
|
||||
}
|
||||
func (f *pipelineObjectsFixture) Remove(context.Context, string) error {
|
||||
if f.removeErr != nil {
|
||||
return f.removeErr
|
||||
}
|
||||
f.removed++
|
||||
return nil
|
||||
}
|
||||
func (f *pipelineObjectsFixture) List(context.Context, string) ([]port.Object, bool, error) {
|
||||
return nil, false, nil
|
||||
}
|
||||
func (f *pipelineObjectsFixture) Ready(context.Context) error { return nil }
|
||||
|
||||
type transformFixture struct{ err error }
|
||||
|
||||
func (f transformFixture) Transform(context.Context, io.Reader) ([]port.ProcessedVariant, error) {
|
||||
return nil, f.err
|
||||
}
|
||||
func TestInfrastructureTransformFailureIsRetried(t *testing.T) {
|
||||
raw := []byte("valid durable bytes")
|
||||
sum := sha256.Sum256(raw)
|
||||
f := &pipelineStoreFixture{a: model.Attachment{ID: uuid.New(), SizeBytes: int64(len(raw)), SHA256: hex.EncodeToString(sum[:])}}
|
||||
for _, failure := range []error{syscall.ENOSPC, errors.New("convert executable unavailable")} {
|
||||
p := NewPipeline(f, &pipelineObjectsFixture{content: raw}, transformFixture{failure}, 5)
|
||||
if e := p.Process(context.Background(), model.Job{ID: uuid.New(), PipelineVersion: 1}); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if f.failed || f.code != "processing_failed" {
|
||||
t.Fatalf("temporary transform infrastructure failure became permanent: failed=%t code=%s", f.failed, f.code)
|
||||
}
|
||||
}
|
||||
}
|
||||
func TestCompletedDeliveryRecoversStagingCleanupAfterCrash(t *testing.T) {
|
||||
raw := []byte("immutable original")
|
||||
sum := sha256.Sum256(raw)
|
||||
store := &pipelineStoreFixture{a: model.Attachment{ID: uuid.New(), SizeBytes: int64(len(raw)), SHA256: hex.EncodeToString(sum[:])}}
|
||||
objects := &pipelineObjectsFixture{content: raw}
|
||||
p := NewPipeline(store, objects, transformFixture{}, 5)
|
||||
p.Fault = func(point string) error {
|
||||
if point == "after_commit" {
|
||||
return errors.New("worker crash")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
j := model.Job{ID: uuid.New(), PipelineVersion: 1}
|
||||
if e := p.Process(context.Background(), j); e == nil {
|
||||
t.Fatal("crash was not injected")
|
||||
}
|
||||
if objects.removed != 0 {
|
||||
t.Fatal("staging removed before simulated crash")
|
||||
}
|
||||
p = NewPipeline(store, objects, transformFixture{}, 5)
|
||||
if e := p.Process(context.Background(), j); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if objects.removed != 1 || store.cleaned != 1 || store.a.Status != "ready" {
|
||||
t.Fatalf("completed redelivery did not recover cleanup: removed=%d durable_cleaned=%d status=%s", objects.removed, store.cleaned, store.a.Status)
|
||||
}
|
||||
if e := p.Process(context.Background(), j); e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if objects.removed != 1 {
|
||||
t.Fatal("completed cleanup was repeated")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
package usecase
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"backend/internal/domain/repository"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"github.com/google/uuid"
|
||||
"io"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type ReconcileReport struct {
|
||||
Metadata, Objects, Orphans, Missing, Recovered, Fresh, Deleted, Changed int
|
||||
PipelineSkipped int
|
||||
NextMetadata, NextObject string
|
||||
}
|
||||
type Reconciler struct {
|
||||
repo repository.AttachmentRepository
|
||||
objects port.Objects
|
||||
now func() time.Time
|
||||
}
|
||||
|
||||
func NewReconciler(repo repository.AttachmentRepository, objects port.Objects, now func() time.Time) *Reconciler {
|
||||
return &Reconciler{repo, objects, now}
|
||||
}
|
||||
func (r *Reconciler) Run(ctx context.Context, after uuid.UUID, objectAfter string, grace time.Duration, apply bool) (report ReconcileReport, runErr error) {
|
||||
report = ReconcileReport{}
|
||||
defer func() {
|
||||
if runErr != nil {
|
||||
report.NextMetadata = ""
|
||||
report.NextObject = ""
|
||||
}
|
||||
}()
|
||||
if grace < time.Minute {
|
||||
return report, &model.ValidationError{Message: "reconciliation grace must be at least 60 seconds"}
|
||||
}
|
||||
now := r.now().UTC()
|
||||
old := func(t time.Time) bool { age := now.Sub(t); return !t.IsZero() && age >= grace && age >= 0 }
|
||||
rows, more, e := r.repo.ReconcileAttachments(ctx, after)
|
||||
if e != nil {
|
||||
return report, e
|
||||
}
|
||||
for _, a := range rows {
|
||||
report.Metadata++
|
||||
if more {
|
||||
report.NextMetadata = a.ID.String()
|
||||
}
|
||||
if !old(a.CreatedAt) {
|
||||
report.Fresh++
|
||||
continue
|
||||
}
|
||||
// Only the fenced pipeline can publish versioned results. The legacy
|
||||
// reconciler knows nothing about required variants, retries or outbox jobs.
|
||||
if a.PipelineVersion > 0 {
|
||||
report.PipelineSkipped++
|
||||
continue
|
||||
}
|
||||
info, e := r.objects.Stat(ctx, ObjectKey(a.ID))
|
||||
target := a.Status
|
||||
if errors.Is(e, model.ErrNotFound) {
|
||||
switch a.Status {
|
||||
case "ready":
|
||||
report.Missing++
|
||||
target = "missing"
|
||||
case "uploading":
|
||||
report.Missing++
|
||||
target = "abandoned"
|
||||
}
|
||||
} else if e != nil {
|
||||
return report, e
|
||||
} else if a.Status != "ready" {
|
||||
valid := false
|
||||
if info.Size == a.SizeBytes {
|
||||
body, err := r.objects.Get(ctx, ObjectKey(a.ID))
|
||||
if err != nil {
|
||||
return report, err
|
||||
}
|
||||
hash := sha256.New()
|
||||
n, err := io.Copy(hash, io.LimitReader(body, a.SizeBytes+1))
|
||||
_ = body.Close()
|
||||
if err != nil {
|
||||
return report, model.ErrUnavailable
|
||||
}
|
||||
valid = n == a.SizeBytes && hex.EncodeToString(hash.Sum(nil)) == a.SHA256
|
||||
}
|
||||
if valid {
|
||||
report.Recovered++
|
||||
target = "ready"
|
||||
} else {
|
||||
report.Missing++
|
||||
target = "missing"
|
||||
}
|
||||
} else if info.Size != a.SizeBytes {
|
||||
report.Missing++
|
||||
target = "missing"
|
||||
}
|
||||
if apply && target != a.Status {
|
||||
changed, e := r.repo.SetAttachmentStatus(ctx, a.ID, a.Status, target)
|
||||
if e != nil {
|
||||
return report, e
|
||||
}
|
||||
if changed {
|
||||
report.Changed++
|
||||
}
|
||||
}
|
||||
}
|
||||
objects, more, e := r.objects.List(ctx, objectAfter)
|
||||
if e != nil {
|
||||
return report, e
|
||||
}
|
||||
for _, o := range objects {
|
||||
report.Objects++
|
||||
if more {
|
||||
report.NextObject = o.Key
|
||||
}
|
||||
if !old(o.Modified) {
|
||||
report.Fresh++
|
||||
continue
|
||||
}
|
||||
raw, ok := strings.CutPrefix(o.Key, "originals/")
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
id, e := uuid.Parse(raw)
|
||||
if e != nil || ObjectKey(id) != o.Key {
|
||||
continue
|
||||
}
|
||||
if _, e = r.repo.GetAttachment(ctx, id); e == nil {
|
||||
continue
|
||||
} else if !errors.Is(e, model.ErrNotFound) {
|
||||
return report, e
|
||||
}
|
||||
report.Orphans++
|
||||
if !apply {
|
||||
continue
|
||||
}
|
||||
fresh, e := r.objects.Stat(ctx, o.Key)
|
||||
if errors.Is(e, model.ErrNotFound) {
|
||||
continue
|
||||
}
|
||||
if e != nil {
|
||||
return report, e
|
||||
}
|
||||
if fresh.ETag != o.ETag || fresh.Size != o.Size || !fresh.Modified.Equal(o.Modified) || !old(fresh.Modified) {
|
||||
report.Fresh++
|
||||
continue
|
||||
}
|
||||
if _, e = r.repo.GetAttachment(ctx, id); e == nil {
|
||||
continue
|
||||
} else if !errors.Is(e, model.ErrNotFound) {
|
||||
return report, e
|
||||
}
|
||||
// Object keys are random UUIDs, immutable and never reused by the upload API.
|
||||
// An absent metadata row cannot later adopt an old inventory key.
|
||||
if e = r.objects.Remove(ctx, o.Key); e != nil {
|
||||
return report, e
|
||||
}
|
||||
report.Deleted++
|
||||
}
|
||||
return report, nil
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package usecase
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"github.com/google/uuid"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestReconcilerCannotPublishVersionedPipelineResult(t *testing.T) {
|
||||
for _, status := range []string{"uploading", "queued", "processing", "failed", "ready"} {
|
||||
t.Run(status, func(t *testing.T) {
|
||||
id := uuid.New()
|
||||
raw := []byte("only original survived worker crash")
|
||||
sum := sha256.Sum256(raw)
|
||||
repo := &fixtureRepo{rows: map[uuid.UUID]model.Attachment{id: {ID: id, Status: status, PipelineVersion: 1, SizeBytes: int64(len(raw)), SHA256: hex.EncodeToString(sum[:]), CreatedAt: fixedNow.Add(-2 * time.Minute)}}}
|
||||
objects := &fixtureObjects{items: map[string]port.Object{ObjectKey(id): {Key: ObjectKey(id), Size: int64(len(raw)), Modified: fixedNow.Add(-2 * time.Minute)}}, content: raw}
|
||||
report, e := NewReconciler(repo, objects, func() time.Time { return fixedNow }).Run(context.Background(), uuid.Nil, "", time.Minute, true)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if repo.rows[id].Status != status || report.Recovered != 0 || report.Changed != 0 {
|
||||
t.Fatalf("pipeline state was changed by legacy reconciler: status %s -> %s, report %+v", status, repo.rows[id].Status, report)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,184 @@
|
||||
package usecase
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"github.com/google/uuid"
|
||||
"io"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
type fixtureRepo struct {
|
||||
rows map[uuid.UUID]model.Attachment
|
||||
failure error
|
||||
more bool
|
||||
}
|
||||
|
||||
func (f *fixtureRepo) ReserveAttachment(context.Context, model.Attachment) (model.Attachment, error) {
|
||||
panic("not used")
|
||||
}
|
||||
func (f *fixtureRepo) GetAttachment(_ context.Context, id uuid.UUID) (model.Attachment, error) {
|
||||
if f.failure != nil {
|
||||
return model.Attachment{}, f.failure
|
||||
}
|
||||
a, ok := f.rows[id]
|
||||
if !ok {
|
||||
return a, model.ErrNotFound
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
func (f *fixtureRepo) SetAttachmentStatus(_ context.Context, id uuid.UUID, from, to string) (bool, error) {
|
||||
a := f.rows[id]
|
||||
if a.Status != from {
|
||||
return false, nil
|
||||
}
|
||||
a.Status = to
|
||||
f.rows[id] = a
|
||||
return true, nil
|
||||
}
|
||||
func (f *fixtureRepo) ReconcileAttachments(context.Context, uuid.UUID) ([]model.Attachment, bool, error) {
|
||||
out := []model.Attachment{}
|
||||
for _, a := range f.rows {
|
||||
out = append(out, a)
|
||||
}
|
||||
return out, f.more, f.failure
|
||||
}
|
||||
|
||||
type fixtureObjects struct {
|
||||
items map[string]port.Object
|
||||
content []byte
|
||||
failure error
|
||||
removed int
|
||||
changed bool
|
||||
}
|
||||
|
||||
func (f *fixtureObjects) Put(context.Context, string, io.Reader, int64, string) error {
|
||||
panic("not used")
|
||||
}
|
||||
func (f *fixtureObjects) Get(context.Context, string) (io.ReadCloser, error) {
|
||||
return io.NopCloser(bytes.NewReader(f.content)), f.failure
|
||||
}
|
||||
func (f *fixtureObjects) Stat(_ context.Context, key string) (port.Object, error) {
|
||||
if f.failure != nil {
|
||||
return port.Object{}, f.failure
|
||||
}
|
||||
o, ok := f.items[key]
|
||||
if !ok {
|
||||
return o, model.ErrNotFound
|
||||
}
|
||||
if f.changed {
|
||||
o.ETag = "changed"
|
||||
}
|
||||
return o, nil
|
||||
}
|
||||
func (f *fixtureObjects) Remove(_ context.Context, key string) error {
|
||||
delete(f.items, key)
|
||||
f.removed++
|
||||
return nil
|
||||
}
|
||||
func (f *fixtureObjects) List(context.Context, string) ([]port.Object, bool, error) {
|
||||
out := []port.Object{}
|
||||
for _, o := range f.items {
|
||||
out = append(out, o)
|
||||
}
|
||||
return out, false, f.failure
|
||||
}
|
||||
|
||||
var fixedNow = time.Date(2026, 11, 12, 12, 0, 0, 0, time.UTC)
|
||||
|
||||
func TestOrphanCleanupHonorsGraceAndDryRun(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
age time.Duration
|
||||
apply, used, changed bool
|
||||
wantDeleted int
|
||||
}{
|
||||
{name: "old dry run", age: 2 * time.Minute},
|
||||
{name: "old apply", age: 2 * time.Minute, apply: true, wantDeleted: 1},
|
||||
{name: "fresh protected", age: 10 * time.Second, apply: true},
|
||||
{name: "future timestamp protected", age: -time.Minute, apply: true},
|
||||
{name: "referenced protected", age: 2 * time.Minute, apply: true, used: true},
|
||||
{name: "changed inventory protected", age: 2 * time.Minute, apply: true, changed: true},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
id := uuid.MustParse("00000000-0000-0000-0000-000000000001")
|
||||
key := ObjectKey(id)
|
||||
repo := &fixtureRepo{rows: map[uuid.UUID]model.Attachment{}}
|
||||
if tc.used {
|
||||
repo.rows[id] = model.Attachment{ID: id, Status: "ready", CreatedAt: fixedNow}
|
||||
}
|
||||
objects := &fixtureObjects{items: map[string]port.Object{key: {Key: key, ETag: "original", Modified: fixedNow.Add(-tc.age)}}, changed: tc.changed}
|
||||
report, e := NewReconciler(repo, objects, func() time.Time { return fixedNow }).Run(context.Background(), uuid.Nil, "", time.Minute, tc.apply)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if objects.removed != tc.wantDeleted {
|
||||
t.Fatalf("deleted %d, want %d; report=%+v", objects.removed, tc.wantDeleted, report)
|
||||
}
|
||||
if tc.wantDeleted > 0 {
|
||||
_, e = NewReconciler(repo, objects, func() time.Time { return fixedNow }).Run(context.Background(), uuid.Nil, "", time.Minute, true)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if objects.removed != 1 {
|
||||
t.Fatal("second run deleted something twice")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
func TestMissingAndPendingMetadataRepair(t *testing.T) {
|
||||
for _, status := range []string{"ready", "uploading", "missing"} {
|
||||
t.Run(status, func(t *testing.T) {
|
||||
id := uuid.New()
|
||||
raw := []byte("original bytes")
|
||||
sum := sha256.Sum256(raw)
|
||||
repo := &fixtureRepo{rows: map[uuid.UUID]model.Attachment{id: {ID: id, Status: status, CreatedAt: fixedNow.Add(-2 * time.Minute), UpdatedAt: fixedNow.Add(-2 * time.Minute), SizeBytes: int64(len(raw)), SHA256: hex.EncodeToString(sum[:])}}}
|
||||
objects := &fixtureObjects{items: map[string]port.Object{}, content: raw}
|
||||
want := "missing"
|
||||
if status != "ready" {
|
||||
objects.items[ObjectKey(id)] = port.Object{Key: ObjectKey(id), Size: int64(len(raw)), Modified: fixedNow.Add(-2 * time.Minute)}
|
||||
want = "ready"
|
||||
}
|
||||
_, e := NewReconciler(repo, objects, func() time.Time { return fixedNow }).Run(context.Background(), uuid.Nil, "", time.Minute, true)
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if got := repo.rows[id].Status; got != want {
|
||||
t.Fatalf("status %s, want %s", got, want)
|
||||
}
|
||||
if objects.removed != 0 {
|
||||
t.Fatal("metadata repair removed original")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
func TestDependencyFailureNeverDeletes(t *testing.T) {
|
||||
repo := &fixtureRepo{rows: map[uuid.UUID]model.Attachment{}, failure: model.ErrUnavailable}
|
||||
objects := &fixtureObjects{items: map[string]port.Object{}}
|
||||
_, e := NewReconciler(repo, objects, func() time.Time { return fixedNow }).Run(context.Background(), uuid.Nil, "", time.Minute, true)
|
||||
if !errors.Is(e, model.ErrUnavailable) {
|
||||
t.Fatalf("expected dependency error, got %v", e)
|
||||
}
|
||||
if objects.removed != 0 {
|
||||
t.Fatal("deleted during failed inventory")
|
||||
}
|
||||
}
|
||||
func TestFailureDoesNotReturnCursorPastFailedRecord(t *testing.T) {
|
||||
id := uuid.New()
|
||||
repo := &fixtureRepo{rows: map[uuid.UUID]model.Attachment{id: {ID: id, Status: "ready", CreatedAt: fixedNow.Add(-2 * time.Minute)}}, more: true}
|
||||
objects := &fixtureObjects{failure: model.ErrUnavailable}
|
||||
report, err := NewReconciler(repo, objects, func() time.Time { return fixedNow }).Run(context.Background(), uuid.Nil, "", time.Minute, true)
|
||||
if !errors.Is(err, model.ErrUnavailable) {
|
||||
t.Fatalf("expected failure, got %v", err)
|
||||
}
|
||||
if report.NextMetadata != "" || report.NextObject != "" {
|
||||
t.Fatal("failed inventory must restart rather than skip the failed item")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/viper"
|
||||
)
|
||||
|
||||
// Config приходит только из окружения (12-factor): в контейнер не копируются
|
||||
// ни .env, ни файлы конфигурации. Значения по умолчанию — ниже.
|
||||
type Config struct {
|
||||
Host string `mapstructure:"APP_HOST"`
|
||||
Port int `mapstructure:"APP_PORT"`
|
||||
Env string `mapstructure:"APP_ENV"`
|
||||
LogLevel string `mapstructure:"LOG_LEVEL"`
|
||||
ShutdownTimeout time.Duration `mapstructure:"SHUTDOWN_TIMEOUT"`
|
||||
MaxBodyBytes int64 `mapstructure:"MAX_BODY_BYTES"`
|
||||
MaxInflight int `mapstructure:"MAX_INFLIGHT"`
|
||||
MaxQueue int `mapstructure:"MAX_QUEUE"`
|
||||
QueueTimeout time.Duration `mapstructure:"QUEUE_TIMEOUT"`
|
||||
DatabaseURLFile string `mapstructure:"DATABASE_URL_FILE"`
|
||||
CacheURLFile string `mapstructure:"CACHE_URL_FILE"`
|
||||
SessionTTLSeconds int `mapstructure:"SESSION_TTL_SECONDS"`
|
||||
MaxConns int32 `mapstructure:"PG_MAX_CONNS"`
|
||||
}
|
||||
|
||||
var defaults = map[string]any{
|
||||
"APP_HOST": "0.0.0.0",
|
||||
"APP_PORT": 8080,
|
||||
"APP_ENV": "lab",
|
||||
"LOG_LEVEL": "info",
|
||||
"SHUTDOWN_TIMEOUT": "8s",
|
||||
"MAX_BODY_BYTES": 64 << 10,
|
||||
"MAX_INFLIGHT": 4,
|
||||
"MAX_QUEUE": 32,
|
||||
"QUEUE_TIMEOUT": "1s",
|
||||
"DATABASE_URL_FILE": "/run/secrets/database_url",
|
||||
"CACHE_URL_FILE": "/run/secrets/cache_url",
|
||||
"SESSION_TTL_SECONDS": 3600,
|
||||
"PG_MAX_CONNS": 8,
|
||||
}
|
||||
|
||||
func Load() (Config, error) {
|
||||
v := viper.New()
|
||||
for key, value := range defaults {
|
||||
v.SetDefault(key, value)
|
||||
}
|
||||
v.AutomaticEnv()
|
||||
var cfg Config
|
||||
if err := v.Unmarshal(&cfg); err != nil {
|
||||
return Config{}, fmt.Errorf("parse config: %w", err)
|
||||
}
|
||||
if cfg.ShutdownTimeout <= 0 || cfg.ShutdownTimeout > 9*time.Second {
|
||||
return Config{}, fmt.Errorf("SHUTDOWN_TIMEOUT must be in (0, 9s]: docker stop ждёт 10 с")
|
||||
}
|
||||
if cfg.SessionTTLSeconds < 1 || cfg.SessionTTLSeconds > 86400 {
|
||||
return Config{}, fmt.Errorf("SESSION_TTL_SECONDS must be 1..86400")
|
||||
}
|
||||
if cfg.MaxConns < 1 || cfg.MaxConns > 64 {
|
||||
return Config{}, fmt.Errorf("PG_MAX_CONNS must be 1..64")
|
||||
}
|
||||
if cfg.MaxInflight < 1 || cfg.MaxInflight > 4 || cfg.MaxQueue < 0 || cfg.MaxQueue > 128 || cfg.QueueTimeout <= 0 || cfg.QueueTimeout > 2*time.Second {
|
||||
return Config{}, fmt.Errorf("HTTP gate exceeds the tested resource budget")
|
||||
}
|
||||
if cfg.MaxBodyBytes < 1 || cfg.MaxBodyBytes > 65536 {
|
||||
return Config{}, fmt.Errorf("MAX_BODY_BYTES must be 1..65536")
|
||||
}
|
||||
return cfg, nil
|
||||
}
|
||||
|
||||
func (c Config) Addr() string { return fmt.Sprintf("%s:%d", c.Host, c.Port) }
|
||||
|
||||
func ReadSecret(path string) (string, error) {
|
||||
b, e := os.ReadFile(path)
|
||||
if e != nil {
|
||||
return "", fmt.Errorf("required secret file unavailable")
|
||||
}
|
||||
v := strings.TrimSpace(string(b))
|
||||
if v == "" {
|
||||
return "", fmt.Errorf("required secret is empty")
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
package config
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestRejectsConfigurationOutsideResourceBudget(t *testing.T) {
|
||||
for _, tc := range []struct{ key, value string }{{"MAX_INFLIGHT", "0"}, {"MAX_INFLIGHT", "5"}, {"MAX_QUEUE", "-1"}, {"MAX_QUEUE", "129"}, {"QUEUE_TIMEOUT", "0s"}, {"QUEUE_TIMEOUT", "3s"}, {"MAX_BODY_BYTES", "0"}, {"MAX_BODY_BYTES", "65537"}, {"PG_MAX_CONNS", "0"}, {"PG_MAX_CONNS", "65"}, {"SESSION_TTL_SECONDS", "0"}, {"SESSION_TTL_SECONDS", "86401"}} {
|
||||
t.Run(tc.key+tc.value, func(t *testing.T) {
|
||||
t.Setenv(tc.key, tc.value)
|
||||
if _, e := Load(); e == nil {
|
||||
t.Fatal("accepted configuration beyond tested bounds")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
func TestPoolSizeIsConfigurableWithinBounds(t *testing.T) {
|
||||
t.Setenv("PG_MAX_CONNS", "1")
|
||||
cfg, e := Load()
|
||||
if e != nil {
|
||||
t.Fatal(e)
|
||||
}
|
||||
if cfg.MaxConns != 1 {
|
||||
t.Fatal("configured pool size ignored")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"github.com/google/uuid"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
const MaxImageBytes int64 = 10 * 1024 * 1024
|
||||
const MaxImagePixels int64 = 40_000_000
|
||||
|
||||
type Attachment struct {
|
||||
ID, ChatID, OwnerID uuid.UUID
|
||||
Filename, ContentType, SHA256, Status string
|
||||
SizeBytes int64
|
||||
CreatedAt, UpdatedAt time.Time
|
||||
PipelineVersion int32
|
||||
ErrorCode string
|
||||
Variants []Variant
|
||||
StagingExpired, StagingCleaned bool
|
||||
}
|
||||
|
||||
func ValidateFilename(name string) error {
|
||||
if !utf8.ValidString(name) || utf8.RuneCountInString(name) < 1 || utf8.RuneCountInString(name) > 255 || strings.TrimSpace(name) == "" {
|
||||
return invalidf("filename: 1–255 characters required")
|
||||
}
|
||||
for _, r := range name {
|
||||
if r == '/' || r == '\\' || unicode.IsControl(r) {
|
||||
return invalidf("filename: invalid character")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"slices"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const maxChatMembers = 100
|
||||
|
||||
// Chat неизменяем после создания: участники задаются один раз, удаления в API нет.
|
||||
type Chat struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
MemberIDs []uuid.UUID
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
func (c Chat) HasMember(userID uuid.UUID) bool {
|
||||
return slices.Contains(c.MemberIDs, userID)
|
||||
}
|
||||
|
||||
// ChatDraft — проверенные данные нового чата. Существование участников
|
||||
// проверяет хранилище атомарно с созданием.
|
||||
type ChatDraft struct {
|
||||
Creator uuid.UUID
|
||||
Title string
|
||||
MemberIDs []uuid.UUID
|
||||
}
|
||||
|
||||
func NewChatDraft(creator uuid.UUID, title string, memberIDs []uuid.UUID) (ChatDraft, error) {
|
||||
if err := requireText("title", title, 1, 100); err != nil {
|
||||
return ChatDraft{}, err
|
||||
}
|
||||
if len(memberIDs) == 0 || len(memberIDs) > maxChatMembers {
|
||||
return ChatDraft{}, invalidf("member_ids: от 1 до %d участников", maxChatMembers)
|
||||
}
|
||||
seen := make(map[uuid.UUID]struct{}, len(memberIDs))
|
||||
for _, id := range memberIDs {
|
||||
if _, dup := seen[id]; dup {
|
||||
return ChatDraft{}, invalidf("member_ids: повторяющийся участник")
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
}
|
||||
if _, ok := seen[creator]; !ok {
|
||||
return ChatDraft{}, invalidf("member_ids: должен содержать создателя чата")
|
||||
}
|
||||
return ChatDraft{Creator: creator, Title: title, MemberIDs: slices.Clone(memberIDs)}, nil
|
||||
}
|
||||
|
||||
func (c Chat) Position() Position { return Position{CreatedAt: c.CreatedAt, ID: c.ID} }
|
||||
@@ -0,0 +1,33 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrUnavailable = errors.New("dependency unavailable")
|
||||
ErrInvalidImage = errors.New("invalid staged image")
|
||||
ErrConflict = errors.New("conflict")
|
||||
ErrNotFound = errors.New("not found")
|
||||
ErrUnauthorized = errors.New("unauthorized")
|
||||
ErrUsernameTaken = errors.New("username taken")
|
||||
// ErrStorageFull — исчерпан бюджет памяти хранилища. Подтверждённые данные
|
||||
// не вытесняются, поэтому новые записи отклоняются, а чтение продолжает работать.
|
||||
ErrStorageFull = errors.New("storage full")
|
||||
// ErrUnknownMember возвращает хранилище, если среди участников нового чата
|
||||
// есть несуществующий пользователь; для клиента это ошибка ввода (400).
|
||||
ErrUnknownMember error = &ValidationError{Message: "member_ids: неизвестный пользователь"}
|
||||
)
|
||||
|
||||
// ValidationError — нарушение правил входных данных; Message безопасно
|
||||
// показывать клиенту.
|
||||
type ValidationError struct {
|
||||
Message string
|
||||
}
|
||||
|
||||
func (e *ValidationError) Error() string { return e.Message }
|
||||
|
||||
func invalidf(format string, args ...any) error {
|
||||
return &ValidationError{Message: fmt.Sprintf(format, args...)}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"github.com/google/uuid"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Variant struct {
|
||||
Name string `json:"name"`
|
||||
ContentType string `json:"content_type"`
|
||||
SHA256 string `json:"sha256"`
|
||||
SizeBytes int64 `json:"size_bytes"`
|
||||
Width int `json:"width"`
|
||||
Height int `json:"height"`
|
||||
}
|
||||
type Job struct {
|
||||
ID uuid.UUID `json:"job_id"`
|
||||
AttachmentID uuid.UUID `json:"attachment_id"`
|
||||
PipelineVersion int32 `json:"pipeline_version"`
|
||||
Attempt int32 `json:"attempt"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
Traceparent string `json:"traceparent,omitempty"`
|
||||
Tracestate string `json:"tracestate,omitempty"`
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"regexp"
|
||||
"slices"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const MaxMessageRunes = 4000
|
||||
|
||||
type Message struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
CreatedAt time.Time
|
||||
AttachmentIDs []uuid.UUID
|
||||
}
|
||||
|
||||
// MessageDraft — проверенное сообщение; отправитель берётся из идентификации,
|
||||
// а не из тела запроса.
|
||||
type MessageDraft struct {
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
Key string
|
||||
PayloadHash string
|
||||
AttachmentIDs []uuid.UUID
|
||||
}
|
||||
|
||||
var keyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
|
||||
|
||||
func WithKey(d MessageDraft, key string) (MessageDraft, error) {
|
||||
if !keyPattern.MatchString(key) {
|
||||
return MessageDraft{}, invalidf("Idempotency-Key: 1–128 ASCII characters required")
|
||||
}
|
||||
canonical, _ := json.Marshal(struct {
|
||||
Text string
|
||||
Attachments []uuid.UUID
|
||||
}{d.Text, d.AttachmentIDs})
|
||||
sum := sha256.Sum256(canonical)
|
||||
d.Key = key
|
||||
d.PayloadHash = hex.EncodeToString(sum[:])
|
||||
return d, nil
|
||||
}
|
||||
|
||||
func NewMessageDraft(chatID, senderID uuid.UUID, text string, attachments ...[]uuid.UUID) (MessageDraft, error) {
|
||||
ids := []uuid.UUID{}
|
||||
if len(attachments) > 0 {
|
||||
ids = slices.Clone(attachments[0])
|
||||
if ids == nil {
|
||||
ids = []uuid.UUID{}
|
||||
}
|
||||
}
|
||||
if len(ids) > 10 {
|
||||
return MessageDraft{}, invalidf("attachment_ids: at most 10")
|
||||
}
|
||||
seen := map[uuid.UUID]bool{}
|
||||
for _, id := range ids {
|
||||
if seen[id] {
|
||||
return MessageDraft{}, invalidf("attachment_ids: duplicate")
|
||||
}
|
||||
seen[id] = true
|
||||
}
|
||||
if len(ids) == 0 || strings.TrimSpace(text) != "" {
|
||||
if err := requireText("text", text, 1, MaxMessageRunes); err != nil {
|
||||
return MessageDraft{}, err
|
||||
}
|
||||
} else if !utf8.ValidString(text) || utf8.RuneCountInString(text) > MaxMessageRunes || strings.ContainsRune(text, 0) {
|
||||
return MessageDraft{}, invalidf("text: invalid optional text")
|
||||
}
|
||||
return MessageDraft{ChatID: chatID, SenderID: senderID, Text: text, AttachmentIDs: ids}, nil
|
||||
}
|
||||
|
||||
func (m Message) Position() Position { return Position{CreatedAt: m.CreatedAt, ID: m.ID} }
|
||||
@@ -0,0 +1,126 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
func isValidationError(err error) bool {
|
||||
var v *ValidationError
|
||||
return errors.As(err, &v)
|
||||
}
|
||||
|
||||
func TestNewUserDraft(t *testing.T) {
|
||||
t.Parallel()
|
||||
cases := []struct {
|
||||
name, username, display string
|
||||
ok bool
|
||||
}{
|
||||
{"minimal", "abc", "A", true},
|
||||
{"max username 32", strings.Repeat("a", 32), "A", true},
|
||||
{"username too short", "ab", "A", false},
|
||||
{"username too long", strings.Repeat("a", 33), "A", false},
|
||||
{"uppercase rejected", "Alice", "A", false},
|
||||
{"cyrillic username rejected", "алиса", "A", false},
|
||||
{"display 100 emoji ok", "abc", strings.Repeat("😀", 100), true},
|
||||
{"display 101 code points rejected", "abc", strings.Repeat("ж", 101), false},
|
||||
{"display whitespace only", "abc", " \t\n", false},
|
||||
{"display empty", "abc", "", false},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
_, err := NewUserDraft(tc.username, tc.display)
|
||||
if tc.ok && err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if !tc.ok && !isValidationError(err) {
|
||||
t.Fatalf("want ValidationError, got %v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewChatDraft(t *testing.T) {
|
||||
t.Parallel()
|
||||
me, other := uuid.New(), uuid.New()
|
||||
tooMany := []uuid.UUID{me}
|
||||
for range 100 {
|
||||
tooMany = append(tooMany, uuid.New())
|
||||
}
|
||||
cases := []struct {
|
||||
name string
|
||||
members []uuid.UUID
|
||||
ok bool
|
||||
}{
|
||||
{"creator only", []uuid.UUID{me}, true},
|
||||
{"two members", []uuid.UUID{me, other}, true},
|
||||
{"empty", nil, false},
|
||||
{"creator missing", []uuid.UUID{other}, false},
|
||||
{"duplicate member", []uuid.UUID{me, other, other}, false},
|
||||
{"over 100 members", tooMany, false},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
_, err := NewChatDraft(me, "Чат", tc.members)
|
||||
if tc.ok != (err == nil) {
|
||||
t.Fatalf("ok=%v, err=%v", tc.ok, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewMessageDraftLimitsInCodePoints(t *testing.T) {
|
||||
t.Parallel()
|
||||
if _, err := NewMessageDraft(uuid.New(), uuid.New(), strings.Repeat("👋", MaxMessageRunes)); err != nil {
|
||||
t.Fatalf("4000 four-byte code points must pass: %v", err)
|
||||
}
|
||||
if _, err := NewMessageDraft(uuid.New(), uuid.New(), strings.Repeat("a", MaxMessageRunes+1)); !isValidationError(err) {
|
||||
t.Fatalf("4001 code points must be rejected, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCursorRoundTripAndScope(t *testing.T) {
|
||||
t.Parallel()
|
||||
pos := Position{CreatedAt: time.Date(2026, 9, 1, 12, 0, 0, 123456000, time.UTC), ID: uuid.New()}
|
||||
cursor := EncodeCursor("messages:a", pos)
|
||||
|
||||
q, err := NewPageQuery(nil, &cursor, "messages:a")
|
||||
if err != nil || q.After == nil || *q.After != pos || q.Limit != DefaultPageLimit {
|
||||
t.Fatalf("round trip failed: %+v, %v", q, err)
|
||||
}
|
||||
if _, err := NewPageQuery(nil, &cursor, "messages:b"); !isValidationError(err) {
|
||||
t.Fatalf("cursor of another resource must be rejected, got %v", err)
|
||||
}
|
||||
for _, bad := range []string{"", "!!!", EncodeCursor("x", pos)[:5]} {
|
||||
if _, err := NewPageQuery(nil, &bad, "messages:a"); !isValidationError(err) {
|
||||
t.Fatalf("garbage cursor %q must be rejected, got %v", bad, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPageLimitBounds(t *testing.T) {
|
||||
t.Parallel()
|
||||
for limit, ok := range map[int]bool{0: false, 1: true, 100: true, 101: false, -1: false} {
|
||||
_, err := NewPageQuery(&limit, nil, "chats")
|
||||
if ok != (err == nil) {
|
||||
t.Errorf("limit=%d: ok=%v, err=%v", limit, ok, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPositionOrderTiesBrokenByID(t *testing.T) {
|
||||
t.Parallel()
|
||||
at := time.Now()
|
||||
low := Position{CreatedAt: at, ID: uuid.MustParse("00000000-0000-4000-8000-000000000001")}
|
||||
high := Position{CreatedAt: at, ID: uuid.MustParse("ffffffff-0000-4000-8000-000000000000")}
|
||||
later := Position{CreatedAt: at.Add(time.Microsecond), ID: low.ID}
|
||||
if !high.After(low) || low.After(high) || !later.After(high) || low.After(low) {
|
||||
t.Fatal("order must be (created_at, id) ascending")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/base64"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const (
|
||||
DefaultPageLimit = 50
|
||||
MaxPageLimit = 100
|
||||
)
|
||||
|
||||
// Position — ключ keyset-пагинации: история упорядочена по (created_at, id).
|
||||
type Position struct {
|
||||
CreatedAt time.Time
|
||||
ID uuid.UUID
|
||||
}
|
||||
|
||||
// After сообщает, стоит ли p строго после other в порядке (created_at, id).
|
||||
func (p Position) After(other Position) bool {
|
||||
if !p.CreatedAt.Equal(other.CreatedAt) {
|
||||
return p.CreatedAt.After(other.CreatedAt)
|
||||
}
|
||||
return bytes.Compare(p.ID[:], other.ID[:]) > 0
|
||||
}
|
||||
|
||||
// PageQuery — проверенный запрос страницы: limit 1–100 и позиция после
|
||||
// последнего элемента предыдущей страницы (nil — с начала).
|
||||
type PageQuery struct {
|
||||
Limit int
|
||||
After *Position
|
||||
}
|
||||
|
||||
// NewPageQuery проверяет limit и курсор. scope привязывает курсор к ресурсу:
|
||||
// курсор истории одного чата не подходит к другому чату или к списку чатов.
|
||||
func NewPageQuery(limit *int, cursor *string, scope string) (PageQuery, error) {
|
||||
q := PageQuery{Limit: DefaultPageLimit}
|
||||
if limit != nil {
|
||||
if *limit < 1 || *limit > MaxPageLimit {
|
||||
return PageQuery{}, invalidf("limit: от 1 до %d", MaxPageLimit)
|
||||
}
|
||||
q.Limit = *limit
|
||||
}
|
||||
if cursor != nil {
|
||||
pos, err := decodeCursor(*cursor, scope)
|
||||
if err != nil {
|
||||
return PageQuery{}, err
|
||||
}
|
||||
q.After = &pos
|
||||
}
|
||||
return q, nil
|
||||
}
|
||||
|
||||
// EncodeCursor делает непрозрачную для клиента строку из позиции и scope.
|
||||
func EncodeCursor(scope string, p Position) string {
|
||||
raw := scope + "|" + strconv.FormatInt(p.CreatedAt.UnixMicro(), 10) + "|" + p.ID.String()
|
||||
return base64.RawURLEncoding.EncodeToString([]byte(raw))
|
||||
}
|
||||
|
||||
func decodeCursor(cursor, scope string) (Position, error) {
|
||||
errBad := invalidf("cursor: некорректное значение")
|
||||
raw, err := base64.RawURLEncoding.DecodeString(cursor)
|
||||
if err != nil {
|
||||
return Position{}, errBad
|
||||
}
|
||||
parts := strings.Split(string(raw), "|")
|
||||
if len(parts) != 3 || parts[0] != scope {
|
||||
return Position{}, errBad
|
||||
}
|
||||
micros, err := strconv.ParseInt(parts[1], 10, 64)
|
||||
if err != nil {
|
||||
return Position{}, errBad
|
||||
}
|
||||
id, err := uuid.Parse(parts[2])
|
||||
if err != nil {
|
||||
return Position{}, errBad
|
||||
}
|
||||
return Position{CreatedAt: time.UnixMicro(micros).UTC(), ID: id}, nil
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
package model
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestRejectsNULInPersistedText(t *testing.T) {
|
||||
for _, field := range []string{"display_name", "title", "text"} {
|
||||
t.Run(field, func(t *testing.T) {
|
||||
if err := requireText(field, "a\x00b", 1, 4000); err == nil {
|
||||
t.Fatal("PostgreSQL text must reject NUL as a validation error")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// requireText проверяет обязательную строку: длина в Unicode code points
|
||||
// (не в байтах) и запрет строк только из пробельных символов.
|
||||
func requireText(field, value string, minLen, maxLen int) error {
|
||||
if strings.ContainsRune(value, 0) {
|
||||
return invalidf("%s: NUL недопустим в PostgreSQL text", field)
|
||||
}
|
||||
if !utf8.ValidString(value) {
|
||||
return invalidf("%s: некорректный UTF-8", field)
|
||||
}
|
||||
if strings.TrimSpace(value) == "" {
|
||||
return invalidf("%s: пустая строка", field)
|
||||
}
|
||||
if n := utf8.RuneCountInString(value); n < minLen || n > maxLen {
|
||||
return invalidf("%s: длина должна быть от %d до %d символов", field, minLen, maxLen)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
|
||||
|
||||
type User struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// UserDraft — проверенные данные нового пользователя; ID и время назначает хранилище.
|
||||
type UserDraft struct {
|
||||
Username string
|
||||
DisplayName string
|
||||
PasswordHash string
|
||||
}
|
||||
|
||||
func NewUserDraft(username, displayName string) (UserDraft, error) {
|
||||
if !usernamePattern.MatchString(username) {
|
||||
return UserDraft{}, invalidf("username: допустимо [a-z0-9_], от 3 до 32 символов")
|
||||
}
|
||||
if err := requireText("display_name", displayName, 1, 100); err != nil {
|
||||
return UserDraft{}, err
|
||||
}
|
||||
return UserDraft{Username: username, DisplayName: displayName}, nil
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
package port
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/google/uuid"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Passwords interface {
|
||||
Hash(string) (string, error)
|
||||
Verify(string, string) bool
|
||||
}
|
||||
type Sessions interface {
|
||||
Credentials(context.Context, string) (uuid.UUID, string, error)
|
||||
CreateSession(context.Context, string, uuid.UUID, time.Time) error
|
||||
AuthenticateSession(context.Context, string) (uuid.UUID, error)
|
||||
RevokeSession(context.Context, string) error
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
package port
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Object struct {
|
||||
Key, ETag string
|
||||
Size int64
|
||||
Modified time.Time
|
||||
}
|
||||
type Objects interface {
|
||||
Put(context.Context, string, io.Reader, int64, string) error
|
||||
Get(context.Context, string) (io.ReadCloser, error)
|
||||
Stat(context.Context, string) (Object, error)
|
||||
Remove(context.Context, string) error
|
||||
List(context.Context, string) ([]Object, bool, error)
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
package port
|
||||
|
||||
import (
|
||||
"backend/internal/domain/model"
|
||||
"context"
|
||||
"github.com/google/uuid"
|
||||
"io"
|
||||
"time"
|
||||
)
|
||||
|
||||
type PipelineStore interface {
|
||||
PendingJobs(context.Context) ([]model.Job, error)
|
||||
Published(context.Context, uuid.UUID) error
|
||||
AcquireJob(context.Context, model.Job, uuid.UUID, time.Duration) (model.Job, model.Attachment, bool, error)
|
||||
CompleteJob(context.Context, model.Job, uuid.UUID, []model.Variant) (bool, error)
|
||||
RetryJob(context.Context, model.Job, uuid.UUID, string, time.Duration, bool) error
|
||||
ReplayJob(context.Context, uuid.UUID) (bool, error)
|
||||
AdvancePipeline(context.Context, uuid.UUID) (bool, error)
|
||||
StagingCleanup(context.Context) ([]model.Attachment, error)
|
||||
StagingCleaned(context.Context, uuid.UUID) error
|
||||
}
|
||||
type Transformer interface {
|
||||
Transform(context.Context, io.Reader) ([]ProcessedVariant, error)
|
||||
}
|
||||
type ProcessedVariant struct {
|
||||
Metadata model.Variant
|
||||
Bytes []byte
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
// Package repository — порт персистентности. В lab1 его реализует хранилище
|
||||
// в памяти процесса, с lab2 — PostgreSQL; ядро от этой замены не меняется.
|
||||
package repository
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"backend/internal/domain/model"
|
||||
"backend/internal/domain/port"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
// Repository assigns IDs and database timestamps. Keyset order is (created_at, id);
|
||||
// concurrent commits do not provide insertion order or a traversal snapshot.
|
||||
// Каждый метод атомарен сам по себе.
|
||||
type Repository interface {
|
||||
UserRepository
|
||||
ChatRepository
|
||||
MessageRepository
|
||||
AttachmentRepository
|
||||
}
|
||||
|
||||
type AttachmentRepository interface {
|
||||
ReserveAttachment(context.Context, model.Attachment) (model.Attachment, error)
|
||||
GetAttachment(context.Context, uuid.UUID) (model.Attachment, error)
|
||||
SetAttachmentStatus(context.Context, uuid.UUID, string, string) (bool, error)
|
||||
ReconcileAttachments(context.Context, uuid.UUID) ([]model.Attachment, bool, error)
|
||||
}
|
||||
|
||||
type Persistent interface {
|
||||
Repository
|
||||
port.Sessions
|
||||
AsyncAttachments
|
||||
port.PipelineStore
|
||||
}
|
||||
|
||||
type AsyncAttachments interface {
|
||||
AttachmentRepository
|
||||
QueueAttachment(context.Context, model.Attachment, string, string) (model.Attachment, error)
|
||||
}
|
||||
|
||||
type UserRepository interface {
|
||||
// CreateUser: model.ErrUsernameTaken, model.ErrStorageFull.
|
||||
CreateUser(ctx context.Context, draft model.UserDraft) (model.User, error)
|
||||
// GetUser: model.ErrNotFound.
|
||||
GetUser(ctx context.Context, id uuid.UUID) (model.User, error)
|
||||
}
|
||||
|
||||
type ChatRepository interface {
|
||||
// CreateChat: model.ErrUnknownMember, model.ErrStorageFull.
|
||||
CreateChat(ctx context.Context, draft model.ChatDraft) (model.Chat, error)
|
||||
// GetChat: model.ErrNotFound.
|
||||
GetChat(ctx context.Context, id uuid.UUID) (model.Chat, error)
|
||||
// ListChats возвращает чаты участника и признак, что есть следующая страница.
|
||||
ListChats(ctx context.Context, memberID uuid.UUID, q model.PageQuery) ([]model.Chat, bool, error)
|
||||
}
|
||||
|
||||
type MessageRepository interface {
|
||||
// CreateMessage: model.ErrNotFound (нет чата), model.ErrStorageFull.
|
||||
CreateMessage(ctx context.Context, draft model.MessageDraft) (model.Message, error)
|
||||
// ListMessages возвращает страницу истории и признак следующей страницы.
|
||||
ListMessages(ctx context.Context, chatID uuid.UUID, q model.PageQuery) ([]model.Message, bool, error)
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
package logger
|
||||
|
||||
import (
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/rs/zerolog"
|
||||
)
|
||||
|
||||
// New — JSON-логи в stdout, их собирает docker logs.
|
||||
func New(level string) zerolog.Logger {
|
||||
lvl, err := zerolog.ParseLevel(level)
|
||||
if err != nil || level == "" {
|
||||
lvl = zerolog.InfoLevel
|
||||
}
|
||||
zerolog.TimeFieldFormat = time.RFC3339Nano
|
||||
return zerolog.New(os.Stdout).Level(lvl).With().Timestamp().Logger()
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Server struct {
|
||||
httpServer *http.Server
|
||||
}
|
||||
|
||||
func New(addr string, handler http.Handler) *Server {
|
||||
return &Server{httpServer: &http.Server{
|
||||
Addr: addr,
|
||||
Handler: handler,
|
||||
ReadHeaderTimeout: 5 * time.Second,
|
||||
ReadTimeout: 15 * time.Second,
|
||||
WriteTimeout: 15 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
MaxHeaderBytes: 16 << 10,
|
||||
}}
|
||||
}
|
||||
|
||||
func (s *Server) ListenAndServe() error { return s.httpServer.ListenAndServe() }
|
||||
|
||||
// Shutdown сразу закрывает слушающий сокет (новые соединения не принимаются)
|
||||
// и ждёт завершения начатых запросов, но не дольше ctx.
|
||||
func (s *Server) Shutdown(ctx context.Context) error { return s.httpServer.Shutdown(ctx) }
|
||||
+122
@@ -0,0 +1,122 @@
|
||||
name: mtuci-vp5-medvedev
|
||||
x-api: &api
|
||||
image: mtuci-vp5:local
|
||||
build: .
|
||||
cpus: 1
|
||||
mem_limit: 2g
|
||||
stop_grace_period: 10s
|
||||
read_only: true
|
||||
security_opt: [no-new-privileges:true]
|
||||
cap_drop: [ALL]
|
||||
tmpfs: ['/tmp:uid=65532,gid=65532,size=256m,mode=1777']
|
||||
environment:
|
||||
APP_PORT: 8080
|
||||
SESSION_TTL_SECONDS: 3600
|
||||
PG_MAX_CONNS: 8
|
||||
GOMEMLIMIT: 1536MiB
|
||||
secrets: [database_url, cache_url, s3_credentials]
|
||||
depends_on:
|
||||
migrate: {condition: service_completed_successfully}
|
||||
valkey: {condition: service_started}
|
||||
bootstrap: {condition: service_completed_successfully}
|
||||
networks: [private]
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:18.6@sha256:74935e72241653ca55e0414067e6d8763aceb8a810eb51b452253ec3dcfc4336
|
||||
cpus: 1
|
||||
mem_limit: 768m
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/pg_password
|
||||
secrets: [pg_password]
|
||||
volumes: [postgres:/var/lib/postgresql]
|
||||
healthcheck:
|
||||
test: [CMD-SHELL, pg_isready -U messenger -d messenger]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 30
|
||||
networks: [private]
|
||||
valkey:
|
||||
image: valkey/valkey:9@sha256:418652cfb58ef879d4978c33553735d7147016032d5aefaa14c828e611eb9dfd
|
||||
cpus: 0.25
|
||||
mem_limit: 128m
|
||||
command: [valkey-server, /run/secrets/valkey_conf]
|
||||
secrets: [valkey_conf]
|
||||
volumes: [valkey:/data]
|
||||
networks: [private]
|
||||
s3:
|
||||
image: rustfs/rustfs:1.0.0-rc.1@sha256:f53d700fc16809070326f6ab3fb565d48e722364a7bd5a12e47d0a5abe079ce6
|
||||
cpus: 1
|
||||
mem_limit: 768m
|
||||
environment:
|
||||
RUSTFS_ACCESS_KEY_FILE: /run/secrets/s3_access
|
||||
RUSTFS_SECRET_KEY_FILE: /run/secrets/s3_secret
|
||||
RUSTFS_VOLUMES: /data
|
||||
RUSTFS_CONSOLE_ENABLE: 'false'
|
||||
secrets: [s3_access,s3_secret]
|
||||
volumes: [s3:/data]
|
||||
healthcheck:
|
||||
test: [CMD,curl,-f,http://127.0.0.1:9000/health]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 40
|
||||
networks: [private]
|
||||
migrate:
|
||||
image: mtuci-vp5:local
|
||||
build: .
|
||||
command: [-migrate]
|
||||
cpus: 0.5
|
||||
mem_limit: 256m
|
||||
secrets: [database_url]
|
||||
depends_on:
|
||||
postgres: {condition: service_healthy}
|
||||
networks: [private]
|
||||
bootstrap:
|
||||
image: mtuci-vp5:local
|
||||
build: .
|
||||
command: [-bootstrap-s3]
|
||||
cpus: 0.5
|
||||
mem_limit: 256m
|
||||
secrets: [database_url,s3_root,s3_credentials]
|
||||
depends_on:
|
||||
s3: {condition: service_healthy}
|
||||
networks: [private]
|
||||
api:
|
||||
<<: *api
|
||||
deploy: {replicas: 2}
|
||||
worker:
|
||||
<<: *api
|
||||
entrypoint: [/worker]
|
||||
cpus: 1
|
||||
mem_limit: 2g
|
||||
tmpfs: ['/tmp:uid=65532,gid=65532,size=256m,mode=1777']
|
||||
environment:
|
||||
GOMEMLIMIT: 384MiB
|
||||
WORKER_MAX_ATTEMPTS: 5
|
||||
lb:
|
||||
image: haproxy:3.2-alpine@sha256:1c3568e520453cc8ba98c39501febcf450429c80e6cc27ecad779961d76e597c
|
||||
cpus: 0.25
|
||||
mem_limit: 128m
|
||||
ports: ['127.0.0.1:28205:8080']
|
||||
volumes: ['./config/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro']
|
||||
depends_on:
|
||||
api: {condition: service_started}
|
||||
networks: [private,edge]
|
||||
networks:
|
||||
private: {internal: true}
|
||||
edge: {}
|
||||
volumes:
|
||||
postgres: {}
|
||||
valkey: {}
|
||||
s3: {}
|
||||
secrets:
|
||||
pg_password: {file: .local/pg_password}
|
||||
database_url: {file: .local/database_url}
|
||||
cache_url: {file: .local/cache_url}
|
||||
valkey_conf: {file: .local/valkey.conf}
|
||||
s3_access: {file: .local/s3_access}
|
||||
s3_secret: {file: .local/s3_secret}
|
||||
s3_root: {file: .local/s3_root}
|
||||
s3_credentials: {file: .local/s3_credentials}
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
global
|
||||
log stdout format raw local0
|
||||
maxconn 256
|
||||
defaults
|
||||
mode http
|
||||
log global
|
||||
timeout connect 1s
|
||||
timeout client 20s
|
||||
timeout server 25s
|
||||
retries 0
|
||||
resolvers docker
|
||||
nameserver dns 127.0.0.11:53
|
||||
resolve_retries 2
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
hold valid 1s
|
||||
hold obsolete 1s
|
||||
frontend public
|
||||
bind :8080
|
||||
default_backend api
|
||||
backend api
|
||||
balance roundrobin
|
||||
option httpchk
|
||||
http-check send meth GET uri /health/ready
|
||||
http-check expect status 200
|
||||
default-server inter 500ms fall 2 rise 1
|
||||
server-template replica 1-4 api:8080 check resolvers docker resolve-prefer ipv4 init-addr none
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"checked_at": "2026-11-15T17:22:02.090Z",
|
||||
"results": [
|
||||
{
|
||||
"stopped_instance": "3e051955bcf1",
|
||||
"surviving_instance": "168a40088e2e",
|
||||
"session_preserved": true,
|
||||
"confirmed_messages": 2,
|
||||
"recovery_observed_ms": 1025
|
||||
},
|
||||
{
|
||||
"stopped_instance": "168a40088e2e",
|
||||
"surviving_instance": "3e051955bcf1",
|
||||
"session_preserved": true,
|
||||
"confirmed_messages": 4,
|
||||
"recovery_observed_ms": 27
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
Running as unit: run-p1145148-i22068280.scope; invocation ID: 9e77b7f9f1504b5d92284f2490cd0a95
|
||||
{"checked_at":"2026-11-15T17:22:02.090Z","results":[{"stopped_instance":"3e051955bcf1","surviving_instance":"168a40088e2e","session_preserved":true,"confirmed_messages":2,"recovery_observed_ms":1025},{"stopped_instance":"168a40088e2e","surviving_instance":"3e051955bcf1","session_preserved":true,"confirmed_messages":4,"recovery_observed_ms":27}]}
|
||||
@@ -0,0 +1,149 @@
|
||||
Running as unit: run-p1218114-i22148514.scope; invocation ID: 259d09db44e74bd38eead4c7940a0c94
|
||||
? backend/cmd/app [no test files]
|
||||
? backend/cmd/worker [no test files]
|
||||
? backend/db [no test files]
|
||||
ok backend/integration (cached)
|
||||
ok backend/internal/adapter/handler (cached)
|
||||
ok backend/internal/adapter/imagefile (cached)
|
||||
? backend/internal/adapter/password [no test files]
|
||||
? backend/internal/adapter/queue [no test files]
|
||||
ok backend/internal/adapter/repository/postgres 1.011s
|
||||
? backend/internal/adapter/repository/postgres/queries [no test files]
|
||||
ok backend/internal/adapter/storage (cached)
|
||||
ok backend/internal/application/usecase 1.009s
|
||||
ok backend/internal/config (cached)
|
||||
ok backend/internal/domain/model (cached)
|
||||
? backend/internal/domain/port [no test files]
|
||||
? backend/internal/domain/repository [no test files]
|
||||
? backend/pkg/logger [no test files]
|
||||
? backend/pkg/server [no test files]
|
||||
0 issues.
|
||||
Image mtuci-vp5:local Building
|
||||
#1 [internal] load local bake definitions
|
||||
#1 reading from stdin 1.53kB done
|
||||
#1 DONE 0.0s
|
||||
|
||||
#2 [internal] load build definition from Dockerfile
|
||||
#2 transferring dockerfile: 839B done
|
||||
#2 DONE 0.1s
|
||||
|
||||
#3 resolve image config for docker-image://docker.io/docker/dockerfile:1
|
||||
#3 DONE 4.9s
|
||||
|
||||
#4 docker-image://docker.io/docker/dockerfile:1@sha256:4edf897a3ffa55b89f906fc8cc78afdb3f1834cc9c7083565e611a8a7d5fe99e
|
||||
#4 resolve docker.io/docker/dockerfile:1@sha256:4edf897a3ffa55b89f906fc8cc78afdb3f1834cc9c7083565e611a8a7d5fe99e
|
||||
#4 resolve docker.io/docker/dockerfile:1@sha256:4edf897a3ffa55b89f906fc8cc78afdb3f1834cc9c7083565e611a8a7d5fe99e 0.2s done
|
||||
#4 CACHED
|
||||
|
||||
#5 [internal] load metadata for docker.io/library/debian@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f
|
||||
#5 ...
|
||||
|
||||
#6 [internal] load metadata for docker.io/library/golang:1.27.2-alpine@sha256:f92b6ef800e499660581efdabdf25d9d817a9d124eaf900924f0504e7e27e12d
|
||||
#6 DONE 1.2s
|
||||
|
||||
#5 [internal] load metadata for docker.io/library/debian@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f
|
||||
#5 DONE 1.3s
|
||||
|
||||
#7 [internal] load .dockerignore
|
||||
#7 transferring context: 115B done
|
||||
#7 DONE 0.1s
|
||||
|
||||
#8 [internal] load build context
|
||||
#8 DONE 0.0s
|
||||
|
||||
#9 [stage-1 1/4] FROM docker.io/library/debian@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f
|
||||
#9 resolve docker.io/library/debian@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f
|
||||
#9 resolve docker.io/library/debian@sha256:a29215f6a35e51e22adffa17f89e9d2ef06214e64a2bad10d765c46aea49f11f 0.4s done
|
||||
#9 DONE 0.5s
|
||||
|
||||
#10 [build 1/4] FROM docker.io/library/golang:1.27.2-alpine@sha256:f92b6ef800e499660581efdabdf25d9d817a9d124eaf900924f0504e7e27e12d
|
||||
#10 resolve docker.io/library/golang:1.27.2-alpine@sha256:f92b6ef800e499660581efdabdf25d9d817a9d124eaf900924f0504e7e27e12d
|
||||
#10 resolve docker.io/library/golang:1.27.2-alpine@sha256:f92b6ef800e499660581efdabdf25d9d817a9d124eaf900924f0504e7e27e12d 0.4s done
|
||||
#10 DONE 0.5s
|
||||
|
||||
#8 [internal] load build context
|
||||
#8 transferring context: 55.42kB done
|
||||
#8 DONE 0.1s
|
||||
|
||||
#11 [build 2/4] WORKDIR /src
|
||||
#11 CACHED
|
||||
|
||||
#12 [build 3/4] COPY backend/ ./
|
||||
#12 DONE 0.7s
|
||||
|
||||
#13 [build 4/4] RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build go build -trimpath -ldflags='-s -w' -o /out/messenger ./cmd/app && go build -trimpath -ldflags='-s -w' -o /out/worker ./cmd/worker
|
||||
#13 DONE 18.8s
|
||||
|
||||
#14 [stage-1 2/4] RUN apt-get update && apt-get install -y --no-install-recommends imagemagick ca-certificates && apt-get clean
|
||||
#14 CACHED
|
||||
|
||||
#15 [stage-1 3/4] COPY --from=build /out/messenger /messenger
|
||||
#15 DONE 0.9s
|
||||
|
||||
#16 [stage-1 4/4] COPY --from=build /out/worker /worker
|
||||
#16 DONE 1.1s
|
||||
|
||||
#17 exporting to image
|
||||
#17 exporting layers
|
||||
#17 exporting layers 2.2s done
|
||||
#17 exporting manifest sha256:11b531203ff037cef9fa60e89ebbf8b98c597cabb043a2f39d3452a00097d29a
|
||||
#17 exporting manifest sha256:11b531203ff037cef9fa60e89ebbf8b98c597cabb043a2f39d3452a00097d29a 0.2s done
|
||||
#17 exporting config sha256:6eb1958a181c51ce939df15c467beedb96a9c2b9629b355460d7bbfa1bab3824
|
||||
#17 exporting config sha256:6eb1958a181c51ce939df15c467beedb96a9c2b9629b355460d7bbfa1bab3824 0.2s done
|
||||
#17 exporting attestation manifest sha256:82091c7efa4ace5668dfab0a8afe102c4292e83937d06c8c63c2ed0ab6cfb995
|
||||
#17 exporting attestation manifest sha256:82091c7efa4ace5668dfab0a8afe102c4292e83937d06c8c63c2ed0ab6cfb995 0.3s done
|
||||
#17 exporting manifest list sha256:22d0a63d522e7a322c7ea0a0319be7cb1f303089bc1ab1c26e1238da36f06050
|
||||
#17 exporting manifest list sha256:22d0a63d522e7a322c7ea0a0319be7cb1f303089bc1ab1c26e1238da36f06050 0.2s done
|
||||
#17 naming to docker.io/library/mtuci-vp5:local
|
||||
#17 naming to docker.io/library/mtuci-vp5:local 0.0s done
|
||||
#17 unpacking to docker.io/library/mtuci-vp5:local
|
||||
#17 unpacking to docker.io/library/mtuci-vp5:local 0.7s done
|
||||
#17 DONE 4.1s
|
||||
|
||||
#18 resolving provenance for metadata file
|
||||
#18 DONE 0.0s
|
||||
Image mtuci-vp5:local Built
|
||||
time="2026-11-15T20:29:02+03:00" level=warning msg="Found orphan containers (mtuci-vp5-medvedev-worker-run-db8c2cb4f0d4, mtuci-vp5-medvedev-api-run-5ed09d6abf58, mtuci-vp5-medvedev-worker-run-b5fa7057152c, mtuci-vp5-medvedev-api-run-7ccf113a8771, mtuci-vp5-medvedev-worker-run-d4f26bcfc148, mtuci-vp5-medvedev-worker-run-a2389dc840d1, mtuci-vp5-medvedev-worker-run-6c8f0bb601f5, mtuci-vp5-medvedev-worker-run-b9be14682b27) for this project. If you removed or renamed this service in your compose file, you can run this command with the --remove-orphans flag to clean it up."
|
||||
Container mtuci-vp5-medvedev-postgres-1 Running
|
||||
Container mtuci-vp5-medvedev-postgres-1 Waiting
|
||||
Container mtuci-vp5-medvedev-postgres-1 Healthy
|
||||
Container mtuci-vp5-medvedev-migrate-run-1e87f28d2b77 Creating
|
||||
Container mtuci-vp5-medvedev-migrate-run-1e87f28d2b77 Created
|
||||
2026/11/15 17:29:05 OK 00005_replay_audit.sql (534.27ms)
|
||||
2026/11/15 17:29:05 goose: successfully migrated database to version: 5
|
||||
time="2026-11-15T20:29:07+03:00" level=warning msg="Found orphan containers (mtuci-vp5-medvedev-worker-run-db8c2cb4f0d4, mtuci-vp5-medvedev-api-run-5ed09d6abf58, mtuci-vp5-medvedev-worker-run-b5fa7057152c, mtuci-vp5-medvedev-api-run-7ccf113a8771, mtuci-vp5-medvedev-worker-run-d4f26bcfc148, mtuci-vp5-medvedev-worker-run-a2389dc840d1, mtuci-vp5-medvedev-worker-run-6c8f0bb601f5, mtuci-vp5-medvedev-worker-run-b9be14682b27) for this project. If you removed or renamed this service in your compose file, you can run this command with the --remove-orphans flag to clean it up."
|
||||
Container mtuci-vp5-medvedev-postgres-1 Running
|
||||
Container mtuci-vp5-medvedev-valkey-1 Running
|
||||
Container mtuci-vp5-medvedev-s3-1 Running
|
||||
Container mtuci-vp5-medvedev-migrate-1 Recreate
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Recreate
|
||||
Container mtuci-vp5-medvedev-migrate-1 Recreated
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Recreated
|
||||
Container mtuci-vp5-medvedev-worker-1 Recreate
|
||||
Container mtuci-vp5-medvedev-api-2 Recreate
|
||||
Container mtuci-vp5-medvedev-api-1 Recreate
|
||||
Container mtuci-vp5-medvedev-worker-1 Recreated
|
||||
Container mtuci-vp5-medvedev-api-2 Recreated
|
||||
Container mtuci-vp5-medvedev-api-1 Recreated
|
||||
Container mtuci-vp5-medvedev-s3-1 Waiting
|
||||
Container mtuci-vp5-medvedev-postgres-1 Waiting
|
||||
Container mtuci-vp5-medvedev-postgres-1 Healthy
|
||||
Container mtuci-vp5-medvedev-migrate-1 Starting
|
||||
Container mtuci-vp5-medvedev-s3-1 Healthy
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Starting
|
||||
Container mtuci-vp5-medvedev-migrate-1 Started
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Started
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Waiting
|
||||
Container mtuci-vp5-medvedev-migrate-1 Waiting
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Waiting
|
||||
Container mtuci-vp5-medvedev-migrate-1 Waiting
|
||||
Container mtuci-vp5-medvedev-migrate-1 Exited
|
||||
Container mtuci-vp5-medvedev-migrate-1 Exited
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Exited
|
||||
Container mtuci-vp5-medvedev-api-1 Starting
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Exited
|
||||
Container mtuci-vp5-medvedev-worker-1 Starting
|
||||
Container mtuci-vp5-medvedev-api-1 Started
|
||||
Container mtuci-vp5-medvedev-api-2 Starting
|
||||
Container mtuci-vp5-medvedev-api-2 Started
|
||||
Container mtuci-vp5-medvedev-worker-1 Started
|
||||
@@ -0,0 +1,59 @@
|
||||
Running as unit: run-p1353899-i22195833.scope; invocation ID: b3b71e390dd94959b46dd7bbc7897868
|
||||
python3 scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
.venv/bin/python scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
? backend/cmd/app [no test files]
|
||||
? backend/cmd/worker [no test files]
|
||||
? backend/db [no test files]
|
||||
ok backend/integration (cached)
|
||||
ok backend/internal/adapter/handler (cached)
|
||||
ok backend/internal/adapter/imagefile (cached)
|
||||
? backend/internal/adapter/password [no test files]
|
||||
? backend/internal/adapter/queue [no test files]
|
||||
ok backend/internal/adapter/repository/postgres (cached)
|
||||
? backend/internal/adapter/repository/postgres/queries [no test files]
|
||||
ok backend/internal/adapter/storage (cached)
|
||||
ok backend/internal/application/usecase (cached)
|
||||
ok backend/internal/config (cached)
|
||||
ok backend/internal/domain/model (cached)
|
||||
? backend/internal/domain/port [no test files]
|
||||
? backend/internal/domain/repository [no test files]
|
||||
? backend/pkg/logger [no test files]
|
||||
? backend/pkg/server [no test files]
|
||||
0 issues.
|
||||
time="2026-11-15T20:42:06+03:00" level=warning msg="Found orphan containers (mtuci-vp5-medvedev-api-run-4077310676b4, mtuci-vp5-medvedev-worker-run-771b781db111, mtuci-vp5-medvedev-api-run-b290bf928939, mtuci-vp5-medvedev-worker-run-db8c2cb4f0d4, mtuci-vp5-medvedev-api-run-5ed09d6abf58, mtuci-vp5-medvedev-worker-run-b5fa7057152c, mtuci-vp5-medvedev-api-run-7ccf113a8771, mtuci-vp5-medvedev-worker-run-d4f26bcfc148, mtuci-vp5-medvedev-worker-run-a2389dc840d1, mtuci-vp5-medvedev-worker-run-6c8f0bb601f5, mtuci-vp5-medvedev-worker-run-b9be14682b27) for this project. If you removed or renamed this service in your compose file, you can run this command with the --remove-orphans flag to clean it up."
|
||||
Container mtuci-vp5-medvedev-worker-run-883dcfd1c83f Creating
|
||||
Container mtuci-vp5-medvedev-worker-run-883dcfd1c83f Created
|
||||
=== RUN TestOriginalBytesArePreserved
|
||||
--- PASS: TestOriginalBytesArePreserved (0.00s)
|
||||
=== RUN TestRejectsInvalidImageAndFilename
|
||||
=== RUN TestRejectsInvalidImageAndFilename/image/jpeg�
|
||||
=== RUN TestRejectsInvalidImageAndFilename/image/pngn
|
||||
=== RUN TestRejectsInvalidImageAndFilename/application/octet-stream�
|
||||
=== RUN TestRejectsInvalidImageAndFilename/image/png�
|
||||
--- PASS: TestRejectsInvalidImageAndFilename (0.00s)
|
||||
--- PASS: TestRejectsInvalidImageAndFilename/image/jpeg� (0.00s)
|
||||
--- PASS: TestRejectsInvalidImageAndFilename/image/pngn (0.00s)
|
||||
--- PASS: TestRejectsInvalidImageAndFilename/application/octet-stream� (0.00s)
|
||||
--- PASS: TestRejectsInvalidImageAndFilename/image/png� (0.00s)
|
||||
=== RUN TestRejectsOversizedStreamBeforeDecoding
|
||||
--- PASS: TestRejectsOversizedStreamBeforeDecoding (0.01s)
|
||||
=== RUN TestRejectsPixelBombBeforeDecoding
|
||||
--- PASS: TestRejectsPixelBombBeforeDecoding (0.00s)
|
||||
=== RUN TestWorstCaseImagesWithinBudget
|
||||
stress_test.go:78: explicit isolated memory experiment required
|
||||
--- SKIP: TestWorstCaseImagesWithinBudget (0.00s)
|
||||
=== RUN TestActualVariantsHonorDimensionsAlphaAndEXIF
|
||||
=== RUN TestActualVariantsHonorDimensionsAlphaAndEXIF/landscape
|
||||
=== RUN TestActualVariantsHonorDimensionsAlphaAndEXIF/tiny
|
||||
=== RUN TestActualVariantsHonorDimensionsAlphaAndEXIF/portrait
|
||||
=== RUN TestActualVariantsHonorDimensionsAlphaAndEXIF/exif
|
||||
--- PASS: TestActualVariantsHonorDimensionsAlphaAndEXIF (0.18s)
|
||||
--- PASS: TestActualVariantsHonorDimensionsAlphaAndEXIF/landscape (0.12s)
|
||||
--- PASS: TestActualVariantsHonorDimensionsAlphaAndEXIF/tiny (0.02s)
|
||||
--- PASS: TestActualVariantsHonorDimensionsAlphaAndEXIF/portrait (0.02s)
|
||||
--- PASS: TestActualVariantsHonorDimensionsAlphaAndEXIF/exif (0.02s)
|
||||
=== RUN TestFitDimensionsPreservesAspectAndDoesNotUpscale
|
||||
--- PASS: TestFitDimensionsPreservesAspectAndDoesNotUpscale (0.00s)
|
||||
PASS
|
||||
@@ -0,0 +1,37 @@
|
||||
Running as unit: run-p1232569-i22229982.scope; invocation ID: 161ac53c367c43708ce75fb300253e7d
|
||||
Ready: 2 API process(es)
|
||||
Container mtuci-vp5-medvedev-worker-1 Stopping
|
||||
Container mtuci-vp5-medvedev-worker-1 Stopped
|
||||
time="2026-11-15T20:29:47+03:00" level=warning msg="Found orphan containers (mtuci-vp5-medvedev-worker-run-db8c2cb4f0d4, mtuci-vp5-medvedev-api-run-5ed09d6abf58, mtuci-vp5-medvedev-worker-run-b5fa7057152c, mtuci-vp5-medvedev-api-run-7ccf113a8771, mtuci-vp5-medvedev-worker-run-d4f26bcfc148, mtuci-vp5-medvedev-worker-run-a2389dc840d1, mtuci-vp5-medvedev-worker-run-6c8f0bb601f5, mtuci-vp5-medvedev-worker-run-b9be14682b27) for this project. If you removed or renamed this service in your compose file, you can run this command with the --remove-orphans flag to clean it up."
|
||||
Container mtuci-vp5-medvedev-worker-run-9c6243811fa8 Creating
|
||||
Container mtuci-vp5-medvedev-worker-run-9c6243811fa8 Created
|
||||
=== RUN TestReplayAfterCompletedPreviousVersionCleanup
|
||||
--- PASS: TestReplayAfterCompletedPreviousVersionCleanup (0.26s)
|
||||
=== RUN TestVersionedPipelineDuplicateReorderRetryAndCleanup
|
||||
--- PASS: TestVersionedPipelineDuplicateReorderRetryAndCleanup (2.53s)
|
||||
PASS
|
||||
time="2026-11-15T20:29:52+03:00" level=warning msg="Found orphan containers (mtuci-vp5-medvedev-worker-run-db8c2cb4f0d4, mtuci-vp5-medvedev-api-run-5ed09d6abf58, mtuci-vp5-medvedev-worker-run-b5fa7057152c, mtuci-vp5-medvedev-api-run-7ccf113a8771, mtuci-vp5-medvedev-worker-run-d4f26bcfc148, mtuci-vp5-medvedev-worker-run-a2389dc840d1, mtuci-vp5-medvedev-worker-run-6c8f0bb601f5, mtuci-vp5-medvedev-worker-run-b9be14682b27) for this project. If you removed or renamed this service in your compose file, you can run this command with the --remove-orphans flag to clean it up."
|
||||
Container mtuci-vp5-medvedev-postgres-1 Running
|
||||
Container mtuci-vp5-medvedev-valkey-1 Running
|
||||
Container mtuci-vp5-medvedev-s3-1 Running
|
||||
Container mtuci-vp5-medvedev-s3-1 Waiting
|
||||
Container mtuci-vp5-medvedev-postgres-1 Waiting
|
||||
Container mtuci-vp5-medvedev-postgres-1 Healthy
|
||||
Container mtuci-vp5-medvedev-migrate-1 Starting
|
||||
Container mtuci-vp5-medvedev-s3-1 Healthy
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Starting
|
||||
Container mtuci-vp5-medvedev-migrate-1 Started
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Started
|
||||
Container mtuci-vp5-medvedev-migrate-1 Waiting
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Waiting
|
||||
Container mtuci-vp5-medvedev-migrate-1 Exited
|
||||
Container mtuci-vp5-medvedev-bootstrap-1 Exited
|
||||
Container mtuci-vp5-medvedev-worker-1 Starting
|
||||
Container mtuci-vp5-medvedev-worker-1 Started
|
||||
python3 scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
python3 tests/smoke.py --base-url "http://127.0.0.1:28205"
|
||||
PASS: lab5 public API scenario; infrastructure and grading evidence remain separate.
|
||||
python3 tests/resilience.py --mode persistence --action-script "./scripts/restart.sh" --base-url "http://127.0.0.1:28205"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1 @@
|
||||
{"phase":"created_and_selected","database":"messenger_stage_70b6ccce","old_database":"messenger","container":"3b0bdf554f6f648b0846697eac2b2f20512205d5fd373742dcce7a608696c5c9","old_database_preserved":true}
|
||||
@@ -0,0 +1,6 @@
|
||||
Running as unit: run-p1209455-i22190718.scope; invocation ID: 788efe50bc3c434f9f3d4ab94cbb2bb3
|
||||
internal/application/usecase/pipeline_retry_test.go:23:2: field cleanup is unused (unused)
|
||||
cleanup []model.Attachment
|
||||
^
|
||||
1 issues:
|
||||
* unused: 1
|
||||
@@ -0,0 +1,6 @@
|
||||
time="2026-11-15T20:01:08+03:00" level=warning msg="Found orphan containers (mtuci-vp5-medvedev-worker-run-b9be14682b27) for this project. If you removed or renamed this service in your compose file, you can run this command with the --remove-orphans flag to clean it up."
|
||||
Container mtuci-vp5-medvedev-worker-run-1db5a9894a25 Creating
|
||||
Container mtuci-vp5-medvedev-worker-run-1db5a9894a25 Created
|
||||
=== RUN TestReplayAfterCompletedPreviousVersionCleanup
|
||||
--- PASS: TestReplayAfterCompletedPreviousVersionCleanup (0.24s)
|
||||
PASS
|
||||
@@ -0,0 +1,2 @@
|
||||
.venv/bin/python scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
@@ -0,0 +1,10 @@
|
||||
Running as unit: run-p1084962-i22065896.scope; invocation ID: d1fe2b7306ca4399bdf630f35468acc2
|
||||
python3 tests/smoke.py --base-url "http://127.0.0.1:28205"
|
||||
PASS: lab5 public API scenario; infrastructure and grading evidence remain separate.
|
||||
python3 tests/resilience.py --mode persistence --action-script "./scripts/restart.sh" --base-url "http://127.0.0.1:28205"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
python3 tests/resilience.py --mode failover --action-script "./scripts/stop-one.sh" --base-url "http://127.0.0.1:28205"
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
|
||||
{"observed_instances_before": 2, "successful_writes": 126, "failed_attempts": 1, "first_recovery_seconds": 1.492}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1,6 @@
|
||||
=== RUN TestCompletedDeliveryRecoversStagingCleanupAfterCrash
|
||||
pipeline_retry_test.go:49: completed redelivery did not recover cleanup: removed=0 durable_cleaned=0 status=ready
|
||||
--- FAIL: TestCompletedDeliveryRecoversStagingCleanupAfterCrash (0.00s)
|
||||
FAIL
|
||||
FAIL backend/internal/application/usecase 0.008s
|
||||
FAIL
|
||||
@@ -0,0 +1,6 @@
|
||||
Command: go test ./internal/adapter/imagefile
|
||||
Before FitDimensions implementation, on omarchy:
|
||||
# backend/internal/adapter/imagefile [backend/internal/adapter/imagefile.test]
|
||||
internal/adapter/imagefile/variants_test.go:7:10: undefined: FitDimensions
|
||||
FAIL backend/internal/adapter/imagefile [build failed]
|
||||
FAIL
|
||||
@@ -0,0 +1,19 @@
|
||||
=== RUN TestReconcilerCannotPublishVersionedPipelineResult
|
||||
=== RUN TestReconcilerCannotPublishVersionedPipelineResult/uploading
|
||||
reconcile_pipeline_test.go:9: pipeline state was changed by legacy reconciler: status uploading -> ready, report {Metadata:1 Objects:1 Orphans:0 Missing:0 Recovered:1 Fresh:0 Deleted:0 Changed:1 NextMetadata: NextObject:}
|
||||
=== RUN TestReconcilerCannotPublishVersionedPipelineResult/queued
|
||||
reconcile_pipeline_test.go:9: pipeline state was changed by legacy reconciler: status queued -> ready, report {Metadata:1 Objects:1 Orphans:0 Missing:0 Recovered:1 Fresh:0 Deleted:0 Changed:1 NextMetadata: NextObject:}
|
||||
=== RUN TestReconcilerCannotPublishVersionedPipelineResult/processing
|
||||
reconcile_pipeline_test.go:9: pipeline state was changed by legacy reconciler: status processing -> ready, report {Metadata:1 Objects:1 Orphans:0 Missing:0 Recovered:1 Fresh:0 Deleted:0 Changed:1 NextMetadata: NextObject:}
|
||||
=== RUN TestReconcilerCannotPublishVersionedPipelineResult/failed
|
||||
reconcile_pipeline_test.go:9: pipeline state was changed by legacy reconciler: status failed -> ready, report {Metadata:1 Objects:1 Orphans:0 Missing:0 Recovered:1 Fresh:0 Deleted:0 Changed:1 NextMetadata: NextObject:}
|
||||
=== RUN TestReconcilerCannotPublishVersionedPipelineResult/ready
|
||||
--- FAIL: TestReconcilerCannotPublishVersionedPipelineResult (0.00s)
|
||||
--- FAIL: TestReconcilerCannotPublishVersionedPipelineResult/uploading (0.00s)
|
||||
--- FAIL: TestReconcilerCannotPublishVersionedPipelineResult/queued (0.00s)
|
||||
--- FAIL: TestReconcilerCannotPublishVersionedPipelineResult/processing (0.00s)
|
||||
--- FAIL: TestReconcilerCannotPublishVersionedPipelineResult/failed (0.00s)
|
||||
--- PASS: TestReconcilerCannotPublishVersionedPipelineResult/ready (0.00s)
|
||||
FAIL
|
||||
FAIL backend/internal/application/usecase 0.003s
|
||||
FAIL
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user