ЛР 5 — БВТ2301 — Чурилин — на 5 #42

Closed
d1frend wants to merge 1 commits from d1frend/mtusi2026lab5:solution/bvt2301-churilin into main
170 changed files with 21149 additions and 30 deletions
+13 -7
View File
@@ -1,25 +1,31 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Copy to .env for a LOCAL synthetic test environment; never commit .env.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_INTERNAL_PORT=8080
PUBLIC_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
CACHE_URL=redis://redis:6379/0
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
S3_ENDPOINT=http://minio:9000
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
S3_OPERATION_TIMEOUT=5s
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
BROKER_URL_FILE=/run/secrets/broker_url
WORKER_CONCURRENCY=2
JOB_MAX_ATTEMPTS=5
JOB_TIMEOUT_SECONDS=60
JOB_RETRY_BASE=250ms
JOB_RETRY_MAX=4s
JOB_LEASE_SECONDS=75
STAGING_RETENTION_SECONDS=86400
STAGING_CLEANUP_INTERVAL_SECONDS=30
API_GO_MEMORY_LIMIT=220MiB
WORKER_GO_MEMORY_LIMIT=448MiB
WORKER_MEMORY_LIMIT=512M
+41
View File
@@ -0,0 +1,41 @@
FROM golang:1.27.1-alpine@sha256:8a5910f31396cd4d89662f56c68b3ae31d374308270a1c3bd96672ee5ed43414 AS builder
WORKDIR /build
COPY go.mod go.sum ./
RUN go mod download
COPY cmd/ ./cmd/
COPY internal/ ./internal/
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-w -s" -o /build/server ./cmd/server/main.go
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-w -s" -o /build/reconciler ./cmd/reconciler/main.go
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-w -s" -o /build/worker ./cmd/worker/main.go
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-w -s" -o /build/dispatcher ./cmd/dispatcher/main.go
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-w -s" -o /build/jobctl ./cmd/jobctl/main.go
FROM alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6
RUN addgroup -g 1000 appgroup && \
adduser -u 1000 -G appgroup -s /bin/sh -D appuser
WORKDIR /app
COPY --from=builder /build/server /app/server
COPY --from=builder /build/reconciler /app/reconciler
COPY --from=builder /build/worker /app/worker
COPY --from=builder /build/dispatcher /app/dispatcher
COPY --from=builder /build/jobctl /app/jobctl
RUN chown -R appuser:appgroup /app
USER appuser:appgroup
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=10 \
CMD wget -qO- http://127.0.0.1:8080/health/ready || exit 1
ENTRYPOINT ["/app/server"]
+53 -1
View File
@@ -2,13 +2,17 @@ PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
RECONCILE_GRACE ?= 15m
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help init-secrets check validate test load test-attachment-boundaries test-attachment-memory test-storage-outage test-minio-policy test-async-resilience test-level4-resilience test-level5-idempotency jobs-failed replay-job upgrade-pipeline inject-job test-persistence test-failover test-reconcile test-reconcile-scale reconcile-dry-run reconcile-apply
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
init-secrets:
./scripts/init-secrets.sh
check:
$(PYTHON) scripts/check_contract.py
@@ -21,6 +25,42 @@ test:
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-attachment-memory:
BASE_URL="$(BASE_URL)" $(PYTHON) tests/attachment_memory.py
test-attachment-boundaries:
BASE_URL="$(BASE_URL)" $(PYTHON) tests/attachment_boundaries.py
test-storage-outage:
BASE_URL="$(BASE_URL)" $(PYTHON) tests/storage_outage.py
test-minio-policy:
./tests/minio_policy.sh
test-async-resilience:
$(PYTHON) tests/async_resilience.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-level4-resilience:
$(PYTHON) tests/level4_resilience.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-level5-idempotency:
$(PYTHON) tests/level5_idempotency.py --base-url "$(BASE_URL)" $(TLS_ARGS)
jobs-failed:
docker compose run --rm --no-deps --entrypoint /app/jobctl dispatcher list-failed
replay-job:
@test -n "$(JOB_ID)" || (echo "Set JOB_ID to a failed attachment job UUID"; exit 2)
docker compose run --rm --no-deps --entrypoint /app/jobctl dispatcher replay "$(JOB_ID)"
upgrade-pipeline:
@test -n "$(ATTACHMENT_ID)" || (echo "Set ATTACHMENT_ID"; exit 2)
@test -n "$(PIPELINE_VERSION)" || (echo "Set PIPELINE_VERSION=2"; exit 2)
docker compose run --rm --no-deps --entrypoint /app/jobctl worker upgrade "$(ATTACHMENT_ID)" "$(PIPELINE_VERSION)"
inject-job:
@test -n "$(JOB_ID)" || (echo "Set JOB_ID"; exit 2)
docker compose run --rm --no-deps --entrypoint /app/jobctl dispatcher inject "$(JOB_ID)"
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
@@ -28,3 +68,15 @@ test-persistence:
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-reconcile:
$(PYTHON) tests/reconcile_integration.py
test-reconcile-scale:
$(PYTHON) tests/reconcile_scale.py
reconcile-dry-run:
docker compose run --rm --entrypoint /app/reconciler api --grace-period "$(RECONCILE_GRACE)"
reconcile-apply:
docker compose run --rm --entrypoint /app/reconciler api --grace-period "$(RECONCILE_GRACE)" --apply
+239 -22
View File
@@ -1,37 +1,254 @@
# Отчёт — лабораторная 5
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Чурилин Данила, БВТ2301
- Текущий завершённый уровень: оценка «5»
- Выбранный трек 5: трек 2 — доказанная идемпотентность versioned pipeline
- Ветка: `solution/bvt2301-churilin`
- Commit/PR: пока не созданы по просьбе автора; весь уровень 5 и финальный аудит подготовлены к одному коммиту
- Использованные источники, библиотеки и помощь ИИ: Go standard library, `amqp091-go`, `disintegration/imaging`, [pure-Go go-webp v0.4.0](https://github.com/mayahiro/go-webp), PostgreSQL/pgx, MinIO SDK и RabbitMQ; OpenAI Codex использован для проектирования, реализации, fault injection, тестирования и отчёта
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Engine с Compose v2, GNU Make, Python 3.9+ и OpenSSL. Go локально не нужен: builder закреплён как `golang:1.27.1-alpine`.
## Архитектура и решения
```sh
cp .env.example .env
make init-secrets
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
docker compose --env-file .env up -d --wait
## Доказательства критериев
make check
make test BASE_URL=http://127.0.0.1:8080
make test-async-resilience BASE_URL=http://127.0.0.1:8080
make test-level4-resilience BASE_URL=http://127.0.0.1:8080
make test-level5-idempotency BASE_URL=http://127.0.0.1:8080
```
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
`make init-secrets` создаёт локальные файлы с mode 600 в игнорируемом `secrets/` и не перезаписывает существующие значения. Миграции выполняет одноразовый `migrate`; `minio-bootstrap` идемпотентно создаёт приватный bucket, ограниченную policy и отдельного S3-пользователя.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Операторские команды failed registry, replay и versioned pipeline:
## Эксперименты и отказы
```sh
make jobs-failed
make replay-job JOB_ID=<uuid-failed-job>
make upgrade-pipeline ATTACHMENT_ID=<uuid> PIPELINE_VERSION=2
make inject-job JOB_ID=<uuid>
```
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Replay разрешён только для `failed`, требует ещё сохранённый staging и записывает audit event. Попытка replay для `queued`, `processing` или `succeeded` завершается ошибкой без изменения job.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Безопасная остановка с сохранением данных:
## Ограничения и следующие шаги
```sh
docker compose --env-file .env down
```
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Намеренное удаление всех учебных данных:
```sh
docker compose --env-file .env down --volumes
```
## Архитектура и транзакционные границы
```text
client -> HAProxy -> API x2
|-- MinIO staging/{attachment_id}/original
'-- PostgreSQL attachment + attachment_job/outbox (COMMIT)
|
dispatcher
lease reaper <----+----> publisher confirm
|
durable RabbitMQ queue
|
manual ack -> worker (prefetch=2)
|-- MinIO original + v{1,2}/{thumbnail,crop,optimized}
'-- PostgreSQL variants + ready/succeeded (COMMIT)
|
delete/clear staging
```
Источники истины:
- PostgreSQL: состояния, metadata, job/outbox, `available_at`, lease, failed registry и audit events;
- MinIO: durable staging и конечные объекты;
- RabbitMQ: persistent at-least-once transport;
- Redis: восстанавливаемый cache, не источник истины.
### Граница ответа 202
1. API ограниченно читает максимум 10 MiB, проверяет MIME, полный decode и максимум 40 млн пикселей.
2. Проверенный оригинал устойчиво записывается в приватный MinIO staging.
3. `attachments(status=queued)` и `attachment_jobs(status=queued, attempt=1)` фиксируются одной транзакцией PostgreSQL.
4. Только после успешного commit возвращается `202 Accepted`. Resize в API не выполняется.
Job-row одновременно является outbox-записью. Dispatcher выбирает только `queued AND published_at IS NULL AND available_at <= now()`, публикует persistent-message в durable queue, ждёт publisher confirm и затем ставит publish-marker. Если процесс падает после DB commit до publish, строка остаётся видимой. Если он падает после confirm до marker, будет безопасный дубль.
Broker message содержит только schema/job/attachment/pipeline/attempt и время. Bytes, credentials, произвольный URL и клиентский filename в очередь не попадают.
### Media pipeline
Worker повторно проверяет размер, SHA-256 и pixel limit, применяет EXIF orientation и создаёт:
| Variant | Формат и параметры | Геометрия |
| --- | --- | --- |
| `thumbnail` | JPEG quality 85 (v1) / 90 (v2), alpha на белом | fit 256×256, floor, минимум 1 px, без upscale |
| `crop` | JPEG quality 85 (v1) / 90 (v2), alpha на белом | центрированный square 128×128, upscale разрешён |
| `optimized` | lossy WebP quality 80 (v1) / 85 (v2) | fit 1280×1280, floor, без upscale, alpha сохраняется |
Все варианты строятся из декодированных ориентированных пикселей. EXIF/ICC/XMP не передаются кодировщикам, поэтому metadata удаляется. WebP вызывается через cancellable `EncodeContext`. Новые upload используют v1; операторский upgrade повторно ставит готовый или остановленный после side effect original в v2 через отдельный durable staging.
Ограничения ресурсов worker:
- повторная проверка 10 MiB и 40 млн пикселей до полного worker-decode;
- `JOB_TIMEOUT_SECONDS=60`;
- `GOMEMLIMIT=448MiB` и hard Compose limit 512 MiB;
- concurrency/prefetch равны 2;
- lease 75 секунд, то есть длиннее timeout;
- S3/DB операции имеют отдельные bounded timeouts.
### Идемпотентность, retry и lease
Ключ эффекта — `(attachment_id, pipeline_version, variant)`; это PK таблицы вариантов. Object keys детерминированы и содержат версию. Все три variant metadata и переход `ready/succeeded` фиксируются одной DB-транзакцией. Повтор не создаёт новые строки и не откатывает ready.
Upgrade v1→v2 сначала создаёт новый durable staging из неизменного final original, затем одной PostgreSQL-транзакцией меняет активную `attachments.pipeline_version`, переводит прежнюю queued/processing job в `superseded` и создаёт v2 job/outbox. Completion, retry, permanent failure, replay и lease recovery сравнивают версию job с активной версией attachment. Устаревший результат может оставить объект только в своём `/v1/` prefix, но не публикует metadata и не очищает v2 staging.
Transient error:
- job `processing -> queued`;
- attempt увеличивается;
- `published_at` и lease сбрасываются;
- `available_at` получает exponential backoff;
- base 250 ms, cap 4 s, deterministic per-job jitter в диапазоне 0.5–1.5;
- после пятой попытки: job `failed/processing_failed`, attachment `failed/retry_exhausted`.
Permanent error (`invalid_image`, `staging_expired`, `unsupported_pipeline`) сразу переводит активную job в failed без расходования остальных попыток. Устаревшая версия получает `superseded` без изменения активного attachment. Все переходы регистрируются в `attachment_job_events`.
При claim worker ставит `lease_until` и `leased_by`. Dispatcher reaper возвращает просроченную processing-job в queued с новой попыткой и backoff. Старое broker-сообщение после смены attempt становится no-op. Сообщение для уже удалённой job также ack-ается как stale no-op, а не образует poison requeue loop.
### Staging cleanup
После commit результата worker удаляет staging и очищает `attachments.staging_key`. Фоновый cleaner запускается при старте и каждые 30 секунд:
- ready staging удаляется немедленно как избыточный;
- failed staging и DB-orphan удаляются только старше retention 24 часа;
- queued/processing staging не удаляется независимо от возраста;
- replay после retention безопасно отклоняется.
## Fault injection и доказательства уровня 4
`tests/level4_resilience.py` выполняет реальные управляемые сбои:
1. создаёт и скачивает три настоящих варианта, проверяет MIME, dimensions, size и SHA-256;
2. создаёт marker в dispatcher, после DB commit процесс делает `os.Exit(87)` до publish; restart восстанавливает ту же outbox-job;
3. создаёт marker в worker, процесс делает `os.Exit(86)` после всех S3 writes, но до result commit/ack; lease принудительно истекает, reaper выполняет redelivery;
4. подменяет trusted SHA-256 и доказывает permanent `invalid_image` на attempt 1;
5. делает staging временно недоступным, получает четыре retry + финальный attempt 5;
6. находит job через `jobctl list-failed`, восстанавливает staging и делает явный replay;
7. повторный replay уже succeeded-job отклоняется;
8. проверяет ровно три variant rows и `staging_key IS NULL`.
Фактический итог:
```text
PASS: level-4 variants, outbox crash recovery, lease recovery, backoff/failed registry and safe replay verified.
```
## Исследование уровня 5 — трек 2
### Гипотеза
Versioned keys и проверка активной версии во всех DB-переходах обеспечивают идемпотентный итог при at-least-once доставке: подтверждённая работа не теряется при crash до/после side effect, а дубликат, reorder и старая job после v2 не меняют новый результат.
### Методика
`tests/level5_idempotency.py` автоматически выполняет четыре группы воздействий:
1. crash до первого object write (`os.Exit(85)`), проверка отсутствия final original, принудительное истечение lease и восстановление v1;
2. crash после object writes до result COMMIT/ACK (`os.Exit(86)`), upgrade processing v1→v2 и проверка `v1=superseded`;
3. завершение v1, upgrade v2 и сравнение трёх SHA-256 каждой версии;
4. два дубля v2 и затем reorder устаревшего v1-сообщения после v2.
До воздействия фиксируются active version, job states, variant hashes и original SHA-256. После воздействия проверяются `ready:2`, неизменность v2/original, шесть исторических variant rows для завершённых v1+v2, отсутствие лишних строк и пустая очередь.
### Результат
~~~text
PASS: pipeline v1/v2 history, crash before/after side effect,
superseded in-flight work, duplicate and reordered stale deliveries verified.
~~~
Гипотеза подтверждена в заявленной модели отказов. Подробные команды, sample UUID/хеши, инварианты и ограничения сохранены в `evidence/lab5-grade5.md`.
Это не exactly-once: RabbitMQ физически может доставить сообщение повторно, publisher может повторить publish после неясного confirm, а worker — повторить S3 write после смерти до ACK. Доказан идемпотентный effectively-once результат: только активная версия может атомарно опубликовать metadata, а versioned keys изолируют side effects.
## Таблица проверок
Все результаты ниже повторно получены 2026-11-08 на локальном WSL2/Docker Compose стенде после чистой пересборки образов и финального аудита.
| Критерий | Команда/сценарий | Наблюдаемый результат |
| --- | --- | --- |
| Contract/OpenAPI | `make check`, `make validate` | PASS |
| Public API | `make test` | PASS |
| Уровень 3 | `make test-async-resilience` | durability, duplicate, bounded failed — PASS |
| Уровень 5, трек 2 | `make test-level5-idempotency` | v1/v2, crash before/after side effect, duplicate, reorder, stale-after-new — PASS |
| Три level-4 variants | `make test-level4-resilience` | thumbnail 256×160, crop 128×128, optimized WebP 320×200 — PASS |
| COMMIT → publish crash | dispatcher fault marker | один job, restart, publish и ready — PASS |
| S3 writes → commit/ack crash | worker fault marker + lease expiry | lease_recovered, ready, ровно 3 variants — PASS |
| Permanent/transient | SHA mismatch / missing staging | attempt 1 invalid_image / attempt 5 retry_exhausted — PASS |
| Failed registry/replay | `jobctl list-failed/replay` | replay_count=1; replay succeeded-job отклонён |
| Staging cleanup | integration + `cleaner_test.go` | ready удалён; active/recent сохранены — PASS |
| EXIF/alpha/no-upscale | `processor_test.go` | orientation, white JPEG background, WebP alpha, metadata stripping — PASS |
| Unit/static | `go test -count=1 ./...`, `go test -race -count=1 ./...`, `go vet ./...`, `go build ./...` | PASS |
| Go hygiene | `gofmt`, `go mod verify`, `go mod tidy -diff`, `git diff --check` | PASS, изменений/ошибок нет |
| Frontend | чистый `docker compose build --no-cache frontend` | 1/1 Vitest, TypeScript и Vite production build — PASS; 0 npm vulnerabilities |
| Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS |
| API failover | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 142 writes, 0 failures, recovery 2.757 s |
| Boundaries | `make test-attachment-boundaries` | 10 MiB/40M px accepted; excess/corruption rejected — PASS |
| API memory | `make test-attachment-memory` | 12/12, 2 replicas; peaks 28,531,752 / 32,516,341 bytes |
| MinIO policy | `make test-minio-policy` | least privilege и anonymous GET denied — PASS |
| MinIO outage | `make test-storage-outage` | readiness 503 2.003 s; upload 503 5.007 s; original preserved |
| Reconciler | `make test-reconcile` | 4 fixture-проблемы; apply удалил 2 объекта и пометил 1 attachment; повтор 0 mutations; reference protected — PASS |
| Reconciler scale | `make test-reconcile-scale` | 100/1000 orphan objects; traversal 33/46 ms — PASS |
| Fresh migrations | одноразовый чистый PostgreSQL + migrations `up` | версии 1→6 применены; `version=6`, `dirty=false` — PASS |
| Изолированный чистый стенд | новый Compose project/volumes, порт 18080 | smoke + уровни 3/4/5 + reconciler — PASS; после аудита временные volumes удалены |
| Secrets | Git ignore + exact-value scan локальных password/URL/key | `.env`, `secrets/`, `.venv` не входят в Git; совпадений чувствительных значений нет |
| Stale messages | memory cleanup + queue inspection | `messages_ready=0`, `messages_unacknowledged=0` |
| Compose | `docker compose --env-file .env config --quiet` | exit 0 |
Подробные raw summaries сохранены в `evidence/lab5-grade4.md` и `evidence/lab5-grade5.md`.
### Повторный предсдаточный аудит 2026-11-08
Аудит обнаружил и устранил две связанные регрессии совместимости lab4→lab5 в служебном reconciler:
1. старая fixture использовала больше не допустимый статус `pending`, а reconciler через source-compatible alias мог считать давно стоящий `queued` устаревшим и ошибочно переводить его в `failed`;
2. inventory ownership учитывал только `attachments.object_key`, поэтому versioned variants и staging могли выглядеть как orphan objects.
Текущая реализация не изменяет `queued/processing` по одному возрасту, а как принадлежащие attachment учитывает final original, ненулевой `staging_key` и все ключи из `attachment_variants`. Unit-тест отдельно фиксирует сохранность старых активных attachment/staging, integration-тест проверяет dry-run/apply/repeat на реальных PostgreSQL и MinIO, а scale-тест повторяет обход на 100 и 1000 объектах.
Финальное состояние отдельного чистого Compose-проекта после всех намеренных crash/restart сценариев и до удаления его временных volumes:
- обе API-реплики, PostgreSQL, Redis, MinIO, RabbitMQ, frontend и load balancer healthy; migration/bootstrap завершились с exit 0;
- schema migration `6`, `dirty=false`;
- jobs: `failed=2`, `succeeded=10`, `superseded=1`, активных `queued/processing=0`;
- variant metadata: `v1=24`, `v2=6`;
- RabbitMQ `messages_ready=0`, `messages_unacknowledged=0`;
- у девяти `ready` attachment нет staging; два failed staging сохранены намеренно до retention/replay;
- `/health/ready` возвращает `200 {"status":"ok"}`, frontend `/` возвращает 200.
На основном стенде после такого же прогона fault-marker files отсутствуют, а за минуту после стабилизации новых `panic/fatal/error/warn` в логах не появилось. Временный чистый Compose-проект `mtusi2026lab5audit1108` и только его изолированные volumes после снятия результатов удалены.
## Ограничения
Уровень 4 и выбранный трек 5 полностью реализованы.
- Поддержаны pipeline v1 и v2; произвольный registry версий и профилей не реализован.
- Upgrade является операторской командой, а не публичным пользовательским API.
- Старые versioned variant-объекты сохраняются для аудита; lifecycle архивных версий не реализован.
- Lease фиксированный и длиннее timeout; heartbeat-продление для динамических SLA отсутствует.
- Failed registry находится в PostgreSQL, а не отдельной broker DLQ, чтобы сохранить атомарную связь с attachment и audit.
- At-least-once плюс идемпотентный эффект не является exactly-once delivery.
- Эксперимент выполнен на одном Docker-host и не покрывает потерю host или volumes PostgreSQL/MinIO.
+131
View File
@@ -0,0 +1,131 @@
package main
import (
"context"
"errors"
"log"
"os"
"os/signal"
"syscall"
"time"
"mtusi2026lab5/internal/adapter/broker"
"mtusi2026lab5/internal/adapter/postgres"
"mtusi2026lab5/internal/config"
"mtusi2026lab5/internal/database"
"mtusi2026lab5/internal/domain"
"mtusi2026lab5/internal/worker"
)
const defaultBeforePublishFaultFile = "/tmp/mtusi-fault-before-publish"
func main() {
cfg, err := config.LoadDispatcher()
if err != nil {
log.Fatalf("[FATAL] Invalid configuration: %v", err)
}
if cfg.BrokerURL == "" {
log.Fatal("[FATAL] BROKER_URL or BROKER_URL_FILE is required")
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
pool, err := database.Open(ctx, cfg)
if err != nil {
log.Fatalf("[FATAL] PostgreSQL initialization failed: %v", err)
}
defer pool.Close()
store := postgres.NewPostgreSQLStore(pool, cfg.DatabaseQueryTimeout)
client, err := broker.Open(cfg.BrokerURL, 0)
if err != nil {
log.Fatalf("[FATAL] RabbitMQ initialization failed: %v", err)
}
defer client.Close()
faultFile := os.Getenv("DISPATCHER_FAULT_BEFORE_PUBLISH_FILE")
if faultFile == "" {
faultFile = defaultBeforePublishFaultFile
}
ticker := time.NewTicker(250 * time.Millisecond)
defer ticker.Stop()
log.Println("[INFO] Attachment job dispatcher and lease reaper started")
for {
now := time.Now().UTC()
expired, queryErr := store.ListExpiredAttachmentJobs(ctx, now, 50)
if queryErr != nil {
if ctx.Err() != nil {
return
}
log.Printf("[WARN] List expired jobs failed: %v", queryErr)
} else {
for _, job := range expired {
delay := worker.RetryDelay(
job.JobID,
job.Attempt+1,
cfg.JobRetryBase,
cfg.JobRetryMax,
)
recovered, final, recoverErr := store.RetryAttachmentJob(
ctx,
job.JobID,
"lease_expired",
now.Add(delay),
now,
"lease_recovered",
)
if recoverErr != nil {
log.Printf("[WARN] Recover expired job %s failed: %v", job.JobID, recoverErr)
continue
}
if final && recovered.Status == domain.AttachmentJobFailed {
log.Printf("[WARN] Expired job %s exhausted retries", job.JobID)
} else if !final {
log.Printf("[INFO] Recovered expired job %s as attempt %d", job.JobID, recovered.Attempt)
}
}
}
jobs, queryErr := store.ListUnpublishedAttachmentJobs(ctx, 50)
if queryErr != nil {
if ctx.Err() != nil {
return
}
log.Printf("[WARN] List unpublished jobs failed: %v", queryErr)
} else {
for _, job := range jobs {
removeErr := os.Remove(faultFile)
if removeErr == nil {
log.Printf("[FAULT] exiting after DB commit and before publish for job %s", job.JobID)
os.Exit(87)
}
if removeErr != nil && !errors.Is(removeErr, os.ErrNotExist) {
log.Printf("[WARN] Consume before-publish fault marker: %v", removeErr)
}
publishContext, cancel := context.WithTimeout(ctx, 10*time.Second)
publishErr := client.Publish(publishContext, job)
cancel()
if publishErr != nil {
log.Fatalf("[FATAL] Publish job %s failed: %v", job.JobID, publishErr)
}
if err = store.MarkAttachmentJobPublished(
ctx,
job.JobID,
job.Attempt,
time.Now().UTC(),
); err != nil {
// Publisher confirm proves broker acceptance. Leaving the
// marker unset intentionally causes a safe duplicate.
log.Printf("[WARN] Job %s was confirmed but publish marker failed: %v", job.JobID, err)
}
}
}
select {
case <-ctx.Done():
return
case <-ticker.C:
}
}
}
+259
View File
@@ -0,0 +1,259 @@
package main
import (
"context"
"encoding/json"
"errors"
"fmt"
"log"
"os"
"strconv"
"time"
"mtusi2026lab5/internal/adapter/broker"
"mtusi2026lab5/internal/adapter/objectstore"
"mtusi2026lab5/internal/adapter/postgres"
"mtusi2026lab5/internal/application"
"mtusi2026lab5/internal/config"
"mtusi2026lab5/internal/database"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
)
type jobView struct {
JobID string `json:"job_id"`
AttachmentID string `json:"attachment_id"`
PipelineVersion int `json:"pipeline_version"`
Status domain.AttachmentJobStatus `json:"status"`
Attempt int `json:"attempt"`
MaxAttempts int `json:"max_attempts"`
ErrorCode *string `json:"error_code"`
ReplayCount int `json:"replay_count"`
UpdatedAt time.Time `json:"updated_at"`
}
func main() {
if len(os.Args) < 2 {
usage()
}
switch os.Args[1] {
case "list-failed":
runListFailed()
case "replay":
runReplay()
case "inject":
runInject()
case "upgrade":
runUpgrade()
default:
usage()
}
}
func openStore(ctx context.Context, cfg config.Config) (*postgres.PostgreSQLStore, func()) {
pool, err := database.Open(ctx, cfg)
if err != nil {
log.Fatalf("PostgreSQL initialization failed: %v", err)
}
return postgres.NewPostgreSQLStore(pool, cfg.DatabaseQueryTimeout), pool.Close
}
func runListFailed() {
limit := 100
if len(os.Args) == 3 {
parsed, err := strconv.Atoi(os.Args[2])
if err != nil || parsed < 1 || parsed > 1000 {
log.Fatal("limit must be an integer between 1 and 1000")
}
limit = parsed
} else if len(os.Args) != 2 {
usage()
}
cfg, err := config.LoadDispatcher()
if err != nil {
log.Fatalf("invalid configuration: %v", err)
}
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
store, closeStore := openStore(ctx, cfg)
defer closeStore()
jobs, err := store.ListFailedAttachmentJobs(ctx, limit)
if err != nil {
log.Fatalf("list failed jobs: %v", err)
}
views := make([]jobView, 0, len(jobs))
for _, job := range jobs {
views = append(views, view(job))
}
writeJSON(views)
}
func runReplay() {
if len(os.Args) != 3 {
usage()
}
jobID := requireUUID(os.Args[2], "job_id")
cfg, err := config.LoadDispatcher()
if err != nil {
log.Fatalf("invalid configuration: %v", err)
}
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
store, closeStore := openStore(ctx, cfg)
defer closeStore()
job, err := store.ReplayFailedAttachmentJob(ctx, jobID, time.Now().UTC())
if errors.Is(err, postgres.ErrConflict) {
log.Fatal("replay rejected: job is not the active failed pipeline or retained staging is unavailable")
}
if errors.Is(err, postgres.ErrNotFound) {
log.Fatal("replay rejected: job not found")
}
if err != nil {
log.Fatalf("replay failed: %v", err)
}
writeJSON(view(job))
}
func runInject() {
if len(os.Args) != 3 {
usage()
}
jobID := requireUUID(os.Args[2], "job_id")
cfg, err := config.LoadDispatcher()
if err != nil {
log.Fatalf("invalid configuration: %v", err)
}
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
store, closeStore := openStore(ctx, cfg)
defer closeStore()
job, err := store.GetAttachmentJob(ctx, jobID)
if errors.Is(err, postgres.ErrNotFound) {
log.Fatal("inject rejected: job not found")
}
if err != nil {
log.Fatalf("read job for injection: %v", err)
}
client, err := broker.Open(cfg.BrokerURL, 1)
if err != nil {
log.Fatalf("RabbitMQ initialization failed: %v", err)
}
defer client.Close()
if err = client.Publish(ctx, job); err != nil {
log.Fatalf("inject broker message: %v", err)
}
writeJSON(view(job))
}
func runUpgrade() {
if len(os.Args) != 4 {
usage()
}
attachmentID := requireUUID(os.Args[2], "attachment_id")
targetVersion, err := strconv.Atoi(os.Args[3])
if err != nil || targetVersion != 2 {
log.Fatal("target pipeline version must be 2")
}
cfg, err := config.LoadWorker()
if err != nil {
log.Fatalf("invalid configuration: %v", err)
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
store, closeStore := openStore(ctx, cfg)
defer closeStore()
attachment, err := store.GetAttachmentForProcessing(ctx, attachmentID)
if errors.Is(err, postgres.ErrNotFound) {
log.Fatal("upgrade rejected: attachment not found")
}
if err != nil {
log.Fatalf("read attachment for upgrade: %v", err)
}
if attachment.PipelineVersion+1 != targetVersion {
log.Fatalf("upgrade rejected: current pipeline is v%d", attachment.PipelineVersion)
}
objects, err := objectstore.NewMinIOStore(
cfg.S3Endpoint,
cfg.S3Region,
cfg.S3Bucket,
cfg.S3AccessKeyID,
cfg.S3SecretAccessKey,
cfg.S3OperationTimeout,
)
if err != nil {
log.Fatalf("object storage initialization failed: %v", err)
}
source, err := objects.Get(ctx, attachment.ObjectKey)
if err != nil {
log.Fatalf("upgrade source original is unavailable: %v", err)
}
defer source.Body.Close()
stagingKey := fmt.Sprintf("staging/%s/v%d/original", attachment.ID, targetVersion)
if err = objects.Put(ctx, application.ObjectPut{
Key: stagingKey,
ContentType: attachment.ContentType,
SizeBytes: attachment.SizeBytes,
Body: source.Body,
}); err != nil {
log.Fatalf("create durable upgrade staging: %v", err)
}
now := time.Now().UTC()
job := domain.AttachmentJob{
SchemaVersion: 1,
JobID: uuid.NewString(),
Type: domain.AttachmentJobType,
AttachmentID: attachment.ID,
PipelineVersion: targetVersion,
Attempt: 1,
MaxAttempts: cfg.JobMaxAttempts,
Status: domain.AttachmentJobQueued,
AvailableAt: now,
CreatedAt: now,
UpdatedAt: now,
}
job, err = store.UpgradeAttachmentPipeline(ctx, attachment.ID, targetVersion, stagingKey, job, now)
if errors.Is(err, postgres.ErrConflict) {
log.Fatal("upgrade rejected: attachment is not in an upgradeable state or target is not the next version")
}
if err != nil {
// Keep the copied source: a COMMIT error is ambiguous and cleanup can
// safely remove an actual orphan after the retention period.
log.Fatalf("upgrade pipeline: %v", err)
}
writeJSON(view(job))
}
func requireUUID(value, name string) string {
if _, err := uuid.Parse(value); err != nil {
log.Fatalf("%s must be a UUID", name)
}
return value
}
func view(job domain.AttachmentJob) jobView {
return jobView{
JobID: job.JobID,
AttachmentID: job.AttachmentID,
PipelineVersion: job.PipelineVersion,
Status: job.Status,
Attempt: job.Attempt,
MaxAttempts: job.MaxAttempts,
ErrorCode: job.ErrorCode,
ReplayCount: job.ReplayCount,
UpdatedAt: job.UpdatedAt,
}
}
func writeJSON(value any) {
encoder := json.NewEncoder(os.Stdout)
encoder.SetEscapeHTML(true)
if err := encoder.Encode(value); err != nil {
log.Fatalf("encode output: %v", err)
}
}
func usage() {
fmt.Fprintln(os.Stderr, "usage: jobctl list-failed [limit] | replay <job_id> | inject <job_id> | upgrade <attachment_id> 2")
os.Exit(2)
}
+75
View File
@@ -0,0 +1,75 @@
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"os"
"time"
"mtusi2026lab5/internal/adapter/objectstore"
"mtusi2026lab5/internal/adapter/postgres"
"mtusi2026lab5/internal/config"
"mtusi2026lab5/internal/database"
"mtusi2026lab5/internal/reconcile"
)
func main() {
apply := flag.Bool("apply", false, "apply safe repairs; default is dry-run")
gracePeriod := flag.Duration("grace-period", 15*time.Minute,
"ignore metadata and objects newer than this duration")
timeout := flag.Duration("timeout", 2*time.Minute, "maximum reconciliation runtime")
flag.Parse()
if *gracePeriod <= 0 || *timeout <= 0 {
log.Fatal("[FATAL] grace-period and timeout must be positive")
}
cfg, err := config.Load()
if err != nil {
log.Fatalf("[FATAL] Invalid configuration: %v", err)
}
ctx, cancel := context.WithTimeout(context.Background(), *timeout)
defer cancel()
databasePool, err := database.Open(ctx, cfg)
if err != nil {
log.Fatalf("[FATAL] PostgreSQL initialization failed: %v", err)
}
defer databasePool.Close()
metadataStore := postgres.NewPostgreSQLStore(databasePool, cfg.DatabaseQueryTimeout)
objectStore, err := objectstore.NewMinIOStore(
cfg.S3Endpoint,
cfg.S3Region,
cfg.S3Bucket,
cfg.S3AccessKeyID,
cfg.S3SecretAccessKey,
cfg.S3OperationTimeout,
)
if err != nil {
log.Fatalf("[FATAL] Invalid object storage configuration: %v", err)
}
if err = objectStore.Ping(ctx); err != nil {
log.Fatalf("[FATAL] Object storage unavailable: %v", err)
}
reconciler, err := reconcile.New(metadataStore, objectStore)
if err != nil {
log.Fatalf("[FATAL] Reconciler initialization failed: %v", err)
}
result, err := reconciler.Run(ctx, *gracePeriod, *apply)
if err != nil {
log.Fatalf("[FATAL] Reconciliation failed: %v", err)
}
encoder := json.NewEncoder(os.Stdout)
encoder.SetIndent("", " ")
if err = encoder.Encode(result); err != nil {
log.Fatalf("[FATAL] Encode reconciliation result: %v", err)
}
if !*apply && len(result.Issues) > 0 {
fmt.Fprintln(os.Stderr, "dry-run found reconciliation issues; rerun with --apply after review")
}
}
+260
View File
@@ -0,0 +1,260 @@
package main
import (
"context"
"errors"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
cacheadapter "mtusi2026lab5/internal/adapter/cache"
"mtusi2026lab5/internal/adapter/health"
"mtusi2026lab5/internal/adapter/objectstore"
"mtusi2026lab5/internal/adapter/postgres"
redisadapter "mtusi2026lab5/internal/adapter/redis"
"mtusi2026lab5/internal/application"
"mtusi2026lab5/internal/config"
"mtusi2026lab5/internal/database"
"mtusi2026lab5/internal/transport/http/handlers"
"mtusi2026lab5/internal/transport/http/middleware"
)
func main() {
cfg, err := config.Load()
if err != nil {
log.Fatalf("[FATAL] Invalid configuration: %v", err)
}
startupContext, startupCancel := context.WithTimeout(
context.Background(),
cfg.DatabaseConnectTimeout,
)
databasePool, err := database.Open(startupContext, cfg)
startupCancel()
if err != nil {
log.Fatalf("[FATAL] PostgreSQL initialization failed: %v", err)
}
defer databasePool.Close()
postgresStore := postgres.NewPostgreSQLStore(
databasePool,
cfg.DatabaseQueryTimeout,
)
minioStore, err := objectstore.NewMinIOStore(
cfg.S3Endpoint,
cfg.S3Region,
cfg.S3Bucket,
cfg.S3AccessKeyID,
cfg.S3SecretAccessKey,
cfg.S3OperationTimeout,
)
if err != nil {
log.Fatalf("[FATAL] Invalid object storage configuration: %v", err)
}
storageContext, storageCancel := context.WithTimeout(
context.Background(),
cfg.S3OperationTimeout,
)
if err = minioStore.Ping(storageContext); err != nil {
log.Printf("[WARN] Object storage unavailable at startup: %v", err)
}
storageCancel()
var applicationStore application.Repository = postgresStore
if cfg.RedisURL != "" {
redisChatCache, cacheError := redisadapter.NewRedisChatCache(
cfg.RedisURL,
cfg.RedisCacheTTL,
cfg.RedisOperationTimeout,
cfg.RedisPoolSize,
)
if cacheError != nil {
log.Fatalf("[FATAL] Invalid Redis configuration: %v", cacheError)
}
defer func() {
if closeError := redisChatCache.Close(); closeError != nil {
log.Printf("[WARN] Redis client close failed: %v", closeError)
}
}()
cacheContext, cacheCancel := context.WithTimeout(
context.Background(),
cfg.RedisOperationTimeout,
)
if cacheError = redisChatCache.Ping(cacheContext); cacheError != nil {
log.Printf("[WARN] Redis unavailable at startup; PostgreSQL fallback is active: %v", cacheError)
} else {
log.Println("[INFO] Redis chat cache is available")
}
cacheCancel()
applicationStore = cacheadapter.NewCachedRepository(
postgresStore,
redisChatCache,
log.Default(),
)
}
cursorCodec, err := application.NewCursorCodec(cfg.CursorSigningKey)
if err != nil {
log.Fatalf("[FATAL] Invalid cursor configuration: %v", err)
}
service, err := application.NewService(
applicationStore,
cursorCodec,
cfg.SessionTTL,
application.WithIdempotencyTTL(cfg.IdempotencyTTL),
application.WithObjectStore(minioStore),
application.WithJobMaxAttempts(cfg.JobMaxAttempts),
)
if err != nil {
log.Fatalf("[FATAL] Application initialization failed: %v", err)
}
handler := handlers.NewHandler(
service,
handlers.WithReadiness(
health.NewMultiChecker(databasePool, minioStore),
cfg.ReadinessTimeout,
),
handlers.WithSessionCookieSecure(cfg.SessionCookieSecure),
)
mux := http.NewServeMux()
mux.HandleFunc("GET /health/live", handler.HealthLive)
mux.HandleFunc("GET /health/lb", handler.HealthLive)
mux.HandleFunc("GET /health/ready", handler.HealthReady)
mux.HandleFunc(
"POST /api/v1/auth/sessions",
handler.CreateSession,
)
mux.HandleFunc("POST /api/v1/users", handler.CreateUser)
requireAuth := func(next http.HandlerFunc) http.HandlerFunc {
return middleware.RequireAuth(service, next)
}
mux.HandleFunc(
"GET /api/v1/users/me",
requireAuth(handler.GetMe),
)
mux.HandleFunc(
"DELETE /api/v1/auth/sessions/current",
requireAuth(handler.DeleteCurrentSession),
)
mux.HandleFunc(
"POST /api/v1/chats",
requireAuth(handler.CreateChat),
)
mux.HandleFunc(
"GET /api/v1/chats",
requireAuth(handler.ListChats),
)
mux.HandleFunc(
"GET /api/v1/chats/{chat_id}",
requireAuth(handler.GetChat),
)
mux.HandleFunc(
"POST /api/v1/chats/{chat_id}/messages",
requireAuth(handler.CreateMessage),
)
mux.HandleFunc(
"GET /api/v1/chats/{chat_id}/messages",
requireAuth(handler.GetMessages),
)
mux.HandleFunc(
"POST /api/v1/chats/{chat_id}/attachments",
requireAuth(handler.UploadAttachment),
)
mux.HandleFunc(
"GET /api/v1/attachments/{attachment_id}",
requireAuth(handler.GetAttachment),
)
mux.HandleFunc(
"GET /api/v1/attachments/{attachment_id}/content",
requireAuth(handler.DownloadAttachment),
)
var rootHandler http.Handler = mux
rootHandler = middleware.Recovery(rootHandler)
rootHandler = middleware.Logger(rootHandler)
availabilityGate := middleware.NewAvailabilityGate()
rootHandler = availabilityGate.Middleware(rootHandler)
rootHandler = middleware.RequestID(rootHandler)
rootHandler = middleware.InstanceID(cfg.InstanceID, rootHandler)
server := &http.Server{
Addr: cfg.HTTPAddress(),
Handler: rootHandler,
ReadTimeout: 15 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
}
serverErrors := make(chan error, 1)
go func() {
log.Printf(
"[INFO] Server instance %s starting on %s",
cfg.InstanceID,
server.Addr,
)
serverErrors <- server.ListenAndServe()
}()
shutdownSignals := make(chan os.Signal, 1)
signal.Notify(
shutdownSignals,
os.Interrupt,
syscall.SIGTERM,
)
defer signal.Stop(shutdownSignals)
select {
case serverError := <-serverErrors:
if !errors.Is(serverError, http.ErrServerClosed) {
log.Fatalf("[FATAL] Server crashed: %v", serverError)
}
case signalValue := <-shutdownSignals:
log.Printf(
"[INFO] Signal %v received. Starting graceful shutdown...",
signalValue,
)
availabilityGate.BeginDrain()
log.Printf(
"[INFO] Readiness disabled; draining new traffic for %s",
cfg.ShutdownDrainDelay,
)
time.Sleep(cfg.ShutdownDrainDelay)
shutdownContext, shutdownCancel := context.WithTimeout(
context.Background(),
cfg.ShutdownTimeout,
)
defer shutdownCancel()
if err := server.Shutdown(shutdownContext); err != nil {
log.Printf(
"[WARN] Graceful shutdown failed: %v. Forcing close.",
err,
)
_ = server.Close()
}
log.Println("[INFO] Server stopped gracefully.")
}
}
+240
View File
@@ -0,0 +1,240 @@
package main
import (
"context"
"errors"
"fmt"
"log"
"os"
"os/signal"
"sync"
"syscall"
"time"
"mtusi2026lab5/internal/adapter/broker"
"mtusi2026lab5/internal/adapter/objectstore"
"mtusi2026lab5/internal/adapter/postgres"
"mtusi2026lab5/internal/config"
"mtusi2026lab5/internal/database"
"mtusi2026lab5/internal/domain"
"mtusi2026lab5/internal/worker"
)
const (
defaultBeforeObjectsFaultFile = "/tmp/mtusi-fault-before-objects"
defaultAfterObjectsFaultFile = "/tmp/mtusi-fault-after-objects"
)
func main() {
cfg, err := config.LoadWorker()
if err != nil {
log.Fatalf("[FATAL] Invalid configuration: %v", err)
}
if cfg.BrokerURL == "" {
log.Fatal("[FATAL] BROKER_URL or BROKER_URL_FILE is required")
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
pool, err := database.Open(ctx, cfg)
if err != nil {
log.Fatalf("[FATAL] PostgreSQL initialization failed: %v", err)
}
defer pool.Close()
store := postgres.NewPostgreSQLStore(pool, cfg.DatabaseQueryTimeout)
objects, err := objectstore.NewMinIOStore(
cfg.S3Endpoint,
cfg.S3Region,
cfg.S3Bucket,
cfg.S3AccessKeyID,
cfg.S3SecretAccessKey,
cfg.S3OperationTimeout,
)
if err != nil {
log.Fatalf("[FATAL] Object storage initialization failed: %v", err)
}
beforeFaultFile := os.Getenv("WORKER_FAULT_BEFORE_OBJECTS_FILE")
if beforeFaultFile == "" {
beforeFaultFile = defaultBeforeObjectsFaultFile
}
afterFaultFile := os.Getenv("WORKER_FAULT_AFTER_OBJECTS_FILE")
if afterFaultFile == "" {
afterFaultFile = defaultAfterObjectsFaultFile
}
processor, err := worker.NewProcessor(store, objects, worker.ProcessorHooks{
BeforeObjects: func(job domain.AttachmentJob) error {
removeErr := os.Remove(beforeFaultFile)
if errors.Is(removeErr, os.ErrNotExist) {
return nil
}
if removeErr != nil {
return fmt.Errorf("consume before-objects fault marker: %w", removeErr)
}
log.Printf("[FAULT] exiting before object writes for job %s", job.JobID)
os.Exit(85)
return nil
},
AfterObjects: func(job domain.AttachmentJob) error {
removeErr := os.Remove(afterFaultFile)
if errors.Is(removeErr, os.ErrNotExist) {
return nil
}
if removeErr != nil {
return fmt.Errorf("consume after-objects fault marker: %w", removeErr)
}
log.Printf("[FAULT] exiting after object writes and before DB commit for job %s", job.JobID)
os.Exit(86)
return nil
},
})
if err != nil {
log.Fatalf("[FATAL] Worker processor initialization failed: %v", err)
}
cleaner, err := worker.NewStagingCleaner(store, objects, cfg.StagingRetention)
if err != nil {
log.Fatalf("[FATAL] Staging cleaner initialization failed: %v", err)
}
var maintenance sync.WaitGroup
maintenance.Add(1)
go func() {
defer maintenance.Done()
runCleanup := func() {
cleanupContext, cancel := context.WithTimeout(ctx, cfg.S3OperationTimeout+cfg.DatabaseQueryTimeout)
deleted, cleanupErr := cleaner.RunOnce(cleanupContext, time.Now().UTC())
cancel()
if cleanupErr != nil && ctx.Err() == nil {
log.Printf("[WARN] Staging cleanup failed: %v", cleanupErr)
} else if deleted > 0 {
log.Printf("[INFO] Staging cleanup removed %d object(s)", deleted)
}
}
runCleanup()
ticker := time.NewTicker(cfg.StagingCleanupInterval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
runCleanup()
}
}
}()
client, err := broker.Open(cfg.BrokerURL, cfg.WorkerConcurrency)
if err != nil {
log.Fatalf("[FATAL] RabbitMQ initialization failed: %v", err)
}
defer client.Close()
deliveries, err := client.Consume(cfg.InstanceID)
if err != nil {
log.Fatalf("[FATAL] RabbitMQ consume failed: %v", err)
}
var group sync.WaitGroup
for index := 0; index < cfg.WorkerConcurrency; index++ {
group.Add(1)
go func(workerIndex int) {
defer group.Done()
workerID := fmt.Sprintf("%s-%d", cfg.InstanceID, workerIndex)
for delivery := range deliveries {
message, decodeErr := broker.Decode(delivery)
if decodeErr != nil {
log.Printf("[WARN] Reject invalid broker message: %v", decodeErr)
_ = delivery.Reject(false)
continue
}
now := time.Now().UTC()
job, claimed, claimErr := store.ClaimAttachmentJob(
ctx,
message,
workerID,
now.Add(cfg.JobLease),
)
if errors.Is(claimErr, postgres.ErrNotFound) {
log.Printf("[INFO] Stale broker message for missing job %s acknowledged", message.JobID)
_ = delivery.Ack(false)
continue
}
if claimErr != nil {
log.Printf("[WARN] Claim job %s failed: %v", message.JobID, claimErr)
_ = delivery.Nack(false, true)
continue
}
if !claimed {
_ = delivery.Ack(false)
continue
}
jobContext, cancel := context.WithTimeout(ctx, cfg.JobTimeout)
processErr := processor.Process(jobContext, job)
cancel()
if processErr == nil {
_ = delivery.Ack(false)
continue
}
var permanent *worker.PermanentError
if errors.As(processErr, &permanent) {
if failErr := store.FailAttachmentJob(
ctx,
job.JobID,
permanent.Code,
time.Now().UTC(),
); failErr != nil {
log.Printf("[WARN] Persist permanent failure for job %s failed: %v", job.JobID, failErr)
_ = delivery.Nack(false, true)
} else {
log.Printf("[WARN] Job %s failed permanently with %s", job.JobID, permanent.Code)
_ = delivery.Ack(false)
}
continue
}
retryAt := time.Now().UTC()
delay := worker.RetryDelay(
job.JobID,
job.Attempt+1,
cfg.JobRetryBase,
cfg.JobRetryMax,
)
retried, final, retryErr := store.RetryAttachmentJob(
ctx,
job.JobID,
"processing_failed",
retryAt.Add(delay),
retryAt,
"retry_scheduled",
)
if retryErr != nil {
log.Printf("[WARN] Schedule retry for job %s failed: %v", job.JobID, retryErr)
_ = delivery.Nack(false, true)
continue
}
if final && retried.Status == domain.AttachmentJobFailed {
log.Printf("[WARN] Job %s exhausted retries", job.JobID)
} else if final && retried.Status == domain.AttachmentJobSucceeded {
log.Printf("[INFO] Duplicate delivery for completed job %s acknowledged", job.JobID)
} else if final && retried.Status == domain.AttachmentJobSuperseded {
log.Printf("[INFO] Stale pipeline job %s acknowledged as superseded", job.JobID)
} else {
log.Printf("[INFO] Job %s retry %d scheduled after %s", job.JobID, retried.Attempt, delay)
}
_ = delivery.Ack(false)
}
}(index)
}
log.Printf(
"[INFO] Attachment worker started with concurrency=%d prefetch=%d lease=%s",
cfg.WorkerConcurrency,
cfg.WorkerConcurrency,
cfg.JobLease,
)
<-ctx.Done()
_ = client.Close()
group.Wait()
maintenance.Wait()
log.Println("[INFO] Attachment worker stopped")
}
+458
View File
@@ -0,0 +1,458 @@
services:
load-balancer:
build:
context: .
dockerfile: infrastructure/haproxy/Dockerfile
image: mtusi2026lab5-load-balancer
ports:
- "127.0.0.1:${PUBLIC_PORT:-8080}:8080"
depends_on:
api:
condition: service_healthy
frontend:
condition: service_healthy
healthcheck:
test:
[
"CMD-SHELL",
"wget -qO- http://127.0.0.1:8080/health/ready || exit 1",
]
interval: 5s
timeout: 3s
retries: 10
start_period: 3s
stop_grace_period: 10s
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.25"
memory: 128M
frontend:
build:
context: .
dockerfile: infrastructure/nginx/Dockerfile
image: mtusi2026lab5-web
expose:
- "8080"
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:8080/ >/dev/null || exit 1"]
interval: 5s
timeout: 3s
retries: 10
start_period: 3s
stop_grace_period: 10s
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.10"
memory: 64M
postgres:
image: postgres:16.15-alpine3.24@sha256:721873c34ceb9f8d8fc265984940dc982404c105f19ad51be9fdc5970a6080ea
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_DB: ${POSTGRES_DB:-messenger}
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test:
[
"CMD-SHELL",
"pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}",
]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
restart: unless-stopped
deploy:
resources:
limits:
cpus: "${POSTGRES_CPU_LIMIT:-1.00}"
memory: ${POSTGRES_MEMORY_LIMIT:-512M}
redis:
image: redis:8.10.2-alpine3.23@sha256:3811787313eba226a2ef38658c6ccb91cd5e110edc89c37767de373120a0e5a0
command:
[
"redis-server",
"--save",
"",
"--appendonly",
"no",
"--maxmemory",
"64mb",
"--maxmemory-policy",
"allkeys-lru",
]
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
start_period: 3s
stop_grace_period: 10s
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.25"
memory: 128M
migrate:
image: migrate/migrate:v4.20.1@sha256:76cc2074cb6642631f34a898ced71e6aeaa6b1a4d78c4daa743275a22e0c5be7
entrypoint: ["/bin/sh", "-ec"]
command:
- >
exec migrate
-path=/migrations
-database="$$(cat /run/secrets/database_url)"
up
secrets:
- database_url
volumes:
- ./migrations:/migrations:ro
depends_on:
postgres:
condition: service_healthy
restart: "no"
deploy:
resources:
limits:
cpus: "0.25"
memory: 64M
minio:
build:
context: .
dockerfile: infrastructure/minio/Dockerfile
target: server
args:
MINIO_VERSION: RELEASE.2025-10-15T17-29-55Z
image: mtusi2026lab5-minio:RELEASE.2025-10-15T17-29-55Z
command: ["server", "/data", "--address", ":9000"]
environment:
MINIO_ROOT_USER_FILE: /run/secrets/minio_root_user
MINIO_ROOT_PASSWORD_FILE: /run/secrets/minio_root_password
MINIO_BROWSER: "off"
secrets:
- minio_root_user
- minio_root_password
volumes:
- minio_data:/data
expose:
- "9000"
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:9000/minio/health/live >/dev/null || exit 1"]
interval: 5s
timeout: 3s
retries: 20
start_period: 10s
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.75"
memory: 512M
minio-bootstrap:
build:
context: .
dockerfile: infrastructure/minio/Dockerfile
target: client
args:
MC_VERSION: RELEASE.2025-08-13T08-35-41Z
image: mtusi2026lab5-mc:RELEASE.2025-08-13T08-35-41Z
entrypoint: ["/bin/sh", "-ec"]
command:
- |
root_user="$$(cat /run/secrets/minio_root_user)"
root_password="$$(cat /run/secrets/minio_root_password)"
api_user="$$(cat /run/secrets/s3_access_key_id)"
api_password="$$(cat /run/secrets/s3_secret_access_key)"
mc alias set local http://minio:9000 "$$root_user" "$$root_password" --api S3v4
mc mb --ignore-existing "local/$${S3_BUCKET}"
mc anonymous set none "local/$${S3_BUCKET}"
sed "s/__BUCKET__/$${S3_BUCKET}/g" /config/api-policy.template.json > /tmp/api-policy.json
mc admin policy create local messenger-api /tmp/api-policy.json
if ! mc admin user info local "$$api_user" >/dev/null 2>&1; then
mc admin user add local "$$api_user" "$$api_password"
fi
mc admin policy attach local messenger-api --user "$$api_user"
environment:
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
secrets:
- minio_root_user
- minio_root_password
- s3_access_key_id
- s3_secret_access_key
volumes:
- ./infrastructure/minio/api-policy.template.json:/config/api-policy.template.json:ro
depends_on:
minio:
condition: service_healthy
restart: "no"
broker:
image: rabbitmq:4.1.4-alpine
entrypoint: ["/bin/sh", "-ec"]
command:
- |
export RABBITMQ_DEFAULT_USER=messenger
export RABBITMQ_DEFAULT_PASS="$$(cat /run/secrets/broker_password)"
exec docker-entrypoint.sh rabbitmq-server
secrets:
- broker_password
volumes:
- broker_data:/var/lib/rabbitmq
healthcheck:
test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
interval: 5s
timeout: 5s
retries: 20
start_period: 10s
stop_grace_period: 20s
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.50"
memory: 256M
dispatcher:
build:
context: .
dockerfile: Dockerfile
image: mtusi2026lab5-app
entrypoint: ["/app/dispatcher"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
BROKER_URL_FILE: /run/secrets/broker_url
DB_CONNECT_TIMEOUT: ${DB_CONNECT_TIMEOUT:-5s}
DB_QUERY_TIMEOUT: ${DB_QUERY_TIMEOUT:-3s}
JOB_TIMEOUT_SECONDS: ${JOB_TIMEOUT_SECONDS:-60}
JOB_RETRY_BASE: ${JOB_RETRY_BASE:-250ms}
JOB_RETRY_MAX: ${JOB_RETRY_MAX:-4s}
JOB_LEASE_SECONDS: ${JOB_LEASE_SECONDS:-75}
DISPATCHER_FAULT_BEFORE_PUBLISH_FILE: /tmp/mtusi-fault-before-publish
secrets:
- database_url
- broker_url
depends_on:
broker:
condition: service_healthy
migrate:
condition: service_completed_successfully
restart: unless-stopped
healthcheck:
disable: true
deploy:
resources:
limits:
cpus: "0.25"
memory: 128M
worker:
build:
context: .
dockerfile: Dockerfile
image: mtusi2026lab5-app
entrypoint: ["/app/worker"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
BROKER_URL_FILE: /run/secrets/broker_url
S3_ENDPOINT: ${S3_ENDPOINT:-http://minio:9000}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
S3_OPERATION_TIMEOUT: ${S3_OPERATION_TIMEOUT:-5s}
WORKER_CONCURRENCY: ${WORKER_CONCURRENCY:-2}
JOB_MAX_ATTEMPTS: ${JOB_MAX_ATTEMPTS:-5}
JOB_TIMEOUT_SECONDS: ${JOB_TIMEOUT_SECONDS:-60}
JOB_RETRY_BASE: ${JOB_RETRY_BASE:-250ms}
JOB_RETRY_MAX: ${JOB_RETRY_MAX:-4s}
JOB_LEASE_SECONDS: ${JOB_LEASE_SECONDS:-75}
STAGING_RETENTION_SECONDS: ${STAGING_RETENTION_SECONDS:-86400}
STAGING_CLEANUP_INTERVAL_SECONDS: ${STAGING_CLEANUP_INTERVAL_SECONDS:-30}
WORKER_FAULT_BEFORE_OBJECTS_FILE: /tmp/mtusi-fault-before-objects
WORKER_FAULT_AFTER_OBJECTS_FILE: /tmp/mtusi-fault-after-objects
DB_CONNECT_TIMEOUT: ${DB_CONNECT_TIMEOUT:-5s}
DB_QUERY_TIMEOUT: ${DB_QUERY_TIMEOUT:-3s}
GOMEMLIMIT: ${WORKER_GO_MEMORY_LIMIT:-448MiB}
secrets:
- database_url
- broker_url
- s3_access_key_id
- s3_secret_access_key
depends_on:
broker:
condition: service_healthy
migrate:
condition: service_completed_successfully
minio-bootstrap:
condition: service_completed_successfully
stop_grace_period: 70s
restart: unless-stopped
healthcheck:
disable: true
deploy:
resources:
limits:
cpus: "1.00"
memory: ${WORKER_MEMORY_LIMIT:-512M}
api:
build:
context: .
dockerfile: Dockerfile
image: mtusi2026lab5-app
environment:
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: ${APP_INTERNAL_PORT:-8080}
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
JOB_MAX_ATTEMPTS: ${JOB_MAX_ATTEMPTS:-5}
SESSION_STORE: ${SESSION_STORE:-postgres}
SESSION_COOKIE_SECURE: ${SESSION_COOKIE_SECURE:-false}
CURSOR_SIGNING_KEY_FILE: ${CURSOR_SIGNING_KEY_FILE:-/run/secrets/cursor_signing_key}
CACHE_URL: ${CACHE_URL:-redis://redis:6379/0}
CACHE_TTL: ${CACHE_TTL:-5m}
CACHE_OPERATION_TIMEOUT: ${CACHE_OPERATION_TIMEOUT:-250ms}
CACHE_POOL_SIZE: ${CACHE_POOL_SIZE:-10}
S3_ENDPOINT: ${S3_ENDPOINT:-http://minio:9000}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID_FILE: ${S3_ACCESS_KEY_ID_FILE:-/run/secrets/s3_access_key_id}
S3_SECRET_ACCESS_KEY_FILE: ${S3_SECRET_ACCESS_KEY_FILE:-/run/secrets/s3_secret_access_key}
S3_OPERATION_TIMEOUT: ${S3_OPERATION_TIMEOUT:-5s}
DATABASE_URL_FILE: ${DATABASE_URL_FILE:-/run/secrets/database_url}
DB_MAX_CONNS: ${DB_MAX_CONNS:-10}
DB_MIN_CONNS: ${DB_MIN_CONNS:-2}
DB_MAX_CONN_LIFETIME: ${DB_MAX_CONN_LIFETIME:-30m}
DB_MAX_CONN_IDLE_TIME: ${DB_MAX_CONN_IDLE_TIME:-5m}
DB_HEALTH_CHECK_PERIOD: ${DB_HEALTH_CHECK_PERIOD:-30s}
DB_CONNECT_TIMEOUT: ${DB_CONNECT_TIMEOUT:-5s}
DB_QUERY_TIMEOUT: ${DB_QUERY_TIMEOUT:-3s}
READINESS_TIMEOUT: ${READINESS_TIMEOUT:-2s}
SHUTDOWN_DRAIN_DELAY: ${SHUTDOWN_DRAIN_DELAY:-2s}
SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-10s}
GOMEMLIMIT: ${API_GO_MEMORY_LIMIT:-220MiB}
secrets:
- database_url
- s3_access_key_id
- s3_secret_access_key
- cursor_signing_key
expose:
- "8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
migrate:
condition: service_completed_successfully
minio-bootstrap:
condition: service_completed_successfully
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits:
cpus: "${API_CPU_LIMIT:-0.50}"
memory: ${API_MEMORY_LIMIT:-256M}
healthcheck:
test:
[
"CMD-SHELL",
"wget -qO- http://127.0.0.1:$${APP_PORT:-8080}/health/ready || exit 1",
]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
stop_grace_period: 15s
restart: unless-stopped
redis-insight:
image: redis/redisinsight:3.8.0@sha256:b5e19ee240abef6edb435871b90ff8a210995422e8e018ab61c0339d318a1f84
profiles: ["tools"]
ports:
- "127.0.0.1:${REDIS_INSIGHT_PORT:-5540}:5540"
volumes:
- redis_insight_data:/data
depends_on:
redis:
condition: service_healthy
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.50"
memory: 256M
postgres-restore:
image: postgres:16.15-alpine3.24@sha256:721873c34ceb9f8d8fc265984940dc982404c105f19ad51be9fdc5970a6080ea
profiles: ["recovery"]
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_DB: ${POSTGRES_RESTORE_DB:-messenger_restore_admin}
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- postgres_restore_data:/var/lib/postgresql/data
healthcheck:
test:
[
"CMD-SHELL",
"pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_RESTORE_DB:-messenger_restore_admin}",
]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
restart: "no"
deploy:
resources:
limits:
cpus: "1.00"
memory: 512M
volumes:
postgres_data:
redis_insight_data:
minio_data:
broker_data:
postgres_restore_data:
secrets:
postgres_password:
file: ./secrets/postgres_password.txt
database_url:
file: ./secrets/database_url.txt
cursor_signing_key:
file: ./secrets/cursor_signing_key.txt
minio_root_user:
file: ./secrets/minio_root_user.txt
minio_root_password:
file: ./secrets/minio_root_password.txt
s3_access_key_id:
file: ./secrets/s3_access_key_id.txt
s3_secret_access_key:
file: ./secrets/s3_secret_access_key.txt
broker_password:
file: ./secrets/broker_password.txt
broker_url:
file: ./secrets/broker_url.txt
+50
View File
@@ -0,0 +1,50 @@
# Lab5 grade 3 — результаты проверок
Дата: 2026-11-04
Ветка: `solution/bvt2301-churilin`
```text
make check
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
make validate PYTHON=/home/d1frend/HL/mtusi2026lab4/.venv/bin/python
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
make test BASE_URL=http://127.0.0.1:8080
PASS: lab5 public API scenario; infrastructure and grading evidence remain separate.
make test-async-resilience BASE_URL=http://127.0.0.1:8080
PASS: durable recovery, idempotent redelivery and bounded final failure verified.
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080
PASS: persistence preserved confirmed data and existing session.
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8080
{"observed_instances_before": 2, "successful_writes": 142, "failed_attempts": 0, "first_recovery_seconds": 2.776}
PASS: failover preserved confirmed data and existing session.
make test-attachment-boundaries
PASS: exact byte/pixel boundaries, complete decode, and filename validation are correct.
make test-attachment-memory
{"api_instances_observed": 2, "concurrency": 12, "elapsed_seconds": 1.007, "payload_bytes": 6293028, "peak_memory_bytes_by_container": {"mtusi2026lab5-api-1": 27472691, "mtusi2026lab5-api-2": 27294433}, "successful_uploads": 12, "total_uploaded_bytes": 75516336}
PASS: concurrent attachment uploads remained within configured API memory limits.
make test-minio-policy
PASS: API has no MinIO root credentials; limited policy permits object IO only in the private bucket; anonymous GET is denied.
make test-storage-outage
{"original_bytes_verified": 111817, "readiness_503_seconds": 2.004, "upload_503_seconds": 5.011}
PASS: MinIO outage returns bounded JSON 503 and preserves existing originals.
go test ./...
PASS
go vet ./...
PASS
docker compose --env-file .env config --quiet
exit 0
```
Сценарии и ожидаемые инварианты находятся в `tests/async_resilience.py`, `tests/resilience.py`, `scripts/restart.sh` и `scripts/stop-one.sh`.
+56
View File
@@ -0,0 +1,56 @@
# Lab5 grade 4 — результаты проверок
Дата: 2026-11-05
Автор: Чурилин Данила, БВТ2301
Ветка: `solution/bvt2301-churilin`
```text
make test-level4-resilience BASE_URL=http://127.0.0.1:8080
PASS: level-4 variants, outbox crash recovery, lease recovery, backoff/failed registry and safe replay verified.
make test-async-resilience BASE_URL=http://127.0.0.1:8080
PASS: durable recovery, idempotent redelivery and bounded final failure verified.
make test BASE_URL=http://127.0.0.1:8080
PASS: lab5 public API scenario; infrastructure and grading evidence remain separate.
go test ./...
PASS
go vet ./...
PASS
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080
PASS: persistence preserved confirmed data and existing session.
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8080
{"observed_instances_before": 2, "successful_writes": 142, "failed_attempts": 0, "first_recovery_seconds": 2.989}
PASS: failover preserved confirmed data and existing session.
make test-attachment-boundaries
PASS: exact byte/pixel boundaries, complete decode, and filename validation are correct.
make test-attachment-memory
{"api_instances_observed": 2, "concurrency": 12, "elapsed_seconds": 0.754, "payload_bytes": 6293028, "peak_memory_bytes_by_container": {"mtusi2026lab5-api-1": 33774632, "mtusi2026lab5-api-2": 36217815}, "successful_uploads": 12, "total_uploaded_bytes": 75516336}
PASS: concurrent attachment uploads remained within configured API memory limits.
make test-minio-policy
PASS: API has no MinIO root credentials; limited policy permits object IO only in the private bucket; anonymous GET is denied.
make test-storage-outage
{"original_bytes_verified": 111817, "readiness_503_seconds": 2.009, "upload_503_seconds": 5.02}
PASS: MinIO outage returns bounded JSON 503 and preserves existing originals.
rabbitmqctl list_queues name messages_ready messages_unacknowledged
attachment.process.v1 0 0
docker compose --env-file .env config --quiet
exit 0
```
Fault points:
- dispatcher: `/tmp/mtusi-fault-before-publish`, exit 87;
- worker: `/tmp/mtusi-fault-after-objects`, exit 86;
- тест: `tests/level4_resilience.py`;
- unit invariants: `internal/worker/processor_test.go`, `backoff_test.go`, `cleaner_test.go`.
+121
View File
@@ -0,0 +1,121 @@
# Lab 5 — доказательства оценки «5», трек 2
Дата эксперимента: 2026-11-05
Автор: Чурилин Данила, БВТ2301
Трек: доказанная идемпотентность versioned pipeline
## Гипотеза
Если логический эффект адресуется ключом `(attachment_id, pipeline_version, variant)`, новая версия создаётся одной транзакцией с supersede старой активной job, а каждый переход проверяет текущую `attachments.pipeline_version`, то at-least-once доставка, дубли, изменение порядка и падения вокруг side effect:
1. не теряют подтверждённый HTTP 202 upload;
2. не создают дополнительные variant rows той же версии;
3. не позволяют старой job изменить состояние или метаданные активной новой версии;
4. сохраняют историю v1 и v2 раздельно.
## Реализация и инварианты
- Новые upload создаются в pipeline v1.
- Операторский `jobctl upgrade <attachment_id> 2` сначала копирует неизменный final original в новый durable staging key, затем транзакционно:
- переводит старую queued/processing job в `superseded`;
- обновляет активную версию attachment;
- создаёт v2 job/outbox;
- записывает audit events.
- v1 и v2 используют разные профили качества:
- v1: JPEG 85, WebP 80;
- v2: JPEG 90, WebP 85.
- S3 keys содержат `/v1/` или `/v2/`.
- DB PK variant: `(attachment_id, pipeline_version, name)`.
- Completion, retry, permanent failure, replay и lease recovery блокируют запись неактивной версии.
- Повтор сообщения ready-job нормализуется/подтверждается как no-op.
- Неизвестный или устаревший attempt подтверждается без requeue-loop.
Проверяемые инварианты:
- `attachments.pipeline_version` никогда не уменьшается;
- active attachment `ready:v2` выдаёт только три v2-варианта;
- old v1 completion не меняет v2 attachment;
- число строк одной версии и одного имени не больше одной;
- original SHA-256 до/после дублей одинаков;
- после завершения нет queued/processing job, ready staging и сообщений broker.
## Повторяемая методика
~~~sh
docker compose --env-file .env up -d --build --wait
make test-level5-idempotency
~~~
`tests/level5_idempotency.py` автоматически выполняет:
1. Crash до первого S3 side effect через `/tmp/mtusi-fault-before-objects`.
- Проверяет, что upgrade v2 отклонён из-за отсутствующего final original.
- Истекает lease и доказывает восстановление той же подтверждённой v1 job до ready.
2. Crash после S3 writes, но до result COMMIT/ack.
- Создаёт v2, пока v1 ещё processing.
- Проверяет v1 `superseded`, v2 `succeeded`, отсутствие v1 metadata commit.
3. Завершает обычную v1, сохраняет три v1-хеша, запускает upgrade v2.
- Проверяет шесть строк истории (по три на версию).
- Проверяет различие v1/v2 SHA-256 из-за разных профилей.
4. Публикует два дубля v2, затем устаревшее v1-сообщение после v2.
- Проверяет состояние `ready:2`, неизменность v2-хешей и original.
- Проверяет отсутствие дополнительных variant rows.
Команды ручной демонстрации:
~~~sh
make upgrade-pipeline ATTACHMENT_ID=<uuid> PIPELINE_VERSION=2
make inject-job JOB_ID=<uuid>
~~~
## Наблюдаемый результат
~~~text
PASS: pipeline v1/v2 history, crash before/after side effect,
superseded in-flight work, duplicate and reordered stale deliveries verified.
~~~
Один зафиксированный version-history sample:
- attachment `96a4af45-e784-4b8d-8031-4c6d0e98a06c`;
- active state: `ready:v2`;
- jobs: v1 `succeeded`, v2 `succeeded`;
- variants: три v1 + три v2;
- v1 thumbnail SHA-256: `b6c3170f7966802990e1bd448f7b5491ff5a45f637c87d19aa2b9c4db42aacae`;
- v2 thumbnail SHA-256: `8947478ff919ac36572552a347acdd564e5a68aeac797adc33e8dd7d5246bb2f`.
Один race sample завершился как v1 `superseded` + v2 `succeeded`, без v1 variant metadata.
Финальные инварианты стенда:
~~~text
active queued/processing jobs = 0
ready attachments with staging_key = 0
RabbitMQ messages_ready = 0
RabbitMQ messages_unacknowledged = 0
~~~
Регрессия после эксперимента:
~~~text
make test-level5-idempotency — PASS
make test-async-resilience — PASS
make test-level4-resilience — PASS
make test — PASS
go test ./... — PASS
go vet ./... — PASS
~~~
## Почему это не exactly-once
RabbitMQ остаётся транспортом at least once: publisher может повторить публикацию после неясного confirm, а consumer может выполнить S3 write и умереть до ACK. Одно сообщение физически может быть доставлено и обработано несколько раз.
Доказанное свойство слабее и практичнее: повторяемый side effect идемпотентен, DB публикует только результат активной версии, а versioned object keys не дают старой версии перезаписать новую. Это effectively-once результат в заявленных границах, но не exactly-once доставка.
## Ограничения
- Поддержаны только pipeline v1 и v2; произвольный registry профилей не реализован.
- Upgrade — операторская команда, а не публичный API.
- История старых variant-объектов сохраняется; отдельная lifecycle-policy для архивных версий не реализована.
- Эксперимент выполнялся на одном Docker-host и не доказывает устойчивость к потере host, PostgreSQL volume или MinIO volume.
- Crash markers учебные и локальные; они не являются production chaos framework.
+3
View File
@@ -0,0 +1,3 @@
node_modules
dist
coverage
+17
View File
@@ -0,0 +1,17 @@
<!doctype html>
<html lang="ru">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta name="theme-color" content="#11110f" />
<meta
name="description"
content="Минималистичный веб-клиент распределённого MTUCI Messenger"
/>
<title>MTUCI Messenger</title>
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
+1688
View File
File diff suppressed because it is too large Load Diff
+27
View File
@@ -0,0 +1,27 @@
{
"name": "mtusi-messenger-web",
"private": true,
"version": "0.1.0",
"type": "module",
"scripts": {
"dev": "vite --host 0.0.0.0",
"build": "tsc -b && vite build",
"test": "vitest run",
"test:watch": "vitest"
},
"dependencies": {
"@tanstack/react-query": "^5.104.5",
"lucide-react": "^1.61.0",
"react": "^19.3.1",
"react-dom": "^19.3.1",
"react-router-dom": "^7.18.4"
},
"devDependencies": {
"@types/react": "^19.3.0",
"@types/react-dom": "^19.3.0",
"@vitejs/plugin-react": "^6.1.2",
"typescript": "^7.0.2",
"vite": "^8.3.5",
"vitest": "^5.0.5"
}
}
+163
View File
@@ -0,0 +1,163 @@
import type {
ApiErrorBody,
Chat,
CreateChatInput,
LoginInput,
Message,
Page,
RegisterInput,
Session,
User,
} from "./types";
const publicApi = "/api/v1";
const browserApi = "/web-api/v1";
export class ApiError extends Error {
readonly status: number;
readonly code?: string;
readonly requestId?: string;
constructor(status: number, body: ApiErrorBody) {
super(body.error?.message || `HTTP ${status}`);
this.name = "ApiError";
this.status = status;
this.code = body.error?.code;
this.requestId = body.error?.request_id;
}
}
type RequestOptions = Omit<RequestInit, "body"> & {
body?: unknown;
};
async function request<T>(path: string, options: RequestOptions = {}): Promise<T> {
const headers = new Headers(options.headers);
if (options.body !== undefined) {
headers.set("Content-Type", "application/json");
}
const response = await fetch(path, {
...options,
headers,
credentials: "same-origin",
body: options.body === undefined ? undefined : JSON.stringify(options.body),
});
if (!response.ok) {
let body: ApiErrorBody = {};
try {
body = (await response.json()) as ApiErrorBody;
} catch {
// Preserve a useful HTTP-level error when a proxy returned non-JSON.
}
throw new ApiError(response.status, body);
}
if (response.status === 204) {
return undefined as T;
}
return (await response.json()) as T;
}
function encodeBasic({ username, password }: LoginInput): string {
const bytes = new TextEncoder().encode(`${username}:${password}`);
let binary = "";
for (const byte of bytes) {
binary += String.fromCharCode(byte);
}
return btoa(binary);
}
async function collectPages<T>(path: string): Promise<T[]> {
const items: T[] = [];
let cursor: string | null = null;
for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
const search = new URLSearchParams({ limit: "100" });
if (cursor) {
search.set("cursor", cursor);
}
const page = await request<Page<T>>(`${path}?${search.toString()}`);
items.push(...page.items);
cursor = page.next_cursor;
if (!cursor) {
return items;
}
}
throw new Error("pagination safety limit exceeded");
}
export const api = {
register(input: RegisterInput): Promise<User> {
return request<User>(`${publicApi}/users`, {
method: "POST",
body: {
username: input.username,
display_name: input.displayName,
password: input.password,
},
});
},
login(input: LoginInput): Promise<Session> {
return request<Session>(`${publicApi}/auth/sessions`, {
method: "POST",
headers: {
Authorization: `Basic ${encodeBasic(input)}`,
},
});
},
logout(): Promise<void> {
return request<void>(`${browserApi}/auth/sessions/current`, {
method: "DELETE",
});
},
me(): Promise<User> {
return request<User>(`${browserApi}/users/me`);
},
chats(): Promise<Chat[]> {
return collectPages<Chat>(`${browserApi}/chats`);
},
chat(chatID: string): Promise<Chat> {
return request<Chat>(`${browserApi}/chats/${encodeURIComponent(chatID)}`);
},
createChat(input: CreateChatInput): Promise<Chat> {
return request<Chat>(`${browserApi}/chats`, {
method: "POST",
body: {
title: input.title,
member_ids: input.memberIds,
},
});
},
messages(chatID: string): Promise<Message[]> {
return collectPages<Message>(
`${browserApi}/chats/${encodeURIComponent(chatID)}/messages`,
);
},
sendMessage(
chatID: string,
text: string,
idempotencyKey: string,
attachmentIDs: string[] = [],
): Promise<Message> {
return request<Message>(
`${browserApi}/chats/${encodeURIComponent(chatID)}/messages`,
{
method: "POST",
headers: {
"Idempotency-Key": idempotencyKey,
},
body: { text, attachment_ids: attachmentIDs },
},
);
},
};
+58
View File
@@ -0,0 +1,58 @@
export type User = {
id: string;
username: string;
display_name: string;
created_at: string;
};
export type Session = {
token: string;
token_type: "Bearer";
expires_at: string;
user: User;
};
export type Chat = {
id: string;
title: string;
member_ids: string[];
created_at: string;
};
export type Message = {
id: string;
chat_id: string;
sender_id: string;
text: string;
attachment_ids: string[];
created_at: string;
};
export type Page<T> = {
items: T[];
next_cursor: string | null;
};
export type ApiErrorBody = {
error?: {
code?: string;
message?: string;
request_id?: string;
};
};
export type RegisterInput = {
username: string;
displayName: string;
password: string;
};
export type CreateChatInput = {
title: string;
memberIds: string[];
};
export type LoginInput = {
username: string;
password: string;
};
+51
View File
@@ -0,0 +1,51 @@
import { Navigate, Outlet, Route, Routes, useLocation } from "react-router-dom";
import { useAuth } from "../auth/AuthProvider";
import { LoadingScreen } from "../components/LoadingScreen";
import { AuthPage } from "../pages/AuthPage";
import { MessengerPage } from "../pages/MessengerPage";
function ProtectedRoute() {
const { user, isLoading } = useAuth();
const location = useLocation();
if (isLoading) {
return <LoadingScreen />;
}
if (!user) {
return <Navigate to="/login" replace state={{ from: location.pathname }} />;
}
return <Outlet />;
}
function PublicOnlyRoute() {
const { user, isLoading } = useAuth();
if (isLoading) {
return <LoadingScreen />;
}
if (user) {
return <Navigate to="/app" replace />;
}
return <Outlet />;
}
export function App() {
return (
<Routes>
<Route element={<PublicOnlyRoute />}>
<Route path="/login" element={<AuthPage initialMode="login" />} />
<Route path="/register" element={<AuthPage initialMode="register" />} />
</Route>
<Route element={<ProtectedRoute />}>
<Route path="/app" element={<MessengerPage />} />
<Route path="/app/chats/:chatId" element={<MessengerPage />} />
<Route path="/app/profile" element={<MessengerPage profileOpen />} />
</Route>
<Route path="/" element={<Navigate to="/app" replace />} />
<Route path="*" element={<Navigate to="/app" replace />} />
</Routes>
);
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 540 KiB

+90
View File
@@ -0,0 +1,90 @@
import { useQuery, useQueryClient } from "@tanstack/react-query";
import {
createContext,
useCallback,
useContext,
type PropsWithChildren,
} from "react";
import { api, ApiError } from "../api/client";
import type { LoginInput, RegisterInput, User } from "../api/types";
type AuthContextValue = {
user: User | null;
isLoading: boolean;
login: (input: LoginInput) => Promise<void>;
register: (input: RegisterInput) => Promise<void>;
logout: () => Promise<void>;
};
const AuthContext = createContext<AuthContextValue | null>(null);
const meQueryKey = ["current-user"] as const;
async function loadCurrentUser(): Promise<User | null> {
try {
return await api.me();
} catch (error) {
if (error instanceof ApiError && error.status === 401) {
return null;
}
throw error;
}
}
export function AuthProvider({ children }: PropsWithChildren) {
const queryClient = useQueryClient();
const meQuery = useQuery({
queryKey: meQueryKey,
queryFn: loadCurrentUser,
retry: false,
staleTime: 30_000,
});
const login = useCallback(
async (input: LoginInput) => {
const session = await api.login(input);
queryClient.setQueryData(meQueryKey, session.user);
},
[queryClient],
);
const register = useCallback(
async (input: RegisterInput) => {
await api.register(input);
const session = await api.login({
username: input.username,
password: input.password,
});
queryClient.setQueryData(meQueryKey, session.user);
},
[queryClient],
);
const logout = useCallback(async () => {
await api.logout();
queryClient.setQueryData(meQueryKey, null);
queryClient.removeQueries({ queryKey: ["chats"] });
}, [queryClient]);
return (
<AuthContext.Provider
value={{
user: meQuery.data ?? null,
isLoading: meQuery.isLoading,
login,
register,
logout,
}}
>
{children}
</AuthContext.Provider>
);
}
export function useAuth(): AuthContextValue {
const context = useContext(AuthContext);
if (!context) {
throw new Error("useAuth must be used within AuthProvider");
}
return context;
}
+26
View File
@@ -0,0 +1,26 @@
import { initials } from "../lib/format";
type AvatarProps = {
label: string;
seed?: string;
size?: "small" | "medium" | "large";
};
function tone(seed: string): number {
let hash = 0;
for (const character of seed) {
hash = (hash * 31 + character.codePointAt(0)!) >>> 0;
}
return hash % 5;
}
export function Avatar({ label, seed = label, size = "medium" }: AvatarProps) {
return (
<span
aria-hidden="true"
className={`avatar avatar--${size} avatar--tone-${tone(seed)}`}
>
{initials(label)}
</span>
);
}
+121
View File
@@ -0,0 +1,121 @@
import { MessageSquarePlus, Search, UsersRound, X } from "lucide-react";
import { useMemo, useState } from "react";
import { useNavigate } from "react-router-dom";
import type { Chat, User } from "../api/types";
import { formatMemberCount } from "../lib/format";
import { Avatar } from "./Avatar";
type ChatListProps = {
chats: Chat[];
currentUser: User;
error: boolean;
isLoading: boolean;
selectedChatID?: string;
onCreateChat: () => void;
};
export function ChatList({
chats,
currentUser,
error,
isLoading,
selectedChatID,
onCreateChat,
}: ChatListProps) {
const navigate = useNavigate();
const [search, setSearch] = useState("");
const filteredChats = useMemo(() => {
const normalized = search.trim().toLocaleLowerCase("ru");
if (!normalized) {
return chats;
}
return chats.filter((chat) =>
chat.title.toLocaleLowerCase("ru").includes(normalized),
);
}, [chats, search]);
return (
<aside className="chat-sidebar">
<header className="chat-sidebar__header">
<div>
<p className="eyebrow">Сообщения</p>
<h1>Чаты</h1>
</div>
<button
aria-label="Создать чат"
className="soft-icon-button"
onClick={onCreateChat}
type="button"
>
<MessageSquarePlus aria-hidden="true" />
</button>
</header>
<div className="search-box">
<Search aria-hidden="true" />
<input
aria-label="Поиск чатов"
onChange={(event) => setSearch(event.target.value)}
placeholder="Поиск"
value={search}
/>
{search && (
<button aria-label="Очистить поиск" onClick={() => setSearch("")} type="button">
<X aria-hidden="true" />
</button>
)}
</div>
<div className="chat-list" aria-live="polite">
{isLoading && (
<div className="sidebar-state">
<span className="loading-line" />
<p>Загружаем чаты…</p>
</div>
)}
{error && (
<div className="sidebar-state sidebar-state--error">
<p>Не удалось загрузить список чатов.</p>
</div>
)}
{!isLoading && !error && filteredChats.length === 0 && (
<div className="sidebar-state">
<UsersRound aria-hidden="true" />
<p>{search ? "Ничего не найдено" : "У вас пока нет чатов"}</p>
{!search && (
<button className="text-button" onClick={onCreateChat} type="button">
Создать первый
</button>
)}
</div>
)}
{filteredChats.map((chat) => (
<button
className={`chat-row ${selectedChatID === chat.id ? "chat-row--active" : ""}`}
key={chat.id}
onClick={() => navigate(`/app/chats/${chat.id}`)}
type="button"
>
<Avatar label={chat.title} seed={chat.id} />
<span className="chat-row__body">
<strong>{chat.title}</strong>
<small>{formatMemberCount(chat.member_ids.length)}</small>
</span>
{chat.member_ids.includes(currentUser.id) && (
<span className="chat-row__status" title="Вы участник">
•
</span>
)}
</button>
))}
</div>
<footer className="sidebar-footer">
<span className="status-dot" />
API подключён
</footer>
</aside>
);
}
+236
View File
@@ -0,0 +1,236 @@
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import {
ArrowLeft,
CheckCheck,
RefreshCcw,
Send,
ShieldCheck,
UsersRound,
} from "lucide-react";
import {
useEffect,
useMemo,
useRef,
useState,
type FormEvent,
type KeyboardEvent,
} from "react";
import { api } from "../api/client";
import type { Chat, Message, User } from "../api/types";
import {
dayKey,
formatDay,
formatMemberCount,
formatMessageTime,
shortID,
} from "../lib/format";
import { createIdempotencyKey } from "../lib/idempotency";
import { Avatar } from "./Avatar";
type ChatViewProps = {
chat: Chat;
currentUser: User;
onBack: () => void;
};
type SendEnvelope = {
text: string;
idempotencyKey: string;
};
export function ChatView({ chat, currentUser, onBack }: ChatViewProps) {
const queryClient = useQueryClient();
const messagesEnd = useRef<HTMLDivElement>(null);
const [draft, setDraft] = useState("");
const [failedEnvelope, setFailedEnvelope] = useState<SendEnvelope | null>(null);
const messagesQuery = useQuery({
queryKey: ["messages", chat.id],
queryFn: () => api.messages(chat.id),
refetchInterval: 3_000,
staleTime: 1_000,
});
const messages = messagesQuery.data ?? [];
useEffect(() => {
messagesEnd.current?.scrollIntoView({
behavior: messages.length > 1 ? "smooth" : "auto",
block: "end",
});
}, [chat.id, messages.length]);
const mutation = useMutation({
mutationFn: (envelope: SendEnvelope) =>
api.sendMessage(chat.id, envelope.text, envelope.idempotencyKey),
onSuccess: (message) => {
setFailedEnvelope(null);
queryClient.setQueryData<Message[]>(
["messages", chat.id],
(current = []) => {
if (current.some((item) => item.id === message.id)) {
return current;
}
return [...current, message];
},
);
},
onError: (_error, envelope) => {
setFailedEnvelope(envelope);
},
});
const groups = useMemo(() => {
const result: Array<{ key: string; label: string; messages: Message[] }> = [];
for (const message of messages) {
const key = dayKey(message.created_at);
const current = result.at(-1);
if (!current || current.key !== key) {
result.push({
key,
label: formatDay(message.created_at),
messages: [message],
});
} else {
current.messages.push(message);
}
}
return result;
}, [messages]);
function send(envelope: SendEnvelope) {
if (!mutation.isPending) {
mutation.mutate(envelope);
}
}
function submit(event: FormEvent<HTMLFormElement>) {
event.preventDefault();
const text = draft.trim();
if (!text || Array.from(text).length > 4_000) {
return;
}
const envelope = { text, idempotencyKey: createIdempotencyKey() };
setDraft("");
setFailedEnvelope(null);
send(envelope);
}
function handleKeyDown(event: KeyboardEvent<HTMLTextAreaElement>) {
if (event.key === "Enter" && !event.shiftKey) {
event.preventDefault();
event.currentTarget.form?.requestSubmit();
}
}
return (
<section className="conversation">
<header className="conversation-header">
<button
aria-label="Назад к списку чатов"
className="mobile-back-button"
onClick={onBack}
type="button"
>
<ArrowLeft aria-hidden="true" />
</button>
<Avatar label={chat.title} seed={chat.id} size="small" />
<div className="conversation-header__title">
<strong>{chat.title}</strong>
<span>{formatMemberCount(chat.member_ids.length)}</span>
</div>
<div className="conversation-header__security">
<ShieldCheck aria-hidden="true" />
<span>сессия защищена</span>
</div>
</header>
<div className="message-canvas">
<div className="message-canvas__shade" />
<div className="message-stream" aria-live="polite">
{messagesQuery.isLoading && (
<div className="floating-state">
<span className="loading-line" />
Загружаем историю
</div>
)}
{messagesQuery.isError && (
<div className="floating-state floating-state--error">
<p>История временно недоступна</p>
<button onClick={() => messagesQuery.refetch()} type="button">
<RefreshCcw aria-hidden="true" /> Повторить
</button>
</div>
)}
{!messagesQuery.isLoading && !messagesQuery.isError && messages.length === 0 && (
<div className="floating-state">
<UsersRound aria-hidden="true" />
<p>Сообщений пока нет. Начните разговор.</p>
</div>
)}
{groups.map((group) => (
<div className="message-day" key={group.key}>
<div className="date-divider"><span>{group.label}</span></div>
{group.messages.map((message) => {
const own = message.sender_id === currentUser.id;
return (
<article
className={`message-bubble ${own ? "message-bubble--own" : ""}`}
key={message.id}
>
<span className="message-bubble__sender">
{own ? "Вы" : shortID(message.sender_id)}
</span>
<p>{message.text}</p>
<span className="message-bubble__meta">
{formatMessageTime(message.created_at)}
{own && <CheckCheck aria-label="Доставлено серверу" />}
</span>
</article>
);
})}
</div>
))}
<div ref={messagesEnd} />
</div>
</div>
<footer className="composer">
{failedEnvelope && (
<div className="send-error" role="alert">
<span>Отправка не подтверждена.</span>
<button onClick={() => send(failedEnvelope)} type="button">
Повторить с тем же ключом
</button>
</div>
)}
<form onSubmit={submit}>
<textarea
aria-label="Текст сообщения"
maxLength={4_000}
onChange={(event) => setDraft(event.target.value)}
onKeyDown={handleKeyDown}
placeholder="Сообщение…"
rows={1}
value={draft}
/>
<span className="composer__counter">
{draft.length > 3_600 ? `${Array.from(draft).length}/4000` : ""}
</span>
<button
aria-label="Отправить"
className="send-button"
disabled={!draft.trim() || mutation.isPending}
type="submit"
>
<Send aria-hidden="true" />
</button>
</form>
</footer>
</section>
);
}
@@ -0,0 +1,148 @@
import { useMutation, useQueryClient } from "@tanstack/react-query";
import { Plus, UserRoundPlus, X } from "lucide-react";
import { useEffect, useState, type FormEvent } from "react";
import { useNavigate } from "react-router-dom";
import { api, ApiError } from "../api/client";
import type { Chat, User } from "../api/types";
import { shortID } from "../lib/format";
type CreateChatDialogProps = {
currentUser: User;
onClose: () => void;
};
const uuidPattern =
/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
export function CreateChatDialog({
currentUser,
onClose,
}: CreateChatDialogProps) {
const navigate = useNavigate();
const queryClient = useQueryClient();
const [title, setTitle] = useState("");
const [memberInput, setMemberInput] = useState("");
const [validationError, setValidationError] = useState("");
useEffect(() => {
function closeOnEscape(event: KeyboardEvent) {
if (event.key === "Escape") {
onClose();
}
}
window.addEventListener("keydown", closeOnEscape);
return () => window.removeEventListener("keydown", closeOnEscape);
}, [onClose]);
const mutation = useMutation({
mutationFn: api.createChat,
onSuccess: (chat) => {
queryClient.setQueryData<Chat[]>(["chats"], (current = []) => [
...current,
chat,
]);
onClose();
navigate(`/app/chats/${chat.id}`);
},
});
function submit(event: FormEvent<HTMLFormElement>) {
event.preventDefault();
setValidationError("");
const enteredIDs = memberInput
.split(/[\s,;]+/)
.map((value) => value.trim())
.filter(Boolean);
const memberIds = Array.from(new Set([currentUser.id, ...enteredIDs]));
if (!title.trim() || Array.from(title.trim()).length > 100) {
setValidationError("Название должно содержать от 1 до 100 символов");
return;
}
const invalidID = enteredIDs.find((id) => !uuidPattern.test(id));
if (invalidID) {
setValidationError(`Некорректный UUID: ${invalidID}`);
return;
}
mutation.mutate({ title: title.trim(), memberIds });
}
const serverError =
mutation.error instanceof ApiError
? mutation.error.message
: mutation.error
? "Не удалось создать чат"
: "";
return (
<div className="dialog-backdrop" onMouseDown={onClose}>
<section
aria-labelledby="create-chat-title"
aria-modal="true"
className="dialog-card"
onMouseDown={(event) => event.stopPropagation()}
role="dialog"
>
<header className="dialog-card__header">
<div>
<p className="eyebrow">Новый разговор</p>
<h2 id="create-chat-title">Создать чат</h2>
</div>
<button
aria-label="Закрыть"
className="soft-icon-button"
onClick={onClose}
type="button"
>
<X aria-hidden="true" />
</button>
</header>
<form className="dialog-form" onSubmit={submit}>
<label>
<span>Название</span>
<div className="input-shell">
<Plus aria-hidden="true" />
<input
autoFocus
maxLength={100}
onChange={(event) => setTitle(event.target.value)}
placeholder="Например, Команда проекта"
required
value={title}
/>
</div>
</label>
<label>
<span>UUID участников</span>
<div className="textarea-shell">
<UserRoundPlus aria-hidden="true" />
<textarea
onChange={(event) => setMemberInput(event.target.value)}
placeholder="Вставьте UUID через пробел, запятую или с новой строки"
rows={4}
value={memberInput}
/>
</div>
<small>
Ваш ID добавлен автоматически: <code>{shortID(currentUser.id)}</code>
</small>
</label>
{(validationError || serverError) && (
<div className="form-error" role="alert">
{validationError || serverError}
</div>
)}
<button className="primary-button" disabled={mutation.isPending} type="submit">
{mutation.isPending ? "Создаём…" : "Создать чат"}
</button>
</form>
</section>
</div>
);
}
+29
View File
@@ -0,0 +1,29 @@
import { MessageSquarePlus } from "lucide-react";
type EmptyChatProps = {
hasChats: boolean;
onCreateChat: () => void;
};
export function EmptyChat({ hasChats, onCreateChat }: EmptyChatProps) {
return (
<section className="conversation conversation--empty">
<div className="empty-chat-card">
<span className="empty-chat-card__line" />
<p className="eyebrow">MTUCI Messenger</p>
<h2>{hasChats ? "Выберите чат" : "Начните разговор"}</h2>
<p>
{hasChats
? "История и новые сообщения появятся здесь."
: "Создайте первый чат и пригласите участников по UUID."}
</p>
{!hasChats && (
<button className="primary-button" onClick={onCreateChat} type="button">
<MessageSquarePlus aria-hidden="true" />
Создать чат
</button>
)}
</div>
</section>
);
}
+11
View File
@@ -0,0 +1,11 @@
export function LoadingScreen() {
return (
<main className="loading-screen" aria-live="polite">
<div className="brand-mark brand-mark--large" aria-hidden="true">
M
</div>
<p>Подключаемся к Messenger</p>
<span className="loading-line" />
</main>
);
}
@@ -0,0 +1,42 @@
import { MessagesSquare, UserRound } from "lucide-react";
import { Link } from "react-router-dom";
import type { User } from "../api/types";
import { Avatar } from "./Avatar";
type NavigationRailProps = {
user: User;
profileOpen: boolean;
};
export function NavigationRail({ user, profileOpen }: NavigationRailProps) {
return (
<nav className="navigation-rail" aria-label="Основная навигация">
<Link className="rail-brand" to="/app" aria-label="MTUCI Messenger">
M
</Link>
<div className="rail-actions">
<Link
className={`rail-action ${profileOpen ? "" : "rail-action--active"}`}
to="/app"
>
<MessagesSquare aria-hidden="true" />
<span>Чаты</span>
</Link>
<Link
className={`rail-action ${profileOpen ? "rail-action--active" : ""}`}
to="/app/profile"
>
<UserRound aria-hidden="true" />
<span>Профиль</span>
</Link>
</div>
<Link className="rail-profile" to="/app/profile" aria-label="Открыть профиль">
<Avatar label={user.display_name} seed={user.id} size="small" />
<span className="presence-dot" />
</Link>
</nav>
);
}
+123
View File
@@ -0,0 +1,123 @@
import {
CalendarDays,
Check,
Copy,
LogOut,
ShieldCheck,
UserRound,
X,
} from "lucide-react";
import { useState } from "react";
import { useNavigate } from "react-router-dom";
import type { User } from "../api/types";
import { useAuth } from "../auth/AuthProvider";
import { Avatar } from "./Avatar";
type ProfileDrawerProps = {
user: User;
};
const createdAtFormatter = new Intl.DateTimeFormat("ru-RU", {
day: "numeric",
month: "long",
year: "numeric",
});
export function ProfileDrawer({ user }: ProfileDrawerProps) {
const { logout } = useAuth();
const navigate = useNavigate();
const [copied, setCopied] = useState(false);
const [error, setError] = useState("");
const [isLoggingOut, setIsLoggingOut] = useState(false);
async function copyID() {
await navigator.clipboard.writeText(user.id);
setCopied(true);
window.setTimeout(() => setCopied(false), 1800);
}
async function submitLogout() {
setError("");
setIsLoggingOut(true);
try {
await logout();
navigate("/login", { replace: true });
} catch {
setError("Не удалось завершить сессию. Попробуйте ещё раз.");
setIsLoggingOut(false);
}
}
return (
<>
<button
aria-label="Закрыть профиль"
className="drawer-backdrop"
onClick={() => navigate("/app")}
type="button"
/>
<aside className="profile-drawer" aria-label="Профиль пользователя">
<header className="profile-drawer__header">
<p className="eyebrow">Ваш аккаунт</p>
<button
aria-label="Закрыть"
className="soft-icon-button"
onClick={() => navigate("/app")}
type="button"
>
<X aria-hidden="true" />
</button>
</header>
<div className="profile-identity">
<Avatar label={user.display_name} seed={user.id} size="large" />
<h2>{user.display_name}</h2>
<p>@{user.username}</p>
<span className="profile-badge">
<ShieldCheck aria-hidden="true" />
серверная сессия
</span>
</div>
<dl className="profile-details">
<div>
<dt><UserRound aria-hidden="true" /> ID аккаунта</dt>
<dd>
<code>{user.id}</code>
<button
aria-label="Скопировать ID"
className="copy-button"
onClick={copyID}
type="button"
>
{copied ? <Check /> : <Copy />}
</button>
</dd>
</div>
<div>
<dt><CalendarDays aria-hidden="true" /> Дата регистрации</dt>
<dd>{createdAtFormatter.format(new Date(user.created_at))}</dd>
</div>
</dl>
<div className="profile-roadmap">
<strong>Следующие версии</strong>
<p>Аватар, редактирование имени и смена пароля появятся после API-контрактов.</p>
</div>
{error && <div className="form-error" role="alert">{error}</div>}
<button
className="logout-button"
disabled={isLoggingOut}
onClick={submitLogout}
type="button"
>
<LogOut aria-hidden="true" />
{isLoggingOut ? "Завершаем…" : "Выйти из аккаунта"}
</button>
</aside>
</>
);
}
+58
View File
@@ -0,0 +1,58 @@
const timeFormatter = new Intl.DateTimeFormat("ru-RU", {
hour: "2-digit",
minute: "2-digit",
});
const dayFormatter = new Intl.DateTimeFormat("ru-RU", {
day: "numeric",
month: "long",
});
const fullDateFormatter = new Intl.DateTimeFormat("ru-RU", {
day: "numeric",
month: "long",
year: "numeric",
});
export function formatMessageTime(value: string): string {
return timeFormatter.format(new Date(value));
}
export function formatDay(value: string): string {
const date = new Date(value);
const now = new Date();
const sameYear = date.getFullYear() === now.getFullYear();
return (sameYear ? dayFormatter : fullDateFormatter).format(date);
}
export function dayKey(value: string): string {
const date = new Date(value);
return [date.getFullYear(), date.getMonth(), date.getDate()].join("-");
}
export function formatMemberCount(count: number): string {
const mod10 = count % 10;
const mod100 = count % 100;
if (mod10 === 1 && mod100 !== 11) {
return `${count} участник`;
}
if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) {
return `${count} участника`;
}
return `${count} участников`;
}
export function shortID(id: string): string {
return id.length > 12 ? `${id.slice(0, 8)}…` : id;
}
export function initials(value: string): string {
const parts = value.trim().split(/\s+/).filter(Boolean);
if (parts.length === 0) {
return "?";
}
return parts
.slice(0, 2)
.map((part) => Array.from(part)[0]?.toUpperCase() ?? "")
.join("");
}
+19
View File
@@ -0,0 +1,19 @@
import { describe, expect, it, vi } from "vitest";
import { createIdempotencyKey } from "./idempotency";
describe("createIdempotencyKey", () => {
it("creates an API-compatible unique key", () => {
vi.stubGlobal("crypto", {
randomUUID: () => "12345678-1234-1234-1234-123456789abc",
});
const key = createIdempotencyKey();
expect(key).toMatch(/^[A-Za-z0-9._:-]{1,128}$/);
expect(key).toContain("12345678123412341234123456789abc");
expect(key.length).toBeLessThanOrEqual(128);
vi.unstubAllGlobals();
});
});
+4
View File
@@ -0,0 +1,4 @@
export function createIdempotencyKey(): string {
const random = crypto.randomUUID().replaceAll("-", "");
return `web-${Date.now().toString(36)}-${random}`;
}
+32
View File
@@ -0,0 +1,32 @@
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import { BrowserRouter } from "react-router-dom";
import { App } from "./app/App";
import { AuthProvider } from "./auth/AuthProvider";
import "./styles.css";
const queryClient = new QueryClient({
defaultOptions: {
queries: {
retry: 1,
refetchOnWindowFocus: true,
},
mutations: {
retry: false,
},
},
});
createRoot(document.getElementById("root")!).render(
<StrictMode>
<QueryClientProvider client={queryClient}>
<BrowserRouter>
<AuthProvider>
<App />
</AuthProvider>
</BrowserRouter>
</QueryClientProvider>
</StrictMode>,
);
+190
View File
@@ -0,0 +1,190 @@
import {
ArrowRight,
Eye,
EyeOff,
LockKeyhole,
MessageCircleMore,
UserRound,
} from "lucide-react";
import { useState, type FormEvent } from "react";
import { Link, useNavigate } from "react-router-dom";
import { ApiError } from "../api/client";
import { useAuth } from "../auth/AuthProvider";
type AuthMode = "login" | "register";
type AuthPageProps = {
initialMode: AuthMode;
};
function errorMessage(error: unknown): string {
if (error instanceof ApiError) {
if (error.status === 401) {
return "Неверный логин или пароль";
}
if (error.status === 409) {
return "Такой username уже занят";
}
return error.message;
}
return "Не удалось связаться с сервером. Попробуйте ещё раз.";
}
export function AuthPage({ initialMode }: AuthPageProps) {
const { login, register } = useAuth();
const navigate = useNavigate();
const [username, setUsername] = useState("");
const [displayName, setDisplayName] = useState("");
const [password, setPassword] = useState("");
const [showPassword, setShowPassword] = useState(false);
const [error, setError] = useState("");
const [isSubmitting, setIsSubmitting] = useState(false);
const isRegister = initialMode === "register";
async function submit(event: FormEvent<HTMLFormElement>) {
event.preventDefault();
setError("");
if (!/^[a-z0-9_]{3,32}$/.test(username)) {
setError("Username: 3–32 символа, только a–z, цифры и _");
return;
}
if (isRegister && displayName.trim().length === 0) {
setError("Укажите отображаемое имя");
return;
}
if (password.length < 12 || Array.from(password).length > 128) {
setError("Пароль должен содержать от 12 до 128 символов");
return;
}
setIsSubmitting(true);
try {
if (isRegister) {
await register({ username, displayName: displayName.trim(), password });
} else {
await login({ username, password });
}
navigate("/app", { replace: true });
} catch (submitError) {
setError(errorMessage(submitError));
} finally {
setIsSubmitting(false);
}
}
return (
<main className="auth-page">
<section className="auth-story" aria-label="О приложении">
<div className="auth-brand">
<div className="brand-mark" aria-hidden="true">
M
</div>
<span>MTUCI Messenger</span>
</div>
<div className="auth-copy">
<p className="eyebrow">Распределённый мессенджер</p>
<h1>Разговоры, которые остаются с вами.</h1>
<p>
Минималистичный клиент поверх отказоустойчивого Go API. Одна сессия,
несколько реплик, никаких лишних отвлечений.
</p>
<div className="auth-status">
<span className="status-dot" />
защищённая серверная сессия
</div>
</div>
</section>
<section className="auth-panel">
<div className="auth-card">
<MessageCircleMore className="auth-card__icon" aria-hidden="true" />
<p className="eyebrow">{isRegister ? "Новый аккаунт" : "С возвращением"}</p>
<h2>{isRegister ? "Создать профиль" : "Войти в Messenger"}</h2>
<p className="auth-card__lead">
{isRegister
? "Данные профиля можно будет расширить в следующих версиях."
: "Продолжите общение с того места, где остановились."}
</p>
<form className="auth-form" onSubmit={submit}>
{isRegister && (
<label>
<span>Отображаемое имя</span>
<div className="input-shell">
<UserRound aria-hidden="true" />
<input
autoComplete="name"
maxLength={100}
onChange={(event) => setDisplayName(event.target.value)}
placeholder="Как к вам обращаться"
required
value={displayName}
/>
</div>
</label>
)}
<label>
<span>Username</span>
<div className="input-shell">
<UserRound aria-hidden="true" />
<input
autoCapitalize="none"
autoComplete="username"
maxLength={32}
onChange={(event) => setUsername(event.target.value.toLowerCase())}
placeholder="username"
required
value={username}
/>
</div>
</label>
<label>
<span>Пароль</span>
<div className="input-shell">
<LockKeyhole aria-hidden="true" />
<input
autoComplete={isRegister ? "new-password" : "current-password"}
maxLength={128}
minLength={12}
onChange={(event) => setPassword(event.target.value)}
placeholder="Минимум 12 символов"
required
type={showPassword ? "text" : "password"}
value={password}
/>
<button
aria-label={showPassword ? "Скрыть пароль" : "Показать пароль"}
className="icon-button"
onClick={() => setShowPassword((value) => !value)}
type="button"
>
{showPassword ? <EyeOff /> : <Eye />}
</button>
</div>
</label>
{error && <div className="form-error" role="alert">{error}</div>}
<button className="primary-button" disabled={isSubmitting} type="submit">
<span>{isSubmitting ? "Подождите…" : isRegister ? "Создать аккаунт" : "Войти"}</span>
{!isSubmitting && <ArrowRight aria-hidden="true" />}
</button>
</form>
<p className="auth-switch">
{isRegister ? "Уже есть аккаунт?" : "Впервые здесь?"}{" "}
<Link to={isRegister ? "/login" : "/register"}>
{isRegister ? "Войти" : "Создать профиль"}
</Link>
</p>
</div>
</section>
</main>
);
}
+81
View File
@@ -0,0 +1,81 @@
import { useQuery } from "@tanstack/react-query";
import { useState } from "react";
import { useNavigate, useParams } from "react-router-dom";
import { api } from "../api/client";
import { useAuth } from "../auth/AuthProvider";
import { ChatList } from "../components/ChatList";
import { ChatView } from "../components/ChatView";
import { CreateChatDialog } from "../components/CreateChatDialog";
import { EmptyChat } from "../components/EmptyChat";
import { NavigationRail } from "../components/NavigationRail";
import { ProfileDrawer } from "../components/ProfileDrawer";
type MessengerPageProps = {
profileOpen?: boolean;
};
export function MessengerPage({ profileOpen = false }: MessengerPageProps) {
const { user } = useAuth();
const { chatId } = useParams();
const navigate = useNavigate();
const [createChatOpen, setCreateChatOpen] = useState(false);
const chatsQuery = useQuery({
queryKey: ["chats"],
queryFn: api.chats,
refetchInterval: 10_000,
staleTime: 5_000,
});
if (!user) {
return null;
}
const chats = chatsQuery.data ?? [];
const selectedChat = chatId
? chats.find((chat) => chat.id === chatId)
: undefined;
return (
<main
className={[
"messenger-shell",
chatId ? "messenger-shell--chat-open" : "",
profileOpen ? "messenger-shell--drawer-open" : "",
].join(" ")}
>
<NavigationRail profileOpen={profileOpen} user={user} />
<ChatList
chats={chats}
currentUser={user}
error={chatsQuery.isError}
isLoading={chatsQuery.isLoading}
onCreateChat={() => setCreateChatOpen(true)}
selectedChatID={chatId}
/>
{selectedChat ? (
<ChatView
chat={selectedChat}
currentUser={user}
onBack={() => navigate("/app")}
/>
) : (
<EmptyChat
hasChats={chats.length > 0}
onCreateChat={() => setCreateChatOpen(true)}
/>
)}
{profileOpen && <ProfileDrawer user={user} />}
{createChatOpen && (
<CreateChatDialog
currentUser={user}
onClose={() => setCreateChatOpen(false)}
/>
)}
</main>
);
}
File diff suppressed because it is too large Load Diff
+1
View File
@@ -0,0 +1 @@
/// <reference types="vite/client" />
+21
View File
@@ -0,0 +1,21 @@
{
"compilerOptions": {
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
"target": "ES2022",
"useDefineForClassFields": true,
"lib": ["ES2022", "DOM", "DOM.Iterable"],
"allowJs": false,
"skipLibCheck": true,
"esModuleInterop": true,
"allowSyntheticDefaultImports": true,
"strict": true,
"forceConsistentCasingInFileNames": true,
"module": "ESNext",
"moduleResolution": "Bundler",
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"jsx": "react-jsx"
},
"include": ["src"]
}
+7
View File
@@ -0,0 +1,7 @@
{
"files": [],
"references": [
{ "path": "./tsconfig.app.json" },
{ "path": "./tsconfig.node.json" }
]
}
+15
View File
@@ -0,0 +1,15 @@
{
"compilerOptions": {
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
"target": "ES2023",
"lib": ["ES2023"],
"module": "ESNext",
"skipLibCheck": true,
"moduleResolution": "Bundler",
"allowImportingTsExtensions": true,
"verbatimModuleSyntax": true,
"moduleDetection": "force",
"noEmit": true
},
"include": ["vite.config.ts"]
}
+23
View File
@@ -0,0 +1,23 @@
import { defineConfig } from "vitest/config";
import react from "@vitejs/plugin-react";
export default defineConfig({
plugins: [react()],
server: {
port: 5173,
strictPort: true,
proxy: {
"/api": "http://localhost:8080",
"/web-api": "http://localhost:8080",
"/health": "http://localhost:8080",
},
},
preview: {
port: 4173,
strictPort: true,
},
test: {
environment: "node",
include: ["src/**/*.test.ts"],
},
});
+39
View File
@@ -0,0 +1,39 @@
module mtusi2026lab5
go 1.27.1
require (
github.com/disintegration/imaging v1.6.2
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.11.0
github.com/mayahiro/go-webp v0.4.0
github.com/minio/minio-go/v7 v7.4.1
github.com/rabbitmq/amqp091-go v1.10.0
github.com/redis/go-redis/v9 v9.23.0
golang.org/x/crypto v0.57.0
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8
)
require (
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/klauspost/compress v1.19.2 // indirect
github.com/klauspost/cpuid/v2 v2.4.0 // indirect
github.com/klauspost/crc32 v1.3.0 // indirect
github.com/minio/crc64nvme v1.1.1 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/philhofer/fwd v1.2.0 // indirect
github.com/rs/xid v1.6.0 // indirect
github.com/tinylib/msgp v1.6.4 // indirect
github.com/zeebo/xxh3 v1.1.0 // indirect
go.uber.org/atomic v1.12.0 // indirect
go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/net v0.60.0 // indirect
golang.org/x/sync v0.23.0 // indirect
golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.42.0 // indirect
gopkg.in/ini.v1 v1.67.3 // indirect
)
+88
View File
@@ -0,0 +1,88 @@
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg=
github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8=
github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
github.com/klauspost/crc32 v1.3.0 h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM=
github.com/klauspost/crc32 v1.3.0/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw=
github.com/mayahiro/go-webp v0.4.0 h1:2uHEKvvSBREhAB7iDkYC/oZ4K9gbdigk63mLWPBugDQ=
github.com/mayahiro/go-webp v0.4.0/go.mod h1:Z1wt6V5/6f7pUwPsfhA6EbHb7ZhIcoQ7k7/tY9JNG4c=
github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI=
github.com/minio/crc64nvme v1.1.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg=
github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
github.com/minio/minio-go/v7 v7.4.1 h1:PtU/zIOfQRWZ+QydXAZysc+xZYHdG+BBR4Z6TUvy73w=
github.com/minio/minio-go/v7 v7.4.1/go.mod h1:nQnQi7zTfXR4lREtYXZQWqo5aw0Rqv+ZqCGrTORygRk=
github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM=
github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rabbitmq/amqp091-go v1.10.0 h1:STpn5XsHlHGcecLmMFCtg7mqq0RnD+zFr4uzukfVhBw=
github.com/rabbitmq/amqp091-go v1.10.0/go.mod h1:Hy4jKW5kQART1u+JkDTF9YYOQUHXqMuhrgxOEeS7G4o=
github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s=
github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0=
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
github.com/tinylib/msgp v1.6.4 h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ=
github.com/tinylib/msgp v1.6.4/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA=
github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE=
go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8 h1:hVwzHzIUGRjiF7EcUjqNxk3NCfkPxbDKRdnNE1Rpg0U=
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU=
golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/ini.v1 v1.67.3 h1:iM9Lhz5MRSGhHVGGwCuzG9KO8PoirCXj/m/qTmOJJQw=
gopkg.in/ini.v1 v1.67.3/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+7
View File
@@ -0,0 +1,7 @@
FROM haproxy:3.2-alpine@sha256:dfba86f031bd4c9039f10f8cc5de75991d1b6766d5460f0335b980408503baad
COPY infrastructure/haproxy/haproxy.cfg /usr/local/etc/haproxy/haproxy.cfg
USER haproxy
EXPOSE 8080
+66
View File
@@ -0,0 +1,66 @@
global
log stdout format raw local0
maxconn 2048
defaults
log global
mode http
option httplog
timeout connect 1s
timeout client 30s
timeout server 30s
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 1s
hold other 1s
hold refused 1s
hold nx 1s
hold timeout 1s
hold obsolete 1s
frontend public
bind :8080
acl api_request path_beg /api/ /web-api/ /health/
acl web_api path_beg /web-api/
acl has_session req.cook(mtusi_session) -m found
acl message_create method POST
acl message_path path_reg ^/(api|web-api)/v1/chats/[^/]+/messages$
http-request del-header Authorization if web_api
http-request set-header Authorization "Bearer %[req.cook(mtusi_session)]" if web_api has_session
http-request del-header Cookie if api_request
http-request replace-path ^/web-api/(.*)$ /api/\1 if web_api
use_backend message_backend if message_create message_path
use_backend api_backend if api_request
default_backend frontend_backend
backend api_backend
balance leastconn
option httpchk
http-check send meth GET uri /health/lb ver HTTP/1.1 hdr Host api
http-check expect status 200
default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 resolvers docker init-addr libc,none
server-template api 8 api:8080
backend message_backend
balance leastconn
option httpchk
option redispatch
option http-buffer-request
retries 3
retry-on conn-failure empty-response response-timeout 502 503 504
http-check send meth GET uri /health/lb ver HTTP/1.1 hdr Host api
http-check expect status 200
default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 resolvers docker init-addr libc,none
server-template api 8 api:8080
backend frontend_backend
option httpchk GET /
http-check expect status 200
server frontend frontend:8080 check inter 2s fall 2 rise 2 resolvers docker init-addr libc,none
+40
View File
@@ -0,0 +1,40 @@
FROM golang:1.27.1-alpine@sha256:8a5910f31396cd4d89662f56c68b3ae31d374308270a1c3bd96672ee5ed43414 AS minio-builder
ARG MINIO_VERSION=RELEASE.2025-10-15T17-29-55Z
RUN CGO_ENABLED=0 GOBIN=/out go install github.com/minio/minio@${MINIO_VERSION}
FROM golang:1.27.1-alpine@sha256:8a5910f31396cd4d89662f56c68b3ae31d374308270a1c3bd96672ee5ed43414 AS mc-builder
ARG MC_VERSION=RELEASE.2025-08-13T08-35-41Z
RUN CGO_ENABLED=0 GOBIN=/out go install github.com/minio/mc@${MC_VERSION}
FROM alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6 AS server
RUN apk add --no-cache ca-certificates wget && \
addgroup -g 1000 minio && \
adduser -u 1000 -G minio -s /sbin/nologin -D minio && \
mkdir -p /data && \
chown minio:minio /data
COPY --from=minio-builder /out/minio /usr/local/bin/minio
USER minio:minio
VOLUME ["/data"]
EXPOSE 9000
HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=20 \
CMD wget -qO- http://127.0.0.1:9000/minio/health/live >/dev/null || exit 1
ENTRYPOINT ["/usr/local/bin/minio"]
CMD ["server", "/data", "--address", ":9000"]
FROM alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6 AS client
RUN apk add --no-cache ca-certificates && \
addgroup -g 1000 minio && \
adduser -u 1000 -G minio -s /sbin/nologin -D minio
COPY --from=mc-builder /out/mc /usr/local/bin/mc
USER minio:minio
ENTRYPOINT ["/usr/local/bin/mc"]
@@ -0,0 +1,26 @@
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::__BUCKET__"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::__BUCKET__/*"
]
}
]
}
+15
View File
@@ -0,0 +1,15 @@
FROM node:24-alpine@sha256:44fce696f38ba8c987c4db89954051000bbd05ffd8d8659ba15ed4a8602e937f AS frontend-build
WORKDIR /frontend
COPY frontend/package.json frontend/package-lock.json ./
RUN npm ci
COPY frontend/ ./
RUN npm test && npm run build
FROM nginx:1.30.6-alpine@sha256:970364228b1e4f932abc22d321932816782cca8a20b85a77552a7cfe9acfb3b5
COPY infrastructure/nginx/nginx.conf /etc/nginx/nginx.conf
COPY --from=frontend-build /frontend/dist /usr/share/nginx/html
EXPOSE 8080
+32
View File
@@ -0,0 +1,32 @@
worker_processes auto;
events {
worker_connections 512;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
server {
listen 8080;
server_name _;
root /usr/share/nginx/html;
index index.html;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "no-referrer" always;
add_header X-Frame-Options "DENY" always;
add_header Content-Security-Policy "default-src 'self'; img-src 'self' data:; style-src 'self'; script-src 'self'; connect-src 'self'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'" always;
location /assets/ {
try_files $uri =404;
expires 1y;
add_header Cache-Control "public, immutable";
}
location / {
try_files $uri $uri/ /index.html;
}
}
}
+119
View File
@@ -0,0 +1,119 @@
package broker
import (
"context"
"encoding/json"
"fmt"
"sync"
"time"
"mtusi2026lab5/internal/domain"
amqp "github.com/rabbitmq/amqp091-go"
)
const QueueName = "attachment.process.v1"
type RabbitMQ struct {
connection *amqp.Connection
channel *amqp.Channel
confirms <-chan amqp.Confirmation
publishMu sync.Mutex
}
func Open(url string, prefetch int) (*RabbitMQ, error) {
if url == "" {
return nil, fmt.Errorf("broker URL is required")
}
connection, err := amqp.DialConfig(url, amqp.Config{Heartbeat: 10 * time.Second, Locale: "en_US"})
if err != nil {
return nil, fmt.Errorf("connect RabbitMQ: %w", err)
}
channel, err := connection.Channel()
if err != nil {
_ = connection.Close()
return nil, fmt.Errorf("open RabbitMQ channel: %w", err)
}
if _, err = channel.QueueDeclare(QueueName, true, false, false, false, nil); err != nil {
_ = channel.Close()
_ = connection.Close()
return nil, fmt.Errorf("declare RabbitMQ queue: %w", err)
}
if prefetch > 0 {
if err = channel.Qos(prefetch, 0, false); err != nil {
_ = channel.Close()
_ = connection.Close()
return nil, fmt.Errorf("set RabbitMQ prefetch: %w", err)
}
}
client := &RabbitMQ{connection: connection, channel: channel}
if err = channel.Confirm(false); err != nil {
client.Close()
return nil, fmt.Errorf("enable RabbitMQ publisher confirms: %w", err)
}
client.confirms = channel.NotifyPublish(make(chan amqp.Confirmation, 1))
return client, nil
}
func (client *RabbitMQ) Publish(ctx context.Context, job domain.AttachmentJob) error {
body, err := json.Marshal(job.Message())
if err != nil {
return fmt.Errorf("encode attachment job: %w", err)
}
client.publishMu.Lock()
defer client.publishMu.Unlock()
if err = client.channel.PublishWithContext(ctx, "", QueueName, false, false, amqp.Publishing{
DeliveryMode: amqp.Persistent,
ContentType: "application/json",
Type: domain.AttachmentJobType,
MessageId: job.JobID,
Timestamp: time.Now().UTC(),
Body: body,
}); err != nil {
return fmt.Errorf("publish attachment job: %w", err)
}
select {
case confirmation, ok := <-client.confirms:
if !ok {
return fmt.Errorf("publisher confirm channel closed")
}
if !confirmation.Ack {
return fmt.Errorf("broker rejected attachment job")
}
return nil
case <-ctx.Done():
return fmt.Errorf("wait for publisher confirm: %w", ctx.Err())
}
}
func (client *RabbitMQ) Consume(consumerName string) (<-chan amqp.Delivery, error) {
deliveries, err := client.channel.Consume(QueueName, consumerName, false, false, false, false, nil)
if err != nil {
return nil, fmt.Errorf("consume attachment jobs: %w", err)
}
return deliveries, nil
}
func Decode(delivery amqp.Delivery) (domain.AttachmentJobMessage, error) {
var message domain.AttachmentJobMessage
if err := json.Unmarshal(delivery.Body, &message); err != nil {
return message, fmt.Errorf("decode attachment job: %w", err)
}
if message.SchemaVersion != 1 || message.Type != domain.AttachmentJobType || message.JobID == "" || message.AttachmentID == "" || message.PipelineVersion < 1 || message.Attempt < 1 {
return message, fmt.Errorf("attachment job has invalid required fields")
}
return message, nil
}
func (client *RabbitMQ) Close() error {
if client == nil {
return nil
}
if client.channel != nil {
_ = client.channel.Close()
}
if client.connection != nil {
return client.connection.Close()
}
return nil
}
+110
View File
@@ -0,0 +1,110 @@
package cache
import (
"context"
"errors"
"log"
"mtusi2026lab5/internal/adapter/redis"
"mtusi2026lab5/internal/application"
"mtusi2026lab5/internal/domain"
)
// CachedRepository декорирует основной Repository. Все операции, кроме чтения
// и создания чата, автоматически делегируются встроенному Repository.
type CachedRepository struct {
application.Repository
chatCache redis.ChatCache
logger *log.Logger
}
func NewCachedRepository(
repository application.Repository,
chatCache redis.ChatCache,
logger *log.Logger,
) *CachedRepository {
if logger == nil {
logger = log.Default()
}
return &CachedRepository{
Repository: repository,
chatCache: chatCache,
logger: logger,
}
}
func (r *CachedRepository) CreateQueuedAttachment(
ctx context.Context,
attachment domain.Attachment,
job domain.AttachmentJob,
) (domain.Attachment, error) {
queueRepository, ok := r.Repository.(application.AttachmentQueueRepository)
if !ok {
return domain.Attachment{}, errors.New("attachment queue repository is not configured")
}
return queueRepository.CreateQueuedAttachment(ctx, attachment, job)
}
func (r *CachedRepository) CreateChat(
ctx context.Context,
title string,
memberIDs []string,
) (domain.Chat, error) {
chat, err := r.Repository.CreateChat(ctx, title, memberIDs)
if err != nil {
return domain.Chat{}, err
}
// Запись в PostgreSQL уже подтверждена. Ошибка необязательного кэша не
// должна превращать успешную бизнес-операцию в 503.
if err = r.chatCache.Set(ctx, chat); err != nil {
r.logger.Printf("[WARN] Redis chat cache write failed: %v", err)
}
return chat, nil
}
func (r *CachedRepository) GetChatByID(
ctx context.Context,
chatID string,
callerID string,
) (domain.Chat, error) {
chat, err := r.chatCache.Get(ctx, chatID)
if err == nil {
if !containsMember(chat.MemberIDs, callerID) {
return domain.Chat{}, domain.ErrNotFound
}
return chat, nil
}
shouldFillCache := errors.Is(err, redis.ErrMiss)
if !shouldFillCache {
r.logger.Printf("[WARN] Redis chat cache read failed: %v", err)
}
chat, err = r.Repository.GetChatByID(ctx, chatID, callerID)
if err != nil {
return domain.Chat{}, err
}
if shouldFillCache {
if err = r.chatCache.Set(ctx, chat); err != nil {
r.logger.Printf("[WARN] Redis chat cache fill failed: %v", err)
}
}
return chat, nil
}
func containsMember(memberIDs []string, callerID string) bool {
for _, memberID := range memberIDs {
if memberID == callerID {
return true
}
}
return false
}
var _ application.Repository = (*CachedRepository)(nil)
+183
View File
@@ -0,0 +1,183 @@
package cache
import (
"context"
"errors"
"io"
"log"
"testing"
"mtusi2026lab5/internal/adapter/memory"
"mtusi2026lab5/internal/adapter/redis"
"mtusi2026lab5/internal/application"
"mtusi2026lab5/internal/domain"
)
type fakeChatCache struct {
chats map[string]domain.Chat
getErr error
setErr error
sets int
}
func (c *fakeChatCache) Get(
_ context.Context,
chatID string,
) (domain.Chat, error) {
if c.getErr != nil {
return domain.Chat{}, c.getErr
}
chat, exists := c.chats[chatID]
if !exists {
return domain.Chat{}, redis.ErrMiss
}
return chat, nil
}
func (c *fakeChatCache) Set(
_ context.Context,
chat domain.Chat,
) error {
c.sets++
if c.setErr != nil {
return c.setErr
}
c.chats[chat.ID] = chat
return nil
}
type countingRepository struct {
application.Repository
getChatCalls int
}
func (r *countingRepository) GetChatByID(
ctx context.Context,
chatID string,
callerID string,
) (domain.Chat, error) {
r.getChatCalls++
return r.Repository.GetChatByID(ctx, chatID, callerID)
}
func cachedRepositoryFixture(
t *testing.T,
) (*countingRepository, *fakeChatCache, domain.User, domain.User, domain.Chat) {
t.Helper()
legacy := memory.NewMemoryStore()
member, err := legacy.CreateUser("cache_member", "Участник")
if err != nil {
t.Fatalf("create member: %v", err)
}
outsider, err := legacy.CreateUser("cache_outsider", "Посторонний")
if err != nil {
t.Fatalf("create outsider: %v", err)
}
chat, err := legacy.CreateChat("Кешируемый чат", []string{member.ID})
if err != nil {
t.Fatalf("create chat: %v", err)
}
repository := &countingRepository{
Repository: memory.NewMemoryRepository(legacy),
}
chatCache := &fakeChatCache{
chats: make(map[string]domain.Chat),
}
return repository, chatCache, member, outsider, chat
}
func TestCachedRepositoryMissThenHit(t *testing.T) {
repository, chatCache, member, _, expected := cachedRepositoryFixture(t)
cached := NewCachedRepository(
repository,
chatCache,
log.New(io.Discard, "", 0),
)
first, err := cached.GetChatByID(context.Background(), expected.ID, member.ID)
if err != nil {
t.Fatalf("first read: %v", err)
}
second, err := cached.GetChatByID(context.Background(), expected.ID, member.ID)
if err != nil {
t.Fatalf("second read: %v", err)
}
if repository.getChatCalls != 1 {
t.Fatalf("expected one source read, got %d", repository.getChatCalls)
}
if chatCache.sets != 1 {
t.Fatalf("expected one cache fill, got %d", chatCache.sets)
}
if first.ID != expected.ID || second.ID != expected.ID {
t.Fatal("cache changed chat identity")
}
}
func TestCachedRepositoryFallsBackWhenCacheUnavailable(t *testing.T) {
repository, chatCache, member, _, expected := cachedRepositoryFixture(t)
chatCache.getErr = errors.New("redis unavailable")
chatCache.setErr = errors.New("redis unavailable")
cached := NewCachedRepository(
repository,
chatCache,
log.New(io.Discard, "", 0),
)
chat, err := cached.GetChatByID(context.Background(), expected.ID, member.ID)
if err != nil {
t.Fatalf("fallback read: %v", err)
}
if chat.ID != expected.ID || repository.getChatCalls != 1 {
t.Fatal("source repository was not used after cache failure")
}
if chatCache.sets != 0 {
t.Fatal("failed cache read must not trigger another cache operation")
}
}
func TestCachedRepositoryChecksMembershipOnHit(t *testing.T) {
repository, chatCache, _, outsider, expected := cachedRepositoryFixture(t)
chatCache.chats[expected.ID] = expected
cached := NewCachedRepository(
repository,
chatCache,
log.New(io.Discard, "", 0),
)
_, err := cached.GetChatByID(context.Background(), expected.ID, outsider.ID)
if !errors.Is(err, domain.ErrNotFound) {
t.Fatalf("expected ErrNotFound for outsider, got %v", err)
}
if repository.getChatCalls != 0 {
t.Fatal("cache hit unexpectedly queried source repository")
}
}
func TestCachedRepositoryIgnoresWriteFailure(t *testing.T) {
repository, chatCache, member, _, _ := cachedRepositoryFixture(t)
chatCache.setErr = errors.New("redis unavailable")
cached := NewCachedRepository(
repository,
chatCache,
log.New(io.Discard, "", 0),
)
chat, err := cached.CreateChat(
context.Background(),
"Новый чат",
[]string{member.ID},
)
if err != nil {
t.Fatalf("create chat with unavailable cache: %v", err)
}
if chat.ID == "" || chatCache.sets != 1 {
t.Fatal("chat was not created before best-effort cache write")
}
}
+33
View File
@@ -0,0 +1,33 @@
package health
import (
"context"
"fmt"
)
type Checker interface {
Ping(ctx context.Context) error
}
type MultiChecker struct {
checkers []Checker
}
func NewMultiChecker(checkers ...Checker) *MultiChecker {
filtered := make([]Checker, 0, len(checkers))
for _, checker := range checkers {
if checker != nil {
filtered = append(filtered, checker)
}
}
return &MultiChecker{checkers: filtered}
}
func (checker *MultiChecker) Ping(ctx context.Context) error {
for index, dependency := range checker.checkers {
if err := dependency.Ping(ctx); err != nil {
return fmt.Errorf("dependency %d: %w", index, err)
}
}
return nil
}
+8
View File
@@ -0,0 +1,8 @@
package memory
import "mtusi2026lab5/internal/domain"
var (
ErrNotFound = domain.ErrNotFound
ErrConflict = domain.ErrConflict
)
+384
View File
@@ -0,0 +1,384 @@
package memory
import (
"context"
"fmt"
"sync"
"time"
"mtusi2026lab5/internal/application"
"mtusi2026lab5/internal/domain"
)
type memorySession struct {
userID string
expiresAt time.Time
}
type memoryIdempotencyScope struct {
actorID string
method string
canonicalPath string
key string
}
type memoryIdempotencyResult struct {
requestHash [32]byte
message domain.Message
expiresAt time.Time
}
type MemoryRepository struct {
legacy *MemoryStore
mu sync.RWMutex
passwordByUserID map[string]string
userIDByUsername map[string]string
sessionsByHashKey map[[32]byte]memorySession
idempotencyByScope map[memoryIdempotencyScope]memoryIdempotencyResult
}
func NewMemoryRepository(legacy *MemoryStore) *MemoryRepository {
return &MemoryRepository{
legacy: legacy,
passwordByUserID: make(map[string]string),
userIDByUsername: make(map[string]string),
sessionsByHashKey: make(map[[32]byte]memorySession),
idempotencyByScope: make(map[memoryIdempotencyScope]memoryIdempotencyResult),
}
}
func (r *MemoryRepository) CreateUser(
ctx context.Context,
username string,
displayName string,
passwordHash string,
) (domain.User, error) {
if err := ctx.Err(); err != nil {
return domain.User{}, err
}
user, err := r.legacy.CreateUser(username, displayName)
if err != nil {
return domain.User{}, err
}
r.mu.Lock()
r.passwordByUserID[user.ID] = passwordHash
r.userIDByUsername[user.Username] = user.ID
r.mu.Unlock()
return user, nil
}
func (r *MemoryRepository) GetUserByID(
ctx context.Context,
userID string,
) (domain.User, error) {
if err := ctx.Err(); err != nil {
return domain.User{}, err
}
return r.legacy.GetUserByID(userID)
}
func (r *MemoryRepository) GetUserByUsername(
ctx context.Context,
username string,
) (domain.User, string, error) {
if err := ctx.Err(); err != nil {
return domain.User{}, "", err
}
r.mu.RLock()
userID, exists := r.userIDByUsername[username]
passwordHash := r.passwordByUserID[userID]
r.mu.RUnlock()
if !exists {
return domain.User{}, "", ErrNotFound
}
user, err := r.legacy.GetUserByID(userID)
if err != nil {
return domain.User{}, "", err
}
return user, passwordHash, nil
}
func (r *MemoryRepository) CreateChat(
ctx context.Context,
title string,
memberIDs []string,
) (domain.Chat, error) {
if err := ctx.Err(); err != nil {
return domain.Chat{}, err
}
return r.legacy.CreateChat(title, memberIDs)
}
func (r *MemoryRepository) GetChatByID(
ctx context.Context,
chatID string,
callerID string,
) (domain.Chat, error) {
if err := ctx.Err(); err != nil {
return domain.Chat{}, err
}
return r.legacy.GetChatByID(chatID, callerID)
}
func (r *MemoryRepository) GetChatsForUser(
ctx context.Context,
userID string,
limit int,
cursor *domain.ChatCursor,
) ([]domain.Chat, bool, error) {
if err := ctx.Err(); err != nil {
return nil, false, err
}
return r.legacy.GetChatsForUser(userID, limit, cursor)
}
func (r *MemoryRepository) CreateMessageIdempotently(
ctx context.Context,
write application.IdempotentMessageWrite,
) (domain.Message, error) {
if err := ctx.Err(); err != nil {
return domain.Message{}, err
}
scope := memoryIdempotencyScope{
actorID: write.ActorID,
method: write.Method,
canonicalPath: write.CanonicalPath,
key: write.Key,
}
now := time.Now().UTC()
r.mu.Lock()
defer r.mu.Unlock()
if _, err := r.legacy.GetChatByID(write.ChatID, write.ActorID); err != nil {
return domain.Message{}, err
}
for _, attachmentID := range write.AttachmentIDs {
attachment, err := r.legacy.GetAttachmentByID(attachmentID)
if err != nil || attachment.ChatID != write.ChatID {
return domain.Message{}, ErrNotFound
}
if attachment.Status != domain.AttachmentStatusReady {
return domain.Message{}, application.ErrAttachmentNotReady
}
}
if stored, exists := r.idempotencyByScope[scope]; exists {
if stored.expiresAt.After(now) {
if stored.requestHash != write.RequestHash {
return domain.Message{}, application.ErrIdempotencyConflict
}
return stored.message, nil
}
delete(r.idempotencyByScope, scope)
}
message, err := r.legacy.CreateMessage(
write.ChatID,
write.ActorID,
write.Text,
write.AttachmentIDs,
)
if err != nil {
return domain.Message{}, err
}
r.idempotencyByScope[scope] = memoryIdempotencyResult{
requestHash: write.RequestHash,
message: message,
expiresAt: now.Add(write.TTL),
}
return message, nil
}
func (r *MemoryRepository) GetMessages(
ctx context.Context,
chatID string,
callerID string,
limit int,
cursor *domain.MessageCursor,
) ([]domain.Message, bool, error) {
if err := ctx.Err(); err != nil {
return nil, false, err
}
return r.legacy.GetMessages(
chatID,
callerID,
limit,
cursor,
)
}
func (r *MemoryRepository) CreateSession(
ctx context.Context,
tokenHash []byte,
userID string,
expiresAt time.Time,
) error {
if err := ctx.Err(); err != nil {
return err
}
key, err := memoryTokenHashKey(tokenHash)
if err != nil {
return err
}
r.mu.Lock()
r.sessionsByHashKey[key] = memorySession{
userID: userID,
expiresAt: expiresAt,
}
r.mu.Unlock()
return nil
}
func (r *MemoryRepository) GetUserBySession(
ctx context.Context,
tokenHash []byte,
) (domain.User, error) {
if err := ctx.Err(); err != nil {
return domain.User{}, err
}
key, err := memoryTokenHashKey(tokenHash)
if err != nil {
return domain.User{}, ErrNotFound
}
r.mu.RLock()
session, exists := r.sessionsByHashKey[key]
r.mu.RUnlock()
if !exists || !session.expiresAt.After(time.Now().UTC()) {
return domain.User{}, ErrNotFound
}
return r.legacy.GetUserByID(session.userID)
}
func (r *MemoryRepository) DeleteSession(
ctx context.Context,
tokenHash []byte,
) error {
if err := ctx.Err(); err != nil {
return err
}
key, err := memoryTokenHashKey(tokenHash)
if err != nil {
return err
}
r.mu.Lock()
delete(r.sessionsByHashKey, key)
r.mu.Unlock()
return nil
}
func (r *MemoryRepository) CreateQueuedAttachment(
ctx context.Context,
attachment domain.Attachment,
_ domain.AttachmentJob,
) (domain.Attachment, error) {
return r.CreateAttachment(ctx, attachment)
}
func (r *MemoryRepository) CreateAttachment(
ctx context.Context,
attachment domain.Attachment,
) (domain.Attachment, error) {
if err := ctx.Err(); err != nil {
return domain.Attachment{}, err
}
if err := r.legacy.PutAttachment(attachment); err != nil {
return domain.Attachment{}, err
}
return attachment, nil
}
func (r *MemoryRepository) MarkAttachmentReady(
ctx context.Context,
attachmentID string,
updatedAt time.Time,
) (domain.Attachment, error) {
if err := ctx.Err(); err != nil {
return domain.Attachment{}, err
}
return r.legacy.UpdateAttachmentStatus(
attachmentID,
domain.AttachmentStatusReady,
nil,
updatedAt,
)
}
func (r *MemoryRepository) MarkAttachmentFailed(
ctx context.Context,
attachmentID string,
errorCode string,
updatedAt time.Time,
) error {
if err := ctx.Err(); err != nil {
return err
}
_, err := r.legacy.UpdateAttachmentStatus(
attachmentID,
domain.AttachmentStatusFailed,
&errorCode,
updatedAt,
)
return err
}
func (r *MemoryRepository) GetAttachment(
ctx context.Context,
attachmentID string,
callerID string,
) (domain.Attachment, error) {
if err := ctx.Err(); err != nil {
return domain.Attachment{}, err
}
attachment, err := r.legacy.GetAttachmentByID(attachmentID)
if err != nil {
return domain.Attachment{}, err
}
if _, err = r.legacy.GetChatByID(attachment.ChatID, callerID); err != nil {
return domain.Attachment{}, err
}
if attachment.Variants == nil {
attachment.Variants = make([]domain.AttachmentVariant, 0)
}
return attachment, nil
}
func memoryTokenHashKey(tokenHash []byte) ([32]byte, error) {
var key [32]byte
if len(tokenHash) != len(key) {
return key, fmt.Errorf(
"session token hash must contain %d bytes",
len(key),
)
}
copy(key[:], tokenHash)
return key, nil
}
var _ application.Repository = (*MemoryRepository)(nil)
+371
View File
@@ -0,0 +1,371 @@
package memory
import (
"fmt"
"sort"
"sync"
"time"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
)
type MemoryStore struct {
mu sync.RWMutex
usersByID map[string]domain.User //key = user UUID
usersByUsername map[string]string //key = username для быстрой проверки уникальности
chatsByID map[string]domain.Chat //key = chat UUID
messagesByChatID map[string][]domain.Message // key = chat UUID, value = слайс сообщений
attachmentsByID map[string]domain.Attachment
}
func NewMemoryStore() *MemoryStore {
return &MemoryStore{
usersByID: make(map[string]domain.User),
usersByUsername: make(map[string]string),
chatsByID: make(map[string]domain.Chat),
messagesByChatID: make(map[string][]domain.Message),
attachmentsByID: make(map[string]domain.Attachment),
}
}
// ---пользователи---
func (s *MemoryStore) CreateUser(username, displayName string) (domain.User, error) {
s.mu.Lock()
defer s.mu.Unlock()
// дубликат username -> 409 Conflict
if _, exists := s.usersByUsername[username]; exists {
return domain.User{}, ErrConflict
}
user := domain.User{
ID: uuid.NewString(),
Username: username,
DisplayName: displayName,
CreatedAt: time.Now().UTC(),
}
s.usersByID[user.ID] = user
s.usersByUsername[user.Username] = user.ID
return user, nil
}
func (s *MemoryStore) GetUserByID(id string) (domain.User, error) {
s.mu.RLock()
defer s.mu.RUnlock()
user, exists := s.usersByID[id]
if !exists {
return domain.User{}, ErrNotFound
}
return user, nil
}
// ---чаты---
func (s *MemoryStore) CreateChat(title string, memberIDs []string) (domain.Chat, error) {
s.mu.Lock()
defer s.mu.Unlock()
//все участники рил существуют
for _, memberID := range memberIDs {
if _, exists := s.usersByID[memberID]; !exists {
return domain.Chat{}, fmt.Errorf(
"%w: member %s",
ErrNotFound,
memberID,
)
}
}
chat := domain.Chat{
ID: uuid.NewString(),
Title: title,
MemberIDs: append([]string(nil), memberIDs...), //копирую слайс для изоляции
CreatedAt: time.Now().UTC(),
}
s.chatsByID[chat.ID] = chat
s.messagesByChatID[chat.ID] = make([]domain.Message, 0)
return chat, nil
}
func (s *MemoryStore) GetChatByID(chatID, callerID string) (domain.Chat, error) {
s.mu.RLock()
defer s.mu.RUnlock()
chat, exists := s.chatsByID[chatID]
if !exists {
return domain.Chat{}, ErrNotFound
}
// Требование безопасности: посторонний получает 404, а не 403
isMember := false
for _, m := range chat.MemberIDs {
if m == callerID {
isMember = true
break
}
}
if !isMember {
return domain.Chat{}, ErrNotFound
}
return chat, nil
}
func (s *MemoryStore) GetChatsForUser(
userID string,
limit int,
cursorData *domain.ChatCursor,
) ([]domain.Chat, bool, error) {
s.mu.RLock()
defer s.mu.RUnlock()
chats := make([]domain.Chat, 0)
for _, chat := range s.chatsByID {
for _, memberID := range chat.MemberIDs {
if memberID == userID {
chats = append(chats, chat)
break
}
}
}
sort.Slice(chats, func(i, j int) bool {
if chats[i].CreatedAt.Equal(chats[j].CreatedAt) {
return chats[i].ID < chats[j].ID
}
return chats[i].CreatedAt.Before(chats[j].CreatedAt)
})
start := 0
if cursorData != nil {
start = sort.Search(len(chats), func(index int) bool {
chat := chats[index]
if chat.CreatedAt.After(cursorData.CreatedAt) {
return true
}
return chat.CreatedAt.Equal(cursorData.CreatedAt) &&
chat.ID > cursorData.ChatID
})
}
if start >= len(chats) {
return make([]domain.Chat, 0), false, nil
}
end := start + limit
if end > len(chats) {
end = len(chats)
}
items := make([]domain.Chat, end-start)
copy(items, chats[start:end])
return items, end < len(chats), nil
}
// PutAttachment stores metadata for adapter and application tests. Binary
// content intentionally does not belong to this in-memory metadata store.
func (s *MemoryStore) PutAttachment(attachment domain.Attachment) error {
s.mu.Lock()
defer s.mu.Unlock()
if _, exists := s.attachmentsByID[attachment.ID]; exists {
return ErrConflict
}
chat, exists := s.chatsByID[attachment.ChatID]
if !exists {
return ErrNotFound
}
ownerIsMember := false
for _, memberID := range chat.MemberIDs {
if memberID == attachment.OwnerID {
ownerIsMember = true
break
}
}
if !ownerIsMember {
return ErrNotFound
}
s.attachmentsByID[attachment.ID] = attachment
return nil
}
func (s *MemoryStore) GetAttachmentByID(
attachmentID string,
) (domain.Attachment, error) {
s.mu.RLock()
defer s.mu.RUnlock()
attachment, exists := s.attachmentsByID[attachmentID]
if !exists {
return domain.Attachment{}, ErrNotFound
}
return attachment, nil
}
func (s *MemoryStore) UpdateAttachmentStatus(
attachmentID string,
status domain.AttachmentStatus,
errorCode *string,
updatedAt time.Time,
) (domain.Attachment, error) {
s.mu.Lock()
defer s.mu.Unlock()
attachment, exists := s.attachmentsByID[attachmentID]
if !exists {
return domain.Attachment{}, ErrNotFound
}
if attachment.Status != domain.AttachmentStatusPending {
return domain.Attachment{}, ErrConflict
}
attachment.Status = status
attachment.ErrorCode = errorCode
attachment.UpdatedAt = updatedAt
if attachment.Variants == nil {
attachment.Variants = make([]domain.AttachmentVariant, 0)
}
s.attachmentsByID[attachmentID] = attachment
return attachment, nil
}
// ---Сообщения---
func (s *MemoryStore) CreateMessage(
chatID, senderID, text string,
attachmentLists ...[]string,
) (domain.Message, error) {
messageID := uuid.NewString()
attachmentIDs := make([]string, 0)
if len(attachmentLists) > 0 {
attachmentIDs = append(attachmentIDs, attachmentLists[0]...)
}
s.mu.Lock()
defer s.mu.Unlock()
chat, exists := s.chatsByID[chatID]
if !exists {
return domain.Message{}, ErrNotFound
}
isMember := false
for _, memberID := range chat.MemberIDs {
if memberID == senderID {
isMember = true
break
}
}
if !isMember {
return domain.Message{}, ErrNotFound
}
createdAt := time.Now().UTC()
messages := s.messagesByChatID[chatID]
if len(messages) > 0 {
lastCreatedAt := messages[len(messages)-1].CreatedAt
// Обеспечиваем строго возрастающее время внутри каждого чата.
if !createdAt.After(lastCreatedAt) {
createdAt = lastCreatedAt.Add(time.Nanosecond)
}
}
message := domain.Message{
ID: messageID,
ChatID: chatID,
SenderID: senderID,
Text: text,
AttachmentIDs: attachmentIDs,
CreatedAt: createdAt,
}
s.messagesByChatID[chatID] = append(messages, message)
return message, nil
}
func (s *MemoryStore) GetMessages(
chatID, callerID string,
limit int,
cursorData *domain.MessageCursor,
) ([]domain.Message, bool, error) {
s.mu.RLock()
defer s.mu.RUnlock()
chat, exists := s.chatsByID[chatID]
if !exists {
return nil, false, ErrNotFound
}
isMember := false
for _, memberID := range chat.MemberIDs {
if memberID == callerID {
isMember = true
break
}
}
if !isMember {
return nil, false, ErrNotFound
}
messages := s.messagesByChatID[chatID]
start := 0
if cursorData != nil {
// Срез уже упорядочен во время записи, поэтому вместо
// полного прохода используем бинарный поиск.
start = sort.Search(len(messages), func(index int) bool {
message := messages[index]
if message.CreatedAt.After(cursorData.CreatedAt) {
return true
}
return message.CreatedAt.Equal(cursorData.CreatedAt) &&
message.ID > cursorData.MessageID
})
}
if start >= len(messages) {
return make([]domain.Message, 0), false, nil
}
end := len(messages)
if limit > 0 && end-start > limit {
end = start + limit
}
// копируем только возвращаемую страницу, а не всю историю, изменяя внутренний срез
items := make([]domain.Message, end-start)
for index, message := range messages[start:end] {
message.AttachmentIDs = append(
make([]string, 0, len(message.AttachmentIDs)),
message.AttachmentIDs...,
)
items[index] = message
}
return items, end < len(messages), nil
}
+201
View File
@@ -0,0 +1,201 @@
package objectstore
import (
"bytes"
"context"
"fmt"
"io"
"net/url"
"strings"
"time"
"mtusi2026lab5/internal/application"
minio "github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
type MinIOStore struct {
client *minio.Client
bucket string
operationTimeout time.Duration
}
type StoredObject struct {
Key string
SizeBytes int64
LastModified time.Time
}
func NewMinIOStore(
endpoint string,
region string,
bucket string,
accessKeyID string,
secretAccessKey string,
operationTimeout time.Duration,
) (*MinIOStore, error) {
parsedEndpoint, err := url.Parse(endpoint)
if err != nil || parsedEndpoint.Host == "" {
return nil, fmt.Errorf("S3 endpoint must be an absolute HTTP(S) URL")
}
if parsedEndpoint.Scheme != "http" && parsedEndpoint.Scheme != "https" {
return nil, fmt.Errorf("S3 endpoint scheme must be http or https")
}
if parsedEndpoint.Path != "" && parsedEndpoint.Path != "/" {
return nil, fmt.Errorf("S3 endpoint must not contain a path")
}
if parsedEndpoint.RawQuery != "" || parsedEndpoint.Fragment != "" || parsedEndpoint.User != nil {
return nil, fmt.Errorf("S3 endpoint must not contain credentials, query or fragment")
}
if strings.TrimSpace(bucket) == "" || strings.TrimSpace(accessKeyID) == "" ||
strings.TrimSpace(secretAccessKey) == "" {
return nil, fmt.Errorf("S3 bucket and credentials are required")
}
if operationTimeout <= 0 {
return nil, fmt.Errorf("S3 operation timeout must be positive")
}
client, err := minio.New(parsedEndpoint.Host, &minio.Options{
Creds: credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
Secure: parsedEndpoint.Scheme == "https",
Region: region,
})
if err != nil {
return nil, fmt.Errorf("create MinIO client: %w", err)
}
return &MinIOStore{client: client, bucket: bucket, operationTimeout: operationTimeout}, nil
}
func (store *MinIOStore) Put(ctx context.Context, object application.ObjectPut) error {
operationContext, cancel := context.WithTimeout(ctx, store.operationTimeout)
defer cancel()
upload, err := store.client.PutObject(
operationContext,
store.bucket,
object.Key,
object.Body,
object.SizeBytes,
minio.PutObjectOptions{ContentType: object.ContentType},
)
if err != nil {
return fmt.Errorf("put MinIO object: %w", err)
}
if upload.Size != object.SizeBytes {
return fmt.Errorf("put MinIO object: stored %d bytes, want %d", upload.Size, object.SizeBytes)
}
return nil
}
func (store *MinIOStore) Get(
ctx context.Context,
key string,
) (application.ObjectContent, error) {
operationContext, cancel := context.WithTimeout(ctx, store.operationTimeout)
stat, err := store.client.StatObject(
operationContext,
store.bucket,
key,
minio.StatObjectOptions{},
)
if err != nil {
cancel()
return application.ObjectContent{}, fmt.Errorf("stat MinIO object: %w", err)
}
object, err := store.client.GetObject(
operationContext,
store.bucket,
key,
minio.GetObjectOptions{},
)
if err != nil {
cancel()
return application.ObjectContent{}, fmt.Errorf("get MinIO object: %w", err)
}
firstByte := make([]byte, 1)
readCount, readError := object.Read(firstByte)
if readError != nil && readCount == 0 {
_ = object.Close()
cancel()
return application.ObjectContent{}, fmt.Errorf("read MinIO object: %w", readError)
}
if readCount != 1 {
_ = object.Close()
cancel()
return application.ObjectContent{}, fmt.Errorf("read MinIO object: expected non-empty object")
}
return application.ObjectContent{
Body: &cancelingReadCloser{
Reader: io.MultiReader(bytes.NewReader(firstByte), object),
Closer: object,
cancel: cancel,
},
SizeBytes: stat.Size,
}, nil
}
func (store *MinIOStore) List(
ctx context.Context,
prefix string,
) ([]StoredObject, error) {
operationContext, cancel := context.WithTimeout(ctx, store.operationTimeout)
defer cancel()
objects := make([]StoredObject, 0)
for object := range store.client.ListObjects(
operationContext,
store.bucket,
minio.ListObjectsOptions{Prefix: prefix, Recursive: true},
) {
if object.Err != nil {
return nil, fmt.Errorf("list MinIO objects: %w", object.Err)
}
objects = append(objects, StoredObject{
Key: object.Key,
SizeBytes: object.Size,
LastModified: object.LastModified.UTC(),
})
}
return objects, nil
}
func (store *MinIOStore) Delete(ctx context.Context, key string) error {
operationContext, cancel := context.WithTimeout(ctx, store.operationTimeout)
defer cancel()
if err := store.client.RemoveObject(
operationContext,
store.bucket,
key,
minio.RemoveObjectOptions{},
); err != nil {
return fmt.Errorf("delete MinIO object: %w", err)
}
return nil
}
func (store *MinIOStore) Ping(ctx context.Context) error {
operationContext, cancel := context.WithTimeout(ctx, store.operationTimeout)
defer cancel()
exists, err := store.client.BucketExists(operationContext, store.bucket)
if err != nil {
return fmt.Errorf("check MinIO bucket: %w", err)
}
if !exists {
return fmt.Errorf("MinIO bucket %q does not exist", store.bucket)
}
return nil
}
type cancelingReadCloser struct {
io.Reader
io.Closer
cancel context.CancelFunc
}
func (reader *cancelingReadCloser) Close() error {
err := reader.Closer.Close()
reader.cancel()
return err
}
var _ application.ObjectStore = (*MinIOStore)(nil)
@@ -0,0 +1,37 @@
package objectstore
import (
"testing"
"time"
)
func TestNewMinIOStoreValidatesConfiguration(t *testing.T) {
testCases := []struct {
name string
endpoint string
bucket string
accessKey string
secretKey string
timeout time.Duration
wantError bool
}{
{name: "valid HTTP", endpoint: "http://minio:9000", bucket: "attachments", accessKey: "api", secretKey: "secret", timeout: time.Second},
{name: "valid HTTPS", endpoint: "https://s3.example.test", bucket: "attachments", accessKey: "api", secretKey: "secret", timeout: time.Second},
{name: "relative endpoint", endpoint: "minio:9000", bucket: "attachments", accessKey: "api", secretKey: "secret", timeout: time.Second, wantError: true},
{name: "endpoint path", endpoint: "http://minio:9000/path", bucket: "attachments", accessKey: "api", secretKey: "secret", timeout: time.Second, wantError: true},
{name: "embedded credentials", endpoint: "http://user:pass@minio:9000", bucket: "attachments", accessKey: "api", secretKey: "secret", timeout: time.Second, wantError: true},
{name: "empty bucket", endpoint: "http://minio:9000", accessKey: "api", secretKey: "secret", timeout: time.Second, wantError: true},
{name: "empty credentials", endpoint: "http://minio:9000", bucket: "attachments", timeout: time.Second, wantError: true},
{name: "invalid timeout", endpoint: "http://minio:9000", bucket: "attachments", accessKey: "api", secretKey: "secret", wantError: true},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
_, err := NewMinIOStore(testCase.endpoint, "us-east-1", testCase.bucket,
testCase.accessKey, testCase.secretKey, testCase.timeout)
if (err != nil) != testCase.wantError {
t.Fatalf("NewMinIOStore() error = %v, wantError %v", err, testCase.wantError)
}
})
}
}
@@ -0,0 +1,899 @@
package postgres
import (
"context"
"errors"
"fmt"
"time"
"mtusi2026lab5/internal/domain"
"github.com/jackc/pgx/v5"
)
const attachmentJobColumns = `
schema_version, job_id::text, job_type, attachment_id::text,
pipeline_version, attempt, max_attempts, status, error_code,
available_at, lease_until, leased_by, replay_count, created_at, updated_at
`
type scanner interface {
Scan(dest ...any) error
}
func scanAttachmentJob(row scanner, job *domain.AttachmentJob) error {
return row.Scan(
&job.SchemaVersion,
&job.JobID,
&job.Type,
&job.AttachmentID,
&job.PipelineVersion,
&job.Attempt,
&job.MaxAttempts,
&job.Status,
&job.ErrorCode,
&job.AvailableAt,
&job.LeaseUntil,
&job.LeasedBy,
&job.ReplayCount,
&job.CreatedAt,
&job.UpdatedAt,
)
}
func (s *PostgreSQLStore) CreateQueuedAttachment(ctx context.Context, attachment domain.Attachment, job domain.AttachmentJob) (domain.Attachment, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
tx, err := s.pool.Begin(queryContext)
if err != nil {
return domain.Attachment{}, fmt.Errorf("begin queued attachment transaction: %w", err)
}
defer func() { _ = tx.Rollback(queryContext) }()
err = tx.QueryRow(queryContext, `
INSERT INTO attachments (
id, chat_id, owner_id, object_key, staging_key, filename, content_type,
size_bytes, sha256, width, height, pipeline_version, status, error_code,
created_at, updated_at
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,decode($9,'hex'),$10,$11,$12,$13,NULL,$14,$15)
RETURNING created_at, updated_at
`, attachment.ID, attachment.ChatID, attachment.OwnerID, attachment.ObjectKey,
attachment.StagingKey, attachment.Filename, attachment.ContentType, attachment.SizeBytes,
attachment.SHA256, attachment.Width, attachment.Height, attachment.PipelineVersion,
attachment.Status, attachment.CreatedAt, attachment.UpdatedAt,
).Scan(&attachment.CreatedAt, &attachment.UpdatedAt)
if err != nil {
return domain.Attachment{}, fmt.Errorf("insert queued attachment: %w", err)
}
if job.AvailableAt.IsZero() {
job.AvailableAt = job.CreatedAt
}
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_jobs (
job_id, attachment_id, schema_version, job_type, pipeline_version,
attempt, max_attempts, status, available_at, created_at, updated_at
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)
`, job.JobID, job.AttachmentID, job.SchemaVersion, job.Type, job.PipelineVersion,
job.Attempt, job.MaxAttempts, job.Status, job.AvailableAt, job.CreatedAt, job.UpdatedAt)
if err != nil {
return domain.Attachment{}, fmt.Errorf("insert attachment job: %w", err)
}
if err = tx.Commit(queryContext); err != nil {
return domain.Attachment{}, fmt.Errorf("commit queued attachment: %w", err)
}
attachment.Variants = make([]domain.AttachmentVariant, 0)
return attachment, nil
}
func (s *PostgreSQLStore) ListUnpublishedAttachmentJobs(ctx context.Context, limit int) ([]domain.AttachmentJob, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
rows, err := s.pool.Query(queryContext, `
SELECT `+attachmentJobColumns+`
FROM attachment_jobs
WHERE status = 'queued' AND published_at IS NULL
AND available_at <= CURRENT_TIMESTAMP
ORDER BY available_at, created_at, job_id
LIMIT $1
`, limit)
if err != nil {
return nil, fmt.Errorf("list unpublished attachment jobs: %w", err)
}
defer rows.Close()
jobs := make([]domain.AttachmentJob, 0)
for rows.Next() {
var job domain.AttachmentJob
if err = scanAttachmentJob(rows, &job); err != nil {
return nil, fmt.Errorf("scan unpublished attachment job: %w", err)
}
jobs = append(jobs, job)
}
return jobs, rows.Err()
}
func (s *PostgreSQLStore) MarkAttachmentJobPublished(ctx context.Context, jobID string, attempt int, publishedAt time.Time) error {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
_, err := s.pool.Exec(queryContext, `
UPDATE attachment_jobs SET published_at = $3, updated_at = $3
WHERE job_id = $1 AND attempt = $2 AND status = 'queued'
`, jobID, attempt, publishedAt)
if err != nil {
return fmt.Errorf("mark attachment job published: %w", err)
}
return nil
}
func (s *PostgreSQLStore) ClaimAttachmentJob(
ctx context.Context,
message domain.AttachmentJobMessage,
workerID string,
leaseUntil time.Time,
) (domain.AttachmentJob, bool, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
tx, err := s.pool.Begin(queryContext)
if err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("begin claim attachment job: %w", err)
}
defer func() { _ = tx.Rollback(queryContext) }()
var job domain.AttachmentJob
err = scanAttachmentJob(tx.QueryRow(queryContext, `
UPDATE attachment_jobs
SET status = 'processing', lease_until = $5, leased_by = $6,
updated_at = CURRENT_TIMESTAMP
WHERE job_id = $1 AND attachment_id = $2 AND pipeline_version = $3
AND attempt = $4 AND status = 'queued'
AND available_at <= CURRENT_TIMESTAMP
AND EXISTS (
SELECT 1 FROM attachments a
WHERE a.id = attachment_jobs.attachment_id
AND a.pipeline_version = attachment_jobs.pipeline_version
AND a.status = 'queued'
)
RETURNING `+attachmentJobColumns+`
`, message.JobID, message.AttachmentID, message.PipelineVersion, message.Attempt,
leaseUntil, workerID), &job)
if errors.Is(err, pgx.ErrNoRows) {
var status domain.AttachmentJobStatus
var attachmentStatus domain.AttachmentStatus
var attempt, activeVersion, jobVersion int
lookupErr := tx.QueryRow(queryContext, `
SELECT j.status, j.attempt, a.status, a.pipeline_version, j.pipeline_version
FROM attachment_jobs j
JOIN attachments a ON a.id=j.attachment_id
WHERE j.job_id=$1
FOR UPDATE OF a,j
`, message.JobID).Scan(
&status,
&attempt,
&attachmentStatus,
&activeVersion,
&jobVersion,
)
if errors.Is(lookupErr, pgx.ErrNoRows) {
return domain.AttachmentJob{}, false, ErrNotFound
}
if lookupErr != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("inspect unclaimed attachment job: %w", lookupErr)
}
err = nil
switch {
case status == domain.AttachmentJobQueued &&
activeVersion == jobVersion &&
attachmentStatus == domain.AttachmentStatusReady:
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='succeeded', error_code=NULL, published_at=COALESCE(published_at,CURRENT_TIMESTAMP),
lease_until=NULL, leased_by=NULL, updated_at=CURRENT_TIMESTAMP
WHERE job_id=$1
`, message.JobID)
status = domain.AttachmentJobSucceeded
case status == domain.AttachmentJobQueued && activeVersion != jobVersion:
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='superseded', error_code='superseded_pipeline',
lease_until=NULL, leased_by=NULL, updated_at=CURRENT_TIMESTAMP
WHERE job_id=$1
`, message.JobID)
status = domain.AttachmentJobSuperseded
}
if err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("normalize unclaimed attachment job: %w", err)
}
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("commit unclaimed attachment job: %w", err)
}
return domain.AttachmentJob{JobID: message.JobID, Status: status, Attempt: attempt}, false, nil
}
if err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("claim attachment job: %w", err)
}
_, err = tx.Exec(queryContext, `
UPDATE attachments SET status = 'processing', updated_at = CURRENT_TIMESTAMP
WHERE id = $1 AND pipeline_version = $2 AND status = 'queued'
`, message.AttachmentID, message.PipelineVersion)
if err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("mark attachment processing: %w", err)
}
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("commit claimed attachment job: %w", err)
}
return job, true, nil
}
func (s *PostgreSQLStore) GetAttachmentForProcessing(ctx context.Context, attachmentID string) (domain.Attachment, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var attachment domain.Attachment
var digest []byte
var stagingKey *string
err := s.pool.QueryRow(queryContext, `
SELECT id::text, chat_id::text, owner_id::text, object_key, staging_key,
filename, content_type, size_bytes, sha256, width, height,
pipeline_version, status, error_code, created_at, updated_at
FROM attachments WHERE id = $1
`, attachmentID).Scan(&attachment.ID, &attachment.ChatID, &attachment.OwnerID,
&attachment.ObjectKey, &stagingKey, &attachment.Filename,
&attachment.ContentType, &attachment.SizeBytes, &digest, &attachment.Width,
&attachment.Height, &attachment.PipelineVersion, &attachment.Status,
&attachment.ErrorCode, &attachment.CreatedAt, &attachment.UpdatedAt)
if errors.Is(err, pgx.ErrNoRows) {
return domain.Attachment{}, ErrNotFound
}
if err != nil {
return domain.Attachment{}, fmt.Errorf("get attachment for processing: %w", err)
}
attachment.SHA256 = fmt.Sprintf("%x", digest)
if stagingKey != nil {
attachment.StagingKey = *stagingKey
}
return attachment, nil
}
func (s *PostgreSQLStore) CompleteAttachmentJob(
ctx context.Context,
job domain.AttachmentJob,
variants []domain.AttachmentVariant,
updatedAt time.Time,
) (bool, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
tx, err := s.pool.Begin(queryContext)
if err != nil {
return false, fmt.Errorf("begin complete attachment job: %w", err)
}
defer func() { _ = tx.Rollback(queryContext) }()
var attachmentStatus domain.AttachmentStatus
var pipelineVersion int
var jobStatus domain.AttachmentJobStatus
err = tx.QueryRow(queryContext, `
SELECT a.status, a.pipeline_version, j.status
FROM attachments a
JOIN attachment_jobs j ON j.attachment_id = a.id
WHERE a.id = $1 AND j.job_id = $2
FOR UPDATE OF a, j
`, job.AttachmentID, job.JobID).Scan(&attachmentStatus, &pipelineVersion, &jobStatus)
if err != nil {
return false, fmt.Errorf("lock attachment completion: %w", err)
}
if pipelineVersion != job.PipelineVersion || jobStatus == domain.AttachmentJobSuperseded {
if jobStatus != domain.AttachmentJobSuperseded {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='superseded', error_code='superseded_pipeline',
lease_until=NULL, leased_by=NULL, updated_at=$2
WHERE job_id=$1
`, job.JobID, updatedAt)
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, error_code, created_at)
VALUES ($1, 'superseded', $2, 'superseded', $3, 'superseded_pipeline', $4)
`, job.JobID, jobStatus, job.Attempt, updatedAt)
}
if err != nil {
return false, fmt.Errorf("supersede stale pipeline completion: %w", err)
}
}
if err = tx.Commit(queryContext); err != nil {
return false, fmt.Errorf("commit stale pipeline completion: %w", err)
}
return false, nil
}
if attachmentStatus == domain.AttachmentStatusReady || jobStatus == domain.AttachmentJobSucceeded {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='succeeded', error_code=NULL, lease_until=NULL, leased_by=NULL, updated_at=$2
WHERE job_id=$1
`, job.JobID, updatedAt)
if err != nil {
return false, fmt.Errorf("normalize completed job: %w", err)
}
if err = tx.Commit(queryContext); err != nil {
return false, err
}
return true, nil
}
if len(variants) != 3 {
return false, fmt.Errorf("complete attachment requires three variants: %w", ErrConflict)
}
for _, variant := range variants {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_variants (
attachment_id, pipeline_version, name, object_key, content_type,
size_bytes, width, height, sha256, created_at
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,decode($9,'hex'),$10)
ON CONFLICT (attachment_id, pipeline_version, name) DO UPDATE SET
object_key = EXCLUDED.object_key, content_type = EXCLUDED.content_type,
size_bytes = EXCLUDED.size_bytes, width = EXCLUDED.width,
height = EXCLUDED.height, sha256 = EXCLUDED.sha256
`, job.AttachmentID, job.PipelineVersion, variant.Name, variant.ObjectKey,
variant.ContentType, variant.SizeBytes, variant.Width, variant.Height,
variant.SHA256, updatedAt)
if err != nil {
return false, fmt.Errorf("upsert attachment variant %s: %w", variant.Name, err)
}
}
tag, err := tx.Exec(queryContext, `
UPDATE attachments SET status = 'ready', error_code = NULL, updated_at = $3
WHERE id = $1 AND pipeline_version = $2 AND status IN ('queued','processing')
`, job.AttachmentID, job.PipelineVersion, updatedAt)
if err != nil {
return false, fmt.Errorf("mark attachment ready: %w", err)
}
if tag.RowsAffected() != 1 {
return false, fmt.Errorf("active pipeline changed during completion: %w", ErrConflict)
}
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status = 'succeeded', error_code = NULL, lease_until = NULL,
leased_by = NULL, updated_at = $2
WHERE job_id = $1
`, job.JobID, updatedAt)
if err != nil {
return false, fmt.Errorf("mark attachment job succeeded: %w", err)
}
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, created_at)
VALUES ($1, 'completed', $2, 'succeeded', $3, $4)
`, job.JobID, jobStatus, job.Attempt, updatedAt)
if err != nil {
return false, fmt.Errorf("record attachment completion: %w", err)
}
if err = tx.Commit(queryContext); err != nil {
return false, fmt.Errorf("commit completed attachment job: %w", err)
}
return true, nil
}
func (s *PostgreSQLStore) RetryAttachmentJob(
ctx context.Context,
jobID string,
errorCode string,
availableAt time.Time,
updatedAt time.Time,
eventType string,
) (domain.AttachmentJob, bool, error) {
if eventType != "retry_scheduled" && eventType != "lease_recovered" {
return domain.AttachmentJob{}, false, fmt.Errorf("unsupported retry event type")
}
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
tx, err := s.pool.Begin(queryContext)
if err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("begin retry attachment job: %w", err)
}
defer func() { _ = tx.Rollback(queryContext) }()
var job domain.AttachmentJob
err = scanAttachmentJob(tx.QueryRow(queryContext, `
SELECT `+attachmentJobColumns+`
FROM attachment_jobs WHERE job_id = $1 FOR UPDATE
`, jobID), &job)
if err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("lock attachment job for retry: %w", err)
}
var attachmentStatus domain.AttachmentStatus
var activePipelineVersion int
if err = tx.QueryRow(queryContext,
`SELECT status, pipeline_version FROM attachments WHERE id = $1 FOR UPDATE`,
job.AttachmentID,
).Scan(&attachmentStatus, &activePipelineVersion); err != nil {
return domain.AttachmentJob{}, false, fmt.Errorf("lock attachment for retry: %w", err)
}
if activePipelineVersion != job.PipelineVersion || job.Status == domain.AttachmentJobSuperseded {
previousStatus := job.Status
if job.Status != domain.AttachmentJobSuperseded {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='superseded', error_code='superseded_pipeline',
lease_until=NULL, leased_by=NULL, updated_at=$2
WHERE job_id=$1
`, jobID, updatedAt)
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, error_code, created_at)
VALUES ($1, 'superseded', $2, 'superseded', $3, 'superseded_pipeline', $4)
`, jobID, previousStatus, job.Attempt, updatedAt)
}
}
if err != nil {
return domain.AttachmentJob{}, false, err
}
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, false, err
}
job.Status = domain.AttachmentJobSuperseded
job.ErrorCode = stringPointer("superseded_pipeline")
job.LeaseUntil = nil
job.LeasedBy = nil
return job, true, nil
}
if attachmentStatus == domain.AttachmentStatusReady || job.Status == domain.AttachmentJobSucceeded {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='succeeded', error_code=NULL, lease_until=NULL, leased_by=NULL, updated_at=$2
WHERE job_id=$1
`, jobID, updatedAt)
if err != nil {
return domain.AttachmentJob{}, false, err
}
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, false, err
}
job.Status = domain.AttachmentJobSucceeded
return job, true, nil
}
if job.Status != domain.AttachmentJobProcessing {
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, false, err
}
return job, job.Status == domain.AttachmentJobFailed || job.Status == domain.AttachmentJobSuperseded, nil
}
if job.Attempt >= job.MaxAttempts {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='failed', error_code=$2, lease_until=NULL, leased_by=NULL, updated_at=$3
WHERE job_id=$1
`, jobID, errorCode, updatedAt)
if err == nil {
_, err = tx.Exec(queryContext, `
UPDATE attachments
SET status='failed', error_code='retry_exhausted', updated_at=$3
WHERE id=$1 AND pipeline_version=$2 AND status <> 'ready'
`, job.AttachmentID, job.PipelineVersion, updatedAt)
}
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, error_code, created_at)
VALUES ($1, 'permanent_failure', 'processing', 'failed', $2, $3, $4)
`, jobID, job.Attempt, errorCode, updatedAt)
}
if err != nil {
return domain.AttachmentJob{}, false, err
}
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, false, err
}
job.Status = domain.AttachmentJobFailed
job.ErrorCode = &errorCode
job.LeaseUntil = nil
job.LeasedBy = nil
return job, true, nil
}
job.Attempt++
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET attempt=$2, status='queued', error_code=$3, available_at=$4,
published_at=NULL, lease_until=NULL, leased_by=NULL, updated_at=$5
WHERE job_id=$1
`, jobID, job.Attempt, errorCode, availableAt, updatedAt)
if err == nil {
_, err = tx.Exec(queryContext, `
UPDATE attachments
SET status='queued', error_code=NULL, updated_at=$3
WHERE id=$1 AND pipeline_version=$2 AND status <> 'ready'
`, job.AttachmentID, job.PipelineVersion, updatedAt)
}
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, error_code, created_at)
VALUES ($1, $2, 'processing', 'queued', $3, $4, $5)
`, jobID, eventType, job.Attempt, errorCode, updatedAt)
}
if err != nil {
return domain.AttachmentJob{}, false, err
}
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, false, err
}
job.Status = domain.AttachmentJobQueued
job.ErrorCode = &errorCode
job.AvailableAt = availableAt
job.LeaseUntil = nil
job.LeasedBy = nil
job.UpdatedAt = updatedAt
return job, false, nil
}
func (s *PostgreSQLStore) FailAttachmentJob(ctx context.Context, jobID, errorCode string, updatedAt time.Time) error {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
tx, err := s.pool.Begin(queryContext)
if err != nil {
return err
}
defer func() { _ = tx.Rollback(queryContext) }()
var attachmentID string
var attachmentStatus domain.AttachmentStatus
var activePipelineVersion, jobPipelineVersion, attempt int
var jobStatus domain.AttachmentJobStatus
err = tx.QueryRow(queryContext, `
SELECT a.id::text, a.status, a.pipeline_version, j.pipeline_version, j.status, j.attempt
FROM attachment_jobs j
JOIN attachments a ON a.id=j.attachment_id
WHERE j.job_id=$1 FOR UPDATE OF a,j
`, jobID).Scan(
&attachmentID,
&attachmentStatus,
&activePipelineVersion,
&jobPipelineVersion,
&jobStatus,
&attempt,
)
if err != nil {
return err
}
if activePipelineVersion != jobPipelineVersion || jobStatus == domain.AttachmentJobSuperseded {
if jobStatus != domain.AttachmentJobSuperseded {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='superseded', error_code='superseded_pipeline',
lease_until=NULL, leased_by=NULL, updated_at=$2
WHERE job_id=$1
`, jobID, updatedAt)
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, error_code, created_at)
VALUES ($1, 'superseded', $2, 'superseded', $3, 'superseded_pipeline', $4)
`, jobID, jobStatus, attempt, updatedAt)
}
}
if err != nil {
return err
}
return tx.Commit(queryContext)
}
if attachmentStatus == domain.AttachmentStatusReady || jobStatus == domain.AttachmentJobSucceeded {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='succeeded', error_code=NULL, lease_until=NULL, leased_by=NULL, updated_at=$2
WHERE job_id=$1
`, jobID, updatedAt)
} else {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='failed', error_code=$2, lease_until=NULL, leased_by=NULL, updated_at=$3
WHERE job_id=$1
`, jobID, errorCode, updatedAt)
if err == nil {
_, err = tx.Exec(queryContext, `
UPDATE attachments
SET status='failed', error_code=$3, updated_at=$4
WHERE id=$1 AND pipeline_version=$2
`, attachmentID, jobPipelineVersion, errorCode, updatedAt)
}
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, error_code, created_at)
VALUES ($1, 'permanent_failure', $2, 'failed', $3, $4, $5)
`, jobID, jobStatus, attempt, errorCode, updatedAt)
}
}
if err != nil {
return err
}
return tx.Commit(queryContext)
}
func (s *PostgreSQLStore) ListExpiredAttachmentJobs(ctx context.Context, now time.Time, limit int) ([]domain.AttachmentJob, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
rows, err := s.pool.Query(queryContext, `
SELECT `+attachmentJobColumns+`
FROM attachment_jobs
WHERE status='processing' AND lease_until <= $1
ORDER BY lease_until, job_id
LIMIT $2
`, now, limit)
if err != nil {
return nil, fmt.Errorf("list expired attachment jobs: %w", err)
}
defer rows.Close()
jobs := make([]domain.AttachmentJob, 0)
for rows.Next() {
var job domain.AttachmentJob
if err = scanAttachmentJob(rows, &job); err != nil {
return nil, fmt.Errorf("scan expired attachment job: %w", err)
}
jobs = append(jobs, job)
}
return jobs, rows.Err()
}
func (s *PostgreSQLStore) ReplayFailedAttachmentJob(ctx context.Context, jobID string, replayedAt time.Time) (domain.AttachmentJob, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
tx, err := s.pool.Begin(queryContext)
if err != nil {
return domain.AttachmentJob{}, fmt.Errorf("begin attachment replay: %w", err)
}
defer func() { _ = tx.Rollback(queryContext) }()
var job domain.AttachmentJob
err = scanAttachmentJob(tx.QueryRow(queryContext, `
SELECT `+attachmentJobColumns+`
FROM attachment_jobs WHERE job_id=$1 FOR UPDATE
`, jobID), &job)
if errors.Is(err, pgx.ErrNoRows) {
return domain.AttachmentJob{}, ErrNotFound
}
if err != nil {
return domain.AttachmentJob{}, fmt.Errorf("lock failed job for replay: %w", err)
}
var attachmentStatus domain.AttachmentStatus
var activePipelineVersion int
var stagingKey *string
if err = tx.QueryRow(queryContext, `
SELECT status, staging_key, pipeline_version FROM attachments WHERE id=$1 FOR UPDATE
`, job.AttachmentID).Scan(&attachmentStatus, &stagingKey, &activePipelineVersion); err != nil {
return domain.AttachmentJob{}, err
}
if job.Status != domain.AttachmentJobFailed ||
attachmentStatus != domain.AttachmentStatusFailed ||
activePipelineVersion != job.PipelineVersion {
return domain.AttachmentJob{}, fmt.Errorf("only the active failed pipeline can be replayed: %w", ErrConflict)
}
if stagingKey == nil || *stagingKey == "" {
return domain.AttachmentJob{}, fmt.Errorf("failed job staging is no longer retained: %w", ErrConflict)
}
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET attempt=1, status='queued', error_code=NULL, available_at=$2,
published_at=NULL, lease_until=NULL, leased_by=NULL,
replay_count=replay_count+1, updated_at=$2
WHERE job_id=$1
`, jobID, replayedAt)
if err == nil {
_, err = tx.Exec(queryContext, `
UPDATE attachments SET status='queued', error_code=NULL, updated_at=$2 WHERE id=$1
`, job.AttachmentID, replayedAt)
}
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, created_at)
VALUES ($1, 'operator_replay', 'failed', 'queued', 1, $2)
`, jobID, replayedAt)
}
if err != nil {
return domain.AttachmentJob{}, fmt.Errorf("replay failed job: %w", err)
}
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, fmt.Errorf("commit attachment replay: %w", err)
}
job.Attempt = 1
job.Status = domain.AttachmentJobQueued
job.ErrorCode = nil
job.AvailableAt = replayedAt
job.ReplayCount++
job.UpdatedAt = replayedAt
return job, nil
}
func (s *PostgreSQLStore) ListFailedAttachmentJobs(ctx context.Context, limit int) ([]domain.AttachmentJob, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
rows, err := s.pool.Query(queryContext, `
SELECT `+attachmentJobColumns+`
FROM attachment_jobs
WHERE status='failed'
ORDER BY updated_at, job_id
LIMIT $1
`, limit)
if err != nil {
return nil, fmt.Errorf("list failed attachment jobs: %w", err)
}
defer rows.Close()
jobs := make([]domain.AttachmentJob, 0)
for rows.Next() {
var job domain.AttachmentJob
if err = scanAttachmentJob(rows, &job); err != nil {
return nil, err
}
jobs = append(jobs, job)
}
return jobs, rows.Err()
}
func (s *PostgreSQLStore) LookupAttachmentByStagingKey(
ctx context.Context,
stagingKey string,
) (string, domain.AttachmentStatus, time.Time, bool, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var attachmentID string
var status domain.AttachmentStatus
var updatedAt time.Time
err := s.pool.QueryRow(queryContext, `
SELECT id::text, status, updated_at FROM attachments WHERE staging_key=$1
`, stagingKey).Scan(&attachmentID, &status, &updatedAt)
if errors.Is(err, pgx.ErrNoRows) {
return "", "", time.Time{}, false, nil
}
if err != nil {
return "", "", time.Time{}, false, err
}
return attachmentID, status, updatedAt, true, nil
}
func (s *PostgreSQLStore) ClearAttachmentStagingKey(ctx context.Context, attachmentID, stagingKey string) error {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
_, err := s.pool.Exec(queryContext, `
UPDATE attachments SET staging_key=NULL
WHERE id=$1 AND staging_key=$2 AND status IN ('ready','failed')
`, attachmentID, stagingKey)
if err != nil {
return fmt.Errorf("clear attachment staging key: %w", err)
}
return nil
}
func (s *PostgreSQLStore) ListReadyStagingKeys(
ctx context.Context,
limit int,
) (map[string]string, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
rows, err := s.pool.Query(queryContext, `
SELECT staging_key, id::text
FROM attachments
WHERE status='ready' AND staging_key IS NOT NULL
ORDER BY updated_at, id
LIMIT $1
`, limit)
if err != nil {
return nil, fmt.Errorf("list ready staging keys: %w", err)
}
defer rows.Close()
keys := make(map[string]string)
for rows.Next() {
var key, attachmentID string
if err = rows.Scan(&key, &attachmentID); err != nil {
return nil, fmt.Errorf("scan ready staging key: %w", err)
}
keys[key] = attachmentID
}
return keys, rows.Err()
}
func stringPointer(value string) *string { return &value }
func (s *PostgreSQLStore) GetAttachmentJob(ctx context.Context, jobID string) (domain.AttachmentJob, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var job domain.AttachmentJob
err := scanAttachmentJob(s.pool.QueryRow(queryContext, `
SELECT `+attachmentJobColumns+`
FROM attachment_jobs WHERE job_id=$1
`, jobID), &job)
if errors.Is(err, pgx.ErrNoRows) {
return domain.AttachmentJob{}, ErrNotFound
}
if err != nil {
return domain.AttachmentJob{}, fmt.Errorf("get attachment job: %w", err)
}
return job, nil
}
func (s *PostgreSQLStore) UpgradeAttachmentPipeline(
ctx context.Context,
attachmentID string,
targetVersion int,
stagingKey string,
job domain.AttachmentJob,
upgradedAt time.Time,
) (domain.AttachmentJob, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
tx, err := s.pool.Begin(queryContext)
if err != nil {
return domain.AttachmentJob{}, fmt.Errorf("begin pipeline upgrade: %w", err)
}
defer func() { _ = tx.Rollback(queryContext) }()
var status domain.AttachmentStatus
var currentVersion int
err = tx.QueryRow(queryContext, `
SELECT status, pipeline_version
FROM attachments WHERE id=$1 FOR UPDATE
`, attachmentID).Scan(&status, &currentVersion)
if errors.Is(err, pgx.ErrNoRows) {
return domain.AttachmentJob{}, ErrNotFound
}
if err != nil {
return domain.AttachmentJob{}, fmt.Errorf("lock attachment for pipeline upgrade: %w", err)
}
if targetVersion != currentVersion+1 ||
(status != domain.AttachmentStatusReady && status != domain.AttachmentStatusProcessing) {
return domain.AttachmentJob{}, fmt.Errorf("pipeline upgrade requires ready/processing current version and next target version: %w", ErrConflict)
}
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, error_code, created_at)
SELECT job_id, 'superseded', status, 'superseded', attempt, 'superseded_pipeline', $3
FROM attachment_jobs
WHERE attachment_id=$1 AND pipeline_version < $2
AND status IN ('queued','processing')
`, attachmentID, targetVersion, upgradedAt)
if err == nil {
_, err = tx.Exec(queryContext, `
UPDATE attachment_jobs
SET status='superseded', error_code='superseded_pipeline',
lease_until=NULL, leased_by=NULL, updated_at=$3
WHERE attachment_id=$1 AND pipeline_version < $2
AND status IN ('queued','processing')
`, attachmentID, targetVersion, upgradedAt)
}
if err == nil {
_, err = tx.Exec(queryContext, `
UPDATE attachments
SET pipeline_version=$2, staging_key=$3, status='queued',
error_code=NULL, updated_at=$4
WHERE id=$1
`, attachmentID, targetVersion, stagingKey, upgradedAt)
}
if job.AvailableAt.IsZero() {
job.AvailableAt = upgradedAt
}
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_jobs (
job_id, attachment_id, schema_version, job_type, pipeline_version,
attempt, max_attempts, status, available_at, created_at, updated_at
) VALUES ($1,$2,$3,$4,$5,$6,$7,'queued',$8,$9,$10)
`, job.JobID, attachmentID, job.SchemaVersion, job.Type, targetVersion,
job.Attempt, job.MaxAttempts, job.AvailableAt, job.CreatedAt, job.UpdatedAt)
}
if err == nil {
_, err = tx.Exec(queryContext, `
INSERT INTO attachment_job_events
(job_id, event_type, previous_status, new_status, attempt, created_at)
VALUES ($1, 'version_upgrade', 'queued', 'queued', $2, $3)
`, job.JobID, job.Attempt, upgradedAt)
}
if err != nil {
return domain.AttachmentJob{}, fmt.Errorf("apply pipeline upgrade: %w", err)
}
if err = tx.Commit(queryContext); err != nil {
return domain.AttachmentJob{}, fmt.Errorf("commit pipeline upgrade: %w", err)
}
job.Status = domain.AttachmentJobQueued
job.PipelineVersion = targetVersion
job.AvailableAt = upgradedAt
job.UpdatedAt = upgradedAt
return job, nil
}
+372
View File
@@ -0,0 +1,372 @@
package postgres
import (
"context"
"errors"
"fmt"
"time"
"mtusi2026lab5/internal/domain"
"mtusi2026lab5/internal/reconcile"
"github.com/jackc/pgx/v5"
)
func (s *PostgreSQLStore) CreateAttachment(
ctx context.Context,
attachment domain.Attachment,
) (domain.Attachment, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
err := s.pool.QueryRow(
queryContext,
`
INSERT INTO attachments (
id, chat_id, owner_id, object_key, filename, content_type,
size_bytes, sha256, width, height, status, error_code,
created_at, updated_at
)
VALUES (
$1, $2, $3, $4, $5, $6,
$7, decode($8, 'hex'), $9, $10, $11, $12,
$13, $14
)
RETURNING created_at, updated_at
`,
attachment.ID,
attachment.ChatID,
attachment.OwnerID,
attachment.ObjectKey,
attachment.Filename,
attachment.ContentType,
attachment.SizeBytes,
attachment.SHA256,
attachment.Width,
attachment.Height,
attachment.Status,
attachment.ErrorCode,
attachment.CreatedAt,
attachment.UpdatedAt,
).Scan(&attachment.CreatedAt, &attachment.UpdatedAt)
if err != nil {
return domain.Attachment{}, fmt.Errorf("insert attachment metadata: %w", err)
}
if attachment.Variants == nil {
attachment.Variants = make([]domain.AttachmentVariant, 0)
}
return attachment, nil
}
func (s *PostgreSQLStore) MarkAttachmentReady(
ctx context.Context,
attachmentID string,
updatedAt time.Time,
) (domain.Attachment, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var attachment domain.Attachment
var sha256Bytes []byte
err := s.pool.QueryRow(
queryContext,
`
UPDATE attachments
SET status = 'ready', error_code = NULL, updated_at = $2
WHERE id = $1 AND status IN ('queued', 'processing')
RETURNING
id::text, chat_id::text, owner_id::text, object_key,
filename, content_type, size_bytes, sha256, width, height,
pipeline_version, status, error_code, created_at, updated_at
`,
attachmentID,
updatedAt,
).Scan(
&attachment.ID,
&attachment.ChatID,
&attachment.OwnerID,
&attachment.ObjectKey,
&attachment.Filename,
&attachment.ContentType,
&attachment.SizeBytes,
&sha256Bytes,
&attachment.Width,
&attachment.Height,
&attachment.PipelineVersion,
&attachment.Status,
&attachment.ErrorCode,
&attachment.CreatedAt,
&attachment.UpdatedAt,
)
if errors.Is(err, pgx.ErrNoRows) {
return domain.Attachment{}, ErrConflict
}
if err != nil {
return domain.Attachment{}, fmt.Errorf("mark attachment ready: %w", err)
}
attachment.SHA256 = fmt.Sprintf("%x", sha256Bytes)
attachment.Variants, err = s.listAttachmentVariants(queryContext, attachment.ID, attachment.PipelineVersion)
if err != nil {
return domain.Attachment{}, err
}
return attachment, nil
}
func (s *PostgreSQLStore) MarkAttachmentFailed(
ctx context.Context,
attachmentID string,
errorCode string,
updatedAt time.Time,
) error {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
commandTag, err := s.pool.Exec(
queryContext,
`
UPDATE attachments
SET status = 'failed', error_code = $2, updated_at = $3
WHERE id = $1 AND status IN ('queued', 'processing')
`,
attachmentID,
errorCode,
updatedAt,
)
if err != nil {
return fmt.Errorf("mark attachment failed: %w", err)
}
if commandTag.RowsAffected() != 1 {
return ErrConflict
}
return nil
}
func (s *PostgreSQLStore) GetAttachment(
ctx context.Context,
attachmentID string,
callerID string,
) (domain.Attachment, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var attachment domain.Attachment
var sha256Bytes []byte
err := s.pool.QueryRow(
queryContext,
`
SELECT
a.id::text, a.chat_id::text, a.owner_id::text, a.object_key,
a.filename, a.content_type, a.size_bytes, a.sha256,
a.width, a.height, a.pipeline_version, a.status, a.error_code,
a.created_at, a.updated_at
FROM attachments AS a
JOIN chat_members AS cm
ON cm.chat_id = a.chat_id AND cm.user_id = $2
WHERE a.id = $1
`,
attachmentID,
callerID,
).Scan(
&attachment.ID,
&attachment.ChatID,
&attachment.OwnerID,
&attachment.ObjectKey,
&attachment.Filename,
&attachment.ContentType,
&attachment.SizeBytes,
&sha256Bytes,
&attachment.Width,
&attachment.Height,
&attachment.PipelineVersion,
&attachment.Status,
&attachment.ErrorCode,
&attachment.CreatedAt,
&attachment.UpdatedAt,
)
if errors.Is(err, pgx.ErrNoRows) {
return domain.Attachment{}, ErrNotFound
}
if err != nil {
return domain.Attachment{}, fmt.Errorf("get attachment metadata: %w", err)
}
attachment.SHA256 = fmt.Sprintf("%x", sha256Bytes)
attachment.Variants, err = s.listAttachmentVariants(queryContext, attachment.ID, attachment.PipelineVersion)
if err != nil {
return domain.Attachment{}, err
}
return attachment, nil
}
func (s *PostgreSQLStore) ListAttachmentInventory(
ctx context.Context,
) ([]reconcile.AttachmentRecord, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
rows, err := s.pool.Query(
queryContext,
`
SELECT
a.id::text,
a.object_key,
a.status,
a.updated_at,
EXISTS (
SELECT 1
FROM message_attachments AS ma
WHERE ma.attachment_id = a.id
) AS referenced,
COALESCE(a.staging_key, ''),
COALESCE(av.object_key, '')
FROM attachments AS a
LEFT JOIN attachment_variants AS av ON av.attachment_id = a.id
ORDER BY a.id, av.pipeline_version, av.name
`,
)
if err != nil {
return nil, fmt.Errorf("query attachment inventory: %w", err)
}
defer rows.Close()
records := make([]reconcile.AttachmentRecord, 0)
recordIndexes := make(map[string]int)
for rows.Next() {
var record reconcile.AttachmentRecord
var stagingKey string
var variantKey string
if err = rows.Scan(
&record.ID,
&record.ObjectKey,
&record.Status,
&record.UpdatedAt,
&record.Referenced,
&stagingKey,
&variantKey,
); err != nil {
return nil, fmt.Errorf("scan attachment inventory: %w", err)
}
if recordIndex, exists := recordIndexes[record.ID]; exists {
if variantKey != "" {
records[recordIndex].AdditionalObjectKeys = append(
records[recordIndex].AdditionalObjectKeys,
variantKey,
)
}
continue
}
if stagingKey != "" {
record.AdditionalObjectKeys = append(record.AdditionalObjectKeys, stagingKey)
}
if variantKey != "" {
record.AdditionalObjectKeys = append(record.AdditionalObjectKeys, variantKey)
}
recordIndexes[record.ID] = len(records)
records = append(records, record)
}
if err = rows.Err(); err != nil {
return nil, fmt.Errorf("iterate attachment inventory: %w", err)
}
return records, nil
}
func (s *PostgreSQLStore) MarkAttachmentFailedIfUnreferenced(
ctx context.Context,
attachmentID string,
expectedStatus domain.AttachmentStatus,
updatedBefore time.Time,
errorCode string,
updatedAt time.Time,
) (bool, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
transaction, err := s.pool.BeginTx(queryContext, pgx.TxOptions{})
if err != nil {
return false, fmt.Errorf("begin attachment reconciliation transaction: %w", err)
}
defer func() { _ = transaction.Rollback(queryContext) }()
var lockedAttachmentID string
err = transaction.QueryRow(
queryContext,
`
SELECT id::text
FROM attachments
WHERE id = $1
FOR UPDATE
`,
attachmentID,
).Scan(&lockedAttachmentID)
if errors.Is(err, pgx.ErrNoRows) {
return false, nil
}
if err != nil {
return false, fmt.Errorf("lock attachment during reconciliation: %w", err)
}
// This is deliberately a second statement. Under READ COMMITTED it gets a
// fresh snapshot after the row lock was acquired, so a message transaction
// that linked this attachment while we waited is visible to NOT EXISTS.
commandTag, err := transaction.Exec(
queryContext,
`
UPDATE attachments AS a
SET status = 'failed', error_code = $4, updated_at = $5
WHERE a.id = $1
AND a.status = $2
AND a.updated_at <= $3
AND NOT EXISTS (
SELECT 1
FROM message_attachments AS ma
WHERE ma.attachment_id = a.id
)
`,
attachmentID,
expectedStatus,
updatedBefore,
errorCode,
updatedAt,
)
if err != nil {
return false, fmt.Errorf("mark attachment failed during reconciliation: %w", err)
}
if err = transaction.Commit(queryContext); err != nil {
return false, fmt.Errorf("commit attachment reconciliation: %w", err)
}
return commandTag.RowsAffected() == 1, nil
}
func (s *PostgreSQLStore) listAttachmentVariants(
ctx context.Context,
attachmentID string,
pipelineVersion int,
) ([]domain.AttachmentVariant, error) {
if pipelineVersion < 1 {
pipelineVersion = 1
}
rows, err := s.pool.Query(ctx, `
SELECT name, object_key, content_type, size_bytes, width, height, sha256, pipeline_version
FROM attachment_variants
WHERE attachment_id = $1 AND pipeline_version = $2
ORDER BY name
`, attachmentID, pipelineVersion)
if err != nil {
return nil, fmt.Errorf("query attachment variants: %w", err)
}
defer rows.Close()
variants := make([]domain.AttachmentVariant, 0)
for rows.Next() {
var variant domain.AttachmentVariant
var digest []byte
if err = rows.Scan(&variant.Name, &variant.ObjectKey, &variant.ContentType, &variant.SizeBytes, &variant.Width, &variant.Height, &digest, &variant.PipelineVersion); err != nil {
return nil, fmt.Errorf("scan attachment variant: %w", err)
}
variant.SHA256 = fmt.Sprintf("%x", digest)
variants = append(variants, variant)
}
if err = rows.Err(); err != nil {
return nil, fmt.Errorf("iterate attachment variants: %w", err)
}
return variants, nil
}
var _ reconcile.MetadataStore = (*PostgreSQLStore)(nil)
+278
View File
@@ -0,0 +1,278 @@
package postgres
import (
"context"
"errors"
"fmt"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
)
func (s *PostgreSQLStore) CreateChat(
ctx context.Context,
title string,
memberIDs []string,
) (domain.Chat, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
transaction, err := s.pool.Begin(queryContext)
if err != nil {
return domain.Chat{}, fmt.Errorf(
"begin create chat transaction: %w",
err,
)
}
defer func() {
_ = transaction.Rollback(queryContext)
}()
chat := domain.Chat{
ID: uuid.NewString(),
Title: title,
MemberIDs: append([]string(nil), memberIDs...),
}
err = transaction.QueryRow(
queryContext,
`
INSERT INTO chats (
id,
title
)
VALUES ($1, $2)
RETURNING created_at
`,
chat.ID,
chat.Title,
).Scan(&chat.CreatedAt)
if err != nil {
return domain.Chat{}, fmt.Errorf("insert chat: %w", err)
}
for position, memberID := range memberIDs {
commandTag, insertErr := transaction.Exec(
queryContext,
`
INSERT INTO chat_members (
chat_id,
user_id,
position
)
SELECT
$1,
id,
$3
FROM users
WHERE id = $2
`,
chat.ID,
memberID,
position,
)
if insertErr != nil {
return domain.Chat{}, fmt.Errorf(
"insert chat member %s: %w",
memberID,
insertErr,
)
}
// INSERT ... SELECT не вставляет строку, если пользователя нет.
// Возврат из функции активирует deferred Rollback: уже созданные
// chat и предыдущие membership-строки не останутся в базе.
if commandTag.RowsAffected() != 1 {
return domain.Chat{}, fmt.Errorf(
"%w: member %s",
ErrNotFound,
memberID,
)
}
}
if err = transaction.Commit(queryContext); err != nil {
return domain.Chat{}, fmt.Errorf(
"commit create chat transaction: %w",
err,
)
}
return chat, nil
}
func (s *PostgreSQLStore) GetChatByID(
ctx context.Context,
chatID string,
callerID string,
) (domain.Chat, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var chat domain.Chat
err := s.pool.QueryRow(
queryContext,
`
SELECT
chat.id::text,
chat.title,
chat.created_at,
array_agg(
member.user_id::text
ORDER BY member.position
)
FROM chats AS chat
JOIN chat_members AS caller
ON caller.chat_id = chat.id
AND caller.user_id = $2
JOIN chat_members AS member
ON member.chat_id = chat.id
WHERE chat.id = $1
GROUP BY
chat.id,
chat.title,
chat.created_at
`,
chatID,
callerID,
).Scan(
&chat.ID,
&chat.Title,
&chat.CreatedAt,
&chat.MemberIDs,
)
if errors.Is(err, pgx.ErrNoRows) {
return domain.Chat{}, ErrNotFound
}
if err != nil {
return domain.Chat{}, fmt.Errorf("select chat by id: %w", err)
}
return chat, nil
}
func (s *PostgreSQLStore) GetChatsForUser(
ctx context.Context,
userID string,
limit int,
cursor *domain.ChatCursor,
) ([]domain.Chat, bool, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var (
rows pgx.Rows
err error
)
if cursor == nil {
rows, err = s.pool.Query(
queryContext,
`
SELECT
chat.id::text,
chat.title,
chat.created_at,
array_agg(
member.user_id::text
ORDER BY member.position
)
FROM chat_members AS own_membership
JOIN chats AS chat
ON chat.id = own_membership.chat_id
JOIN chat_members AS member
ON member.chat_id = chat.id
WHERE own_membership.user_id = $1
GROUP BY
chat.id,
chat.title,
chat.created_at
ORDER BY
chat.created_at,
chat.id
LIMIT $2
`,
userID,
limit+1,
)
} else {
rows, err = s.pool.Query(
queryContext,
`
SELECT
chat.id::text,
chat.title,
chat.created_at,
array_agg(
member.user_id::text
ORDER BY member.position
)
FROM chat_members AS own_membership
JOIN chats AS chat
ON chat.id = own_membership.chat_id
JOIN chat_members AS member
ON member.chat_id = chat.id
WHERE own_membership.user_id = $1
AND (chat.created_at, chat.id) > ($2, $3)
GROUP BY
chat.id,
chat.title,
chat.created_at
ORDER BY
chat.created_at,
chat.id
LIMIT $4
`,
userID,
cursor.CreatedAt,
cursor.ChatID,
limit+1,
)
}
if err != nil {
return nil, false, fmt.Errorf(
"query chats for user: %w",
err,
)
}
defer rows.Close()
items := make([]domain.Chat, 0, limit+1)
for rows.Next() {
var chat domain.Chat
if err := rows.Scan(
&chat.ID,
&chat.Title,
&chat.CreatedAt,
&chat.MemberIDs,
); err != nil {
return nil, false, fmt.Errorf(
"scan chat page: %w",
err,
)
}
items = append(items, chat)
}
if err := rows.Err(); err != nil {
return nil, false, fmt.Errorf(
"iterate chat page: %w",
err,
)
}
hasMore := len(items) > limit
if hasMore {
items = items[:limit]
}
return items, hasMore, nil
}
+5
View File
@@ -0,0 +1,5 @@
package postgres
import "mtusi2026lab5/internal/application"
var _ application.Repository = (*PostgreSQLStore)(nil)
+8
View File
@@ -0,0 +1,8 @@
package postgres
import "mtusi2026lab5/internal/domain"
var (
ErrNotFound = domain.ErrNotFound
ErrConflict = domain.ErrConflict
)
+423
View File
@@ -0,0 +1,423 @@
package postgres
import (
"bytes"
"context"
"errors"
"fmt"
"time"
"mtusi2026lab5/internal/application"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
)
func (s *PostgreSQLStore) CreateMessageIdempotently(
ctx context.Context,
write application.IdempotentMessageWrite,
) (domain.Message, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
transaction, err := s.pool.BeginTx(queryContext, pgx.TxOptions{})
if err != nil {
return domain.Message{}, fmt.Errorf("begin idempotent message transaction: %w", err)
}
defer func() { _ = transaction.Rollback(queryContext) }()
var isMember bool
err = transaction.QueryRow(
queryContext,
`
SELECT EXISTS (
SELECT 1
FROM chat_members
WHERE chat_id = $1
AND user_id = $2
)
`,
write.ChatID,
write.ActorID,
).Scan(&isMember)
if err != nil {
return domain.Message{}, fmt.Errorf("check chat membership: %w", err)
}
if !isMember {
return domain.Message{}, ErrNotFound
}
attachmentUUIDs := make([]uuid.UUID, len(write.AttachmentIDs))
for index, attachmentID := range write.AttachmentIDs {
parsedID, parseErr := uuid.Parse(attachmentID)
if parseErr != nil {
return domain.Message{}, fmt.Errorf("parse validated attachment id: %w", parseErr)
}
attachmentUUIDs[index] = parsedID
}
if len(attachmentUUIDs) > 0 {
rows, queryError := transaction.Query(
queryContext,
`
SELECT id::text, status
FROM attachments
WHERE chat_id = $1
AND id = ANY($2::uuid[])
ORDER BY id
FOR UPDATE
`,
write.ChatID,
attachmentUUIDs,
)
if queryError != nil {
return domain.Message{}, fmt.Errorf("lock message attachments: %w", queryError)
}
availableCount := 0
eligibleCount := 0
for rows.Next() {
var attachmentID string
var status domain.AttachmentStatus
if queryError = rows.Scan(&attachmentID, &status); queryError != nil {
rows.Close()
return domain.Message{}, fmt.Errorf("scan locked message attachment: %w", queryError)
}
availableCount++
if status != domain.AttachmentStatusFailed {
eligibleCount++
}
}
queryError = rows.Err()
rows.Close()
if queryError != nil {
return domain.Message{}, fmt.Errorf("iterate locked message attachments: %w", queryError)
}
if availableCount != len(attachmentUUIDs) {
return domain.Message{}, ErrNotFound
}
if eligibleCount != len(attachmentUUIDs) {
return domain.Message{}, application.ErrAttachmentNotReady
}
}
_, err = transaction.Exec(
queryContext,
`
DELETE FROM message_idempotency
WHERE user_id = $1
AND method = $2
AND canonical_path = $3
AND idempotency_key = $4
AND expires_at <= CURRENT_TIMESTAMP
`,
write.ActorID,
write.Method,
write.CanonicalPath,
write.Key,
)
if err != nil {
return domain.Message{}, fmt.Errorf("delete expired idempotency key: %w", err)
}
message := domain.Message{
ID: uuid.NewString(),
ChatID: write.ChatID,
SenderID: write.ActorID,
Text: write.Text,
AttachmentIDs: append([]string(nil), write.AttachmentIDs...),
}
var storedHash []byte
var storedMessageID string
err = transaction.QueryRow(
queryContext,
`
INSERT INTO message_idempotency (
user_id,
method,
canonical_path,
idempotency_key,
request_hash,
message_id,
expires_at
)
VALUES (
$1,
$2,
$3,
$4,
$5,
$6,
CURRENT_TIMESTAMP + $7 * INTERVAL '1 second'
)
ON CONFLICT DO NOTHING
RETURNING request_hash, message_id::text
`,
write.ActorID,
write.Method,
write.CanonicalPath,
write.Key,
write.RequestHash[:],
message.ID,
int64(write.TTL/time.Second),
).Scan(&storedHash, &storedMessageID)
if errors.Is(err, pgx.ErrNoRows) {
err = transaction.QueryRow(
queryContext,
`
SELECT request_hash, message_id::text
FROM message_idempotency
WHERE user_id = $1
AND method = $2
AND canonical_path = $3
AND idempotency_key = $4
`,
write.ActorID,
write.Method,
write.CanonicalPath,
write.Key,
).Scan(&storedHash, &storedMessageID)
if err != nil {
return domain.Message{}, fmt.Errorf("read idempotency result: %w", err)
}
if !bytes.Equal(storedHash, write.RequestHash[:]) {
return domain.Message{}, application.ErrIdempotencyConflict
}
err = transaction.QueryRow(
queryContext,
`
SELECT
id::text,
chat_id::text,
sender_id::text,
text,
created_at,
COALESCE(
ARRAY(
SELECT attachment_id::text
FROM message_attachments
WHERE message_id = messages.id
ORDER BY position
), ARRAY[]::text[]
)
FROM messages
WHERE id = $1
`,
storedMessageID,
).Scan(
&message.ID,
&message.ChatID,
&message.SenderID,
&message.Text,
&message.CreatedAt,
&message.AttachmentIDs,
)
if err != nil {
return domain.Message{}, fmt.Errorf("read idempotent message: %w", err)
}
if err = transaction.Commit(queryContext); err != nil {
return domain.Message{}, fmt.Errorf("commit idempotency replay: %w", err)
}
return message, nil
}
if err != nil {
return domain.Message{}, fmt.Errorf("claim idempotency key: %w", err)
}
err = transaction.QueryRow(
queryContext,
`
INSERT INTO messages (
id,
chat_id,
sender_id,
text
)
VALUES ($1, $2, $3, $4)
RETURNING created_at
`,
message.ID,
message.ChatID,
message.SenderID,
message.Text,
).Scan(&message.CreatedAt)
if err != nil {
return domain.Message{}, fmt.Errorf("insert message: %w", err)
}
if len(attachmentUUIDs) > 0 {
_, err = transaction.Exec(
queryContext,
`
INSERT INTO message_attachments (
message_id,
chat_id,
attachment_id,
position
)
SELECT $1, $2, attachment_id, (ordinality - 1)::smallint
FROM unnest($3::uuid[]) WITH ORDINALITY AS input(attachment_id, ordinality)
`,
message.ID,
message.ChatID,
attachmentUUIDs,
)
if err != nil {
return domain.Message{}, fmt.Errorf("link message attachments: %w", err)
}
}
if err = transaction.Commit(queryContext); err != nil {
return domain.Message{}, fmt.Errorf("commit idempotent message: %w", err)
}
return message, nil
}
func (s *PostgreSQLStore) GetMessages(
ctx context.Context,
chatID string,
callerID string,
limit int,
cursor *domain.MessageCursor,
) ([]domain.Message, bool, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var isMember bool
err := s.pool.QueryRow(
queryContext,
`
SELECT EXISTS (
SELECT 1
FROM chat_members
WHERE chat_id = $1
AND user_id = $2
)
`,
chatID,
callerID,
).Scan(&isMember)
if err != nil {
return nil, false, fmt.Errorf(
"check chat membership: %w",
err,
)
}
if !isMember {
return nil, false, ErrNotFound
}
var rows pgx.Rows
if cursor == nil {
rows, err = s.pool.Query(
queryContext,
`
SELECT
id::text,
chat_id::text,
sender_id::text,
text,
created_at,
COALESCE(
ARRAY(
SELECT attachment_id::text
FROM message_attachments
WHERE message_id = messages.id
ORDER BY position
), ARRAY[]::text[]
)
FROM messages
WHERE chat_id = $1
ORDER BY
created_at,
id
LIMIT $2
`,
chatID,
limit+1,
)
} else {
rows, err = s.pool.Query(
queryContext,
`
SELECT
id::text,
chat_id::text,
sender_id::text,
text,
created_at,
COALESCE(
ARRAY(
SELECT attachment_id::text
FROM message_attachments
WHERE message_id = messages.id
ORDER BY position
), ARRAY[]::text[]
)
FROM messages
WHERE chat_id = $1
AND (created_at, id) > ($2, $3)
ORDER BY
created_at,
id
LIMIT $4
`,
chatID,
cursor.CreatedAt,
cursor.MessageID,
limit+1,
)
}
if err != nil {
return nil, false, fmt.Errorf(
"query messages: %w",
err,
)
}
defer rows.Close()
items := make([]domain.Message, 0, limit+1)
for rows.Next() {
var message domain.Message
if err := rows.Scan(
&message.ID,
&message.ChatID,
&message.SenderID,
&message.Text,
&message.CreatedAt,
&message.AttachmentIDs,
); err != nil {
return nil, false, fmt.Errorf(
"scan message page: %w",
err,
)
}
items = append(items, message)
}
if err := rows.Err(); err != nil {
return nil, false, fmt.Errorf(
"iterate message page: %w",
err,
)
}
hasMore := len(items) > limit
if hasMore {
items = items[:limit]
}
return items, hasMore, nil
}
+108
View File
@@ -0,0 +1,108 @@
package postgres
import (
"context"
"errors"
"fmt"
"time"
"mtusi2026lab5/internal/domain"
"github.com/jackc/pgx/v5"
)
func (s *PostgreSQLStore) CreateSession(
ctx context.Context,
tokenHash []byte,
userID string,
expiresAt time.Time,
) error {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
_, err := s.pool.Exec(
queryContext,
`
INSERT INTO sessions (
token_hash,
user_id,
expires_at
)
VALUES ($1, $2, $3)
`,
tokenHash,
userID,
expiresAt,
)
if err != nil {
return fmt.Errorf("insert session: %w", err)
}
return nil
}
func (s *PostgreSQLStore) GetUserBySession(
ctx context.Context,
tokenHash []byte,
) (domain.User, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var user domain.User
err := s.pool.QueryRow(
queryContext,
`
SELECT
app_user.id::text,
app_user.username,
app_user.display_name,
app_user.created_at
FROM sessions AS session
JOIN users AS app_user
ON app_user.id = session.user_id
WHERE session.token_hash = $1
AND session.expires_at > CURRENT_TIMESTAMP
`,
tokenHash,
).Scan(
&user.ID,
&user.Username,
&user.DisplayName,
&user.CreatedAt,
)
if errors.Is(err, pgx.ErrNoRows) {
return domain.User{}, ErrNotFound
}
if err != nil {
return domain.User{}, fmt.Errorf(
"select user by session: %w",
err,
)
}
return user, nil
}
func (s *PostgreSQLStore) DeleteSession(
ctx context.Context,
tokenHash []byte,
) error {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
_, err := s.pool.Exec(
queryContext,
`
DELETE FROM sessions
WHERE token_hash = $1
`,
tokenHash,
)
if err != nil {
return fmt.Errorf("delete session: %w", err)
}
return nil
}
+40
View File
@@ -0,0 +1,40 @@
package postgres
import (
"context"
"time"
"github.com/jackc/pgx/v5/pgxpool"
)
type PostgreSQLStore struct {
pool *pgxpool.Pool
queryTimeout time.Duration
}
func NewPostgreSQLStore(
pool *pgxpool.Pool,
queryTimeout time.Duration,
) *PostgreSQLStore {
return &PostgreSQLStore{
pool: pool,
queryTimeout: queryTimeout,
}
}
func (s *PostgreSQLStore) Ping(ctx context.Context) error {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
return s.pool.Ping(queryContext)
}
func (s *PostgreSQLStore) Close() {
s.pool.Close()
}
func (s *PostgreSQLStore) withTimeout(
ctx context.Context,
) (context.Context, context.CancelFunc) {
return context.WithTimeout(ctx, s.queryTimeout)
}
+144
View File
@@ -0,0 +1,144 @@
package postgres
import (
"context"
"errors"
"fmt"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
func (s *PostgreSQLStore) CreateUser(
ctx context.Context,
username string,
displayName string,
passwordHash string,
) (domain.User, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
user := domain.User{
ID: uuid.NewString(),
Username: username,
DisplayName: displayName,
}
err := s.pool.QueryRow(
queryContext,
`
INSERT INTO users (
id,
username,
display_name,
password_hash
)
VALUES ($1, $2, $3, $4)
RETURNING created_at
`,
user.ID,
user.Username,
user.DisplayName,
passwordHash,
).Scan(&user.CreatedAt)
if err == nil {
return user, nil
}
var postgresError *pgconn.PgError
if errors.As(err, &postgresError) &&
postgresError.Code == "23505" &&
postgresError.ConstraintName == "users_username_unique" {
return domain.User{}, ErrConflict
}
return domain.User{}, fmt.Errorf("insert user: %w", err)
}
func (s *PostgreSQLStore) GetUserByID(
ctx context.Context,
userID string,
) (domain.User, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var user domain.User
err := s.pool.QueryRow(
queryContext,
`
SELECT
id::text,
username,
display_name,
created_at
FROM users
WHERE id = $1
`,
userID,
).Scan(
&user.ID,
&user.Username,
&user.DisplayName,
&user.CreatedAt,
)
if errors.Is(err, pgx.ErrNoRows) {
return domain.User{}, ErrNotFound
}
if err != nil {
return domain.User{}, fmt.Errorf("select user by id: %w", err)
}
return user, nil
}
func (s *PostgreSQLStore) GetUserByUsername(
ctx context.Context,
username string,
) (domain.User, string, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var (
user domain.User
passwordHash string
)
err := s.pool.QueryRow(
queryContext,
`
SELECT
id::text,
username,
display_name,
created_at,
password_hash
FROM users
WHERE username = $1
`,
username,
).Scan(
&user.ID,
&user.Username,
&user.DisplayName,
&user.CreatedAt,
&passwordHash,
)
if errors.Is(err, pgx.ErrNoRows) {
return domain.User{}, "", ErrNotFound
}
if err != nil {
return domain.User{}, "", fmt.Errorf(
"select user by username: %w",
err,
)
}
return user, passwordHash, nil
}
+175
View File
@@ -0,0 +1,175 @@
package redis
import (
"context"
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
goredis "github.com/redis/go-redis/v9"
)
const chatKeyPrefix = "chat:v2:"
var ErrMiss = errors.New("cache miss")
// ChatCache хранит только производную копию неизменяемых данных чата.
// PostgreSQL остаётся источником истины.
type ChatCache interface {
Get(ctx context.Context, chatID string) (domain.Chat, error)
Set(ctx context.Context, chat domain.Chat) error
}
type RedisChatCache struct {
client *goredis.Client
ttl time.Duration
operationTimeout time.Duration
}
func NewRedisChatCache(
redisURL string,
ttl time.Duration,
operationTimeout time.Duration,
poolSize int,
) (*RedisChatCache, error) {
options, err := goredis.ParseURL(strings.TrimSpace(redisURL))
if err != nil {
return nil, fmt.Errorf("parse Redis URL: %w", err)
}
options.DialTimeout = operationTimeout
options.ReadTimeout = operationTimeout
options.WriteTimeout = operationTimeout
options.PoolTimeout = operationTimeout
options.PoolSize = poolSize
options.MaxRetries = -1
return &RedisChatCache{
client: goredis.NewClient(options),
ttl: ttl,
operationTimeout: operationTimeout,
}, nil
}
func (c *RedisChatCache) Ping(ctx context.Context) error {
operationContext, cancel := c.withTimeout(ctx)
defer cancel()
if err := c.client.Ping(operationContext).Err(); err != nil {
return fmt.Errorf("ping Redis: %w", err)
}
return nil
}
func (c *RedisChatCache) Close() error {
return c.client.Close()
}
func (c *RedisChatCache) Get(
ctx context.Context,
chatID string,
) (domain.Chat, error) {
operationContext, cancel := c.withTimeout(ctx)
defer cancel()
payload, err := c.client.Get(
operationContext,
chatKey(chatID),
).Bytes()
if errors.Is(err, goredis.Nil) {
return domain.Chat{}, ErrMiss
}
if err != nil {
return domain.Chat{}, fmt.Errorf("get cached chat: %w", err)
}
var chat domain.Chat
if err = json.Unmarshal(payload, &chat); err != nil {
c.deleteInvalidValue(operationContext, chatID)
return domain.Chat{}, fmt.Errorf("decode cached chat: %w", err)
}
if err = validateCachedChat(chat, chatID); err != nil {
c.deleteInvalidValue(operationContext, chatID)
return domain.Chat{}, err
}
return chat, nil
}
func (c *RedisChatCache) Set(
ctx context.Context,
chat domain.Chat,
) error {
payload, err := json.Marshal(chat)
if err != nil {
return fmt.Errorf("encode chat for cache: %w", err)
}
operationContext, cancel := c.withTimeout(ctx)
defer cancel()
if err = c.client.Set(
operationContext,
chatKey(chat.ID),
payload,
c.ttl,
).Err(); err != nil {
return fmt.Errorf("cache chat: %w", err)
}
return nil
}
func (c *RedisChatCache) withTimeout(
ctx context.Context,
) (context.Context, context.CancelFunc) {
return context.WithTimeout(ctx, c.operationTimeout)
}
func (c *RedisChatCache) deleteInvalidValue(
ctx context.Context,
chatID string,
) {
_ = c.client.Del(ctx, chatKey(chatID)).Err()
}
func chatKey(chatID string) string {
return chatKeyPrefix + chatID
}
func validateCachedChat(chat domain.Chat, expectedID string) error {
if chat.ID != expectedID {
return errors.New("cached chat id does not match cache key")
}
if _, err := uuid.Parse(chat.ID); err != nil {
return errors.New("cached chat contains invalid id")
}
if strings.TrimSpace(chat.Title) == "" || chat.CreatedAt.IsZero() {
return errors.New("cached chat is incomplete")
}
if len(chat.MemberIDs) == 0 {
return errors.New("cached chat has no members")
}
seenMembers := make(map[string]struct{}, len(chat.MemberIDs))
for _, memberID := range chat.MemberIDs {
if _, err := uuid.Parse(memberID); err != nil {
return errors.New("cached chat contains invalid member id")
}
if _, exists := seenMembers[memberID]; exists {
return errors.New("cached chat contains duplicate member id")
}
seenMembers[memberID] = struct{}{}
}
return nil
}
var _ ChatCache = (*RedisChatCache)(nil)
@@ -0,0 +1,67 @@
package application
import (
"context"
"fmt"
"io"
"mtusi2026lab5/internal/domain"
)
type AttachmentDownload struct {
Body io.ReadCloser
ContentType string
Filename string
SizeBytes int64
}
func (s *Service) GetAttachment(ctx context.Context, attachmentID, actorID string) (domain.Attachment, error) {
return s.repository.GetAttachment(ctx, attachmentID, actorID)
}
func (s *Service) DownloadAttachment(ctx context.Context, attachmentID, actorID, variantName string) (AttachmentDownload, error) {
attachment, err := s.repository.GetAttachment(ctx, attachmentID, actorID)
if err != nil {
return AttachmentDownload{}, err
}
if attachment.Status != domain.AttachmentStatusReady {
return AttachmentDownload{}, ErrAttachmentNotReady
}
if s.objectStore == nil {
return AttachmentDownload{}, ErrStorageUnavailable
}
if variantName == "" {
variantName = "original"
}
key := attachment.ObjectKey
contentType := attachment.ContentType
sizeBytes := attachment.SizeBytes
filename := attachment.Filename
if variantName != "original" {
found := false
for _, variant := range attachment.Variants {
if variant.Name == variantName {
key = variant.ObjectKey
contentType = variant.ContentType
sizeBytes = variant.SizeBytes
filename = variant.Name + ".jpg"
found = true
break
}
}
if !found {
return AttachmentDownload{}, domain.ErrNotFound
}
}
object, err := s.objectStore.Get(ctx, key)
if err != nil {
return AttachmentDownload{}, fmt.Errorf("%w: get object", ErrStorageUnavailable)
}
if object.Body == nil || object.SizeBytes != sizeBytes {
if object.Body != nil {
_ = object.Body.Close()
}
return AttachmentDownload{}, fmt.Errorf("%w: object metadata mismatch", ErrStorageUnavailable)
}
return AttachmentDownload{Body: object.Body, ContentType: contentType, Filename: filename, SizeBytes: sizeBytes}, nil
}
+176
View File
@@ -0,0 +1,176 @@
package application
import (
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"image"
_ "image/jpeg"
_ "image/png"
"io"
"os"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
)
const currentAttachmentPipelineVersion = 1
func (s *Service) UploadAttachment(ctx context.Context, command UploadAttachmentCommand) (domain.Attachment, error) {
if s.objectStore == nil {
return domain.Attachment{}, ErrStorageUnavailable
}
queueRepository, ok := s.repository.(AttachmentQueueRepository)
if !ok {
return domain.Attachment{}, fmt.Errorf("attachment queue repository is not configured")
}
if command.Body == nil {
return domain.Attachment{}, fmt.Errorf("%w: attachment body is required", ErrInvalidInput)
}
if err := domain.ValidateAttachmentFilename(command.Filename); err != nil {
return domain.Attachment{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
if err := domain.ValidateAttachmentContentType(command.DeclaredContentType); err != nil {
return domain.Attachment{}, fmt.Errorf("%w: %v", ErrUnsupportedMediaType, err)
}
if _, err := s.repository.GetChatByID(ctx, command.ChatID, command.ActorID); err != nil {
return domain.Attachment{}, err
}
if err := acquireAttachmentSlot(ctx, s.attachmentUploadSlots); err != nil {
return domain.Attachment{}, fmt.Errorf("%w: wait for upload capacity", ErrStorageUnavailable)
}
defer releaseAttachmentSlot(s.attachmentUploadSlots)
stagedFile, err := os.CreateTemp("", "mtusi-attachment-*")
if err != nil {
return domain.Attachment{}, fmt.Errorf("create bounded upload staging file: %w", err)
}
stagedPath := stagedFile.Name()
defer func() {
_ = stagedFile.Close()
_ = os.Remove(stagedPath)
}()
hasher := sha256.New()
sizeBytes, err := io.Copy(io.MultiWriter(stagedFile, hasher), io.LimitReader(command.Body, domain.MaxAttachmentSizeBytes+1))
if err != nil {
return domain.Attachment{}, fmt.Errorf("%w: read attachment body", ErrInvalidInput)
}
if sizeBytes > domain.MaxAttachmentSizeBytes {
return domain.Attachment{}, ErrPayloadTooLarge
}
if _, err = stagedFile.Seek(0, io.SeekStart); err != nil {
return domain.Attachment{}, fmt.Errorf("rewind staged attachment: %w", err)
}
imageConfig, format, err := image.DecodeConfig(stagedFile)
if err != nil {
return domain.Attachment{}, fmt.Errorf("%w: decode image header", ErrInvalidImage)
}
actualContentType, supported := contentTypeForImageFormat(format)
if !supported || actualContentType != command.DeclaredContentType {
return domain.Attachment{}, ErrUnsupportedMediaType
}
if imageConfig.Width < 1 || imageConfig.Height < 1 {
return domain.Attachment{}, ErrInvalidImage
}
if int64(imageConfig.Width) > int64(domain.MaxAttachmentPixels)/int64(imageConfig.Height) {
return domain.Attachment{}, ErrPayloadTooLarge
}
sha256Hex := hex.EncodeToString(hasher.Sum(nil))
if err = domain.ValidateReadyAttachmentMetadata(command.Filename, actualContentType, sizeBytes, sha256Hex, imageConfig.Width, imageConfig.Height); err != nil {
return domain.Attachment{}, fmt.Errorf("%w: %v", ErrInvalidImage, err)
}
if _, err = stagedFile.Seek(0, io.SeekStart); err != nil {
return domain.Attachment{}, fmt.Errorf("rewind staged attachment for validation: %w", err)
}
if err = s.validateCompleteImage(ctx, stagedFile); err != nil {
if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
return domain.Attachment{}, fmt.Errorf("%w: wait for image decoder", ErrStorageUnavailable)
}
return domain.Attachment{}, fmt.Errorf("%w: decode complete image", ErrInvalidImage)
}
now := s.now().UTC()
attachmentID := uuid.NewString()
attachment := domain.Attachment{
ID: attachmentID,
ChatID: command.ChatID,
OwnerID: command.ActorID,
Filename: command.Filename,
ObjectKey: "attachments/" + command.ChatID + "/" + attachmentID + "/original",
StagingKey: "staging/" + attachmentID + "/original",
ContentType: actualContentType,
SizeBytes: sizeBytes,
SHA256: sha256Hex,
Width: imageConfig.Width,
Height: imageConfig.Height,
PipelineVersion: currentAttachmentPipelineVersion,
Status: domain.AttachmentStatusQueued,
Variants: make([]domain.AttachmentVariant, 0),
CreatedAt: now,
UpdatedAt: now,
}
if _, err = stagedFile.Seek(0, io.SeekStart); err != nil {
return domain.Attachment{}, fmt.Errorf("rewind staged attachment for storage: %w", err)
}
if err = s.objectStore.Put(ctx, ObjectPut{Key: attachment.StagingKey, ContentType: attachment.ContentType, SizeBytes: attachment.SizeBytes, Body: stagedFile}); err != nil {
return domain.Attachment{}, fmt.Errorf("%w: put durable staging object", ErrStorageUnavailable)
}
job := domain.AttachmentJob{
SchemaVersion: 1,
JobID: uuid.NewString(),
Type: domain.AttachmentJobType,
AttachmentID: attachment.ID,
PipelineVersion: attachment.PipelineVersion,
Attempt: 1,
MaxAttempts: s.jobMaxAttempts,
Status: domain.AttachmentJobQueued,
AvailableAt: now,
CreatedAt: now,
UpdatedAt: now,
}
attachment, err = queueRepository.CreateQueuedAttachment(ctx, attachment, job)
if err != nil {
// A failed COMMIT response is ambiguous. Preserve staging so a committed
// job can still finish and an uncommitted orphan can be retained/cleaned.
return domain.Attachment{}, fmt.Errorf("persist queued attachment: %w", err)
}
if attachment.Variants == nil {
attachment.Variants = make([]domain.AttachmentVariant, 0)
}
return attachment, nil
}
func acquireAttachmentSlot(ctx context.Context, slots chan struct{}) error {
select {
case slots <- struct{}{}:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func releaseAttachmentSlot(slots chan struct{}) { <-slots }
func (s *Service) validateCompleteImage(ctx context.Context, body io.Reader) error {
if err := acquireAttachmentSlot(ctx, s.attachmentDecodeSlots); err != nil {
return err
}
defer releaseAttachmentSlot(s.attachmentDecodeSlots)
_, _, err := image.Decode(body)
return err
}
func contentTypeForImageFormat(format string) (string, bool) {
switch format {
case "png":
return "image/png", true
case "jpeg":
return "image/jpeg", true
default:
return "", false
}
}
+155
View File
@@ -0,0 +1,155 @@
package application_test
import (
"bytes"
"context"
"errors"
"image"
"image/color"
"image/png"
"io"
"sync"
"testing"
"time"
"mtusi2026lab5/internal/adapter/memory"
. "mtusi2026lab5/internal/application"
"mtusi2026lab5/internal/domain"
)
type fakeObjectStore struct {
mu sync.Mutex
objects map[string][]byte
putError error
}
func newFakeObjectStore() *fakeObjectStore { return &fakeObjectStore{objects: make(map[string][]byte)} }
func (store *fakeObjectStore) Put(_ context.Context, object ObjectPut) error {
if store.putError != nil {
return store.putError
}
payload, err := io.ReadAll(object.Body)
if err != nil {
return err
}
store.mu.Lock()
store.objects[object.Key] = payload
store.mu.Unlock()
return nil
}
func (store *fakeObjectStore) Get(_ context.Context, key string) (ObjectContent, error) {
store.mu.Lock()
defer store.mu.Unlock()
payload, ok := store.objects[key]
if !ok {
return ObjectContent{}, errors.New("not found")
}
return ObjectContent{Body: io.NopCloser(bytes.NewReader(payload)), SizeBytes: int64(len(payload))}, nil
}
func (store *fakeObjectStore) Delete(_ context.Context, key string) error {
store.mu.Lock()
delete(store.objects, key)
store.mu.Unlock()
return nil
}
type interruptedReader struct{}
func (interruptedReader) Read([]byte) (int, error) { return 0, errors.New("injected read failure") }
func newAttachmentService(t *testing.T, objects ObjectStore) (*Service, string, string) {
t.Helper()
legacy := memory.NewMemoryStore()
repository := memory.NewMemoryRepository(legacy)
user, err := repository.CreateUser(context.Background(), "uploader", "Uploader", "hash")
if err != nil {
t.Fatal(err)
}
chat, err := repository.CreateChat(context.Background(), "Images", []string{user.ID})
if err != nil {
t.Fatal(err)
}
codec, err := NewCursorCodec("attachment-test-key-with-more-than-thirty-two-bytes")
if err != nil {
t.Fatal(err)
}
service, err := NewService(repository, codec, time.Hour, WithObjectStore(objects), WithJobMaxAttempts(5))
if err != nil {
t.Fatal(err)
}
return service, user.ID, chat.ID
}
func testPNG(t *testing.T) []byte {
t.Helper()
var payload bytes.Buffer
img := image.NewRGBA(image.Rect(0, 0, 320, 200))
img.Set(0, 0, color.RGBA{R: 255, A: 255})
if err := png.Encode(&payload, img); err != nil {
t.Fatal(err)
}
return payload.Bytes()
}
func TestUploadAttachmentDurablyQueuesStagingObject(t *testing.T) {
objects := newFakeObjectStore()
service, actorID, chatID := newAttachmentService(t, objects)
payload := testPNG(t)
attachment, err := service.UploadAttachment(context.Background(), UploadAttachmentCommand{
ActorID: actorID, ChatID: chatID, Filename: "photo.png",
DeclaredContentType: "image/png", Body: bytes.NewReader(payload),
})
if err != nil {
t.Fatal(err)
}
if attachment.Status != domain.AttachmentStatusQueued {
t.Fatalf("status=%s, want queued", attachment.Status)
}
if attachment.StagingKey == "" || attachment.ObjectKey == attachment.StagingKey {
t.Fatalf("staging/final keys are not separated: %+v", attachment)
}
objects.mu.Lock()
staged := append([]byte(nil), objects.objects[attachment.StagingKey]...)
objects.mu.Unlock()
if !bytes.Equal(staged, payload) {
t.Fatal("durable staging bytes differ")
}
}
func TestUploadAttachmentRejectsInvalidInputBeforeStaging(t *testing.T) {
objects := newFakeObjectStore()
service, actorID, chatID := newAttachmentService(t, objects)
cases := []struct {
name string
command UploadAttachmentCommand
target error
}{
{"unsafe filename", UploadAttachmentCommand{ActorID: actorID, ChatID: chatID, Filename: "../x.png", DeclaredContentType: "image/png", Body: bytes.NewReader(testPNG(t))}, ErrInvalidInput},
{"mime", UploadAttachmentCommand{ActorID: actorID, ChatID: chatID, Filename: "x.png", DeclaredContentType: "image/jpeg", Body: bytes.NewReader(testPNG(t))}, ErrUnsupportedMediaType},
{"corrupt", UploadAttachmentCommand{ActorID: actorID, ChatID: chatID, Filename: "x.png", DeclaredContentType: "image/png", Body: bytes.NewReader([]byte("broken"))}, ErrInvalidImage},
{"interrupted", UploadAttachmentCommand{ActorID: actorID, ChatID: chatID, Filename: "x.png", DeclaredContentType: "image/png", Body: interruptedReader{}}, ErrInvalidInput},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
if _, err := service.UploadAttachment(context.Background(), tc.command); !errors.Is(err, tc.target) {
t.Fatalf("error=%v, want %v", err, tc.target)
}
})
}
objects.mu.Lock()
count := len(objects.objects)
objects.mu.Unlock()
if count != 0 {
t.Fatalf("invalid requests staged %d objects", count)
}
}
func TestUploadAttachmentStorageFailureDoesNotCreateQueuedMetadata(t *testing.T) {
objects := newFakeObjectStore()
objects.putError = errors.New("storage down")
service, actorID, chatID := newAttachmentService(t, objects)
_, err := service.UploadAttachment(context.Background(), UploadAttachmentCommand{ActorID: actorID, ChatID: chatID, Filename: "x.png", DeclaredContentType: "image/png", Body: bytes.NewReader(testPNG(t))})
if !errors.Is(err, ErrStorageUnavailable) {
t.Fatalf("error=%v, want storage unavailable", err)
}
}
+55
View File
@@ -0,0 +1,55 @@
package application
import (
"context"
"fmt"
"mtusi2026lab5/internal/domain"
)
func (s *Service) CreateChat(ctx context.Context, command CreateChatCommand) (domain.Chat, error) {
if err := domain.ValidateChatInput(command.Title, command.MemberIDs, command.ActorID); err != nil {
return domain.Chat{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
return s.repository.CreateChat(ctx, command.Title, command.MemberIDs)
}
func (s *Service) GetChat(ctx context.Context, actorID, chatID string) (domain.Chat, error) {
return s.repository.GetChatByID(ctx, chatID, actorID)
}
func (s *Service) ListChats(
ctx context.Context,
actorID string,
limit int,
cursorToken string,
) (domain.ChatPage, error) {
var cursor *domain.ChatCursor
if cursorToken != "" {
decoded, err := s.cursors.DecodeChat(cursorToken, actorID)
if err != nil {
return domain.ChatPage{}, ErrInvalidCursor
}
cursor = decoded
}
items, hasMore, err := s.repository.GetChatsForUser(ctx, actorID, limit, cursor)
if err != nil {
return domain.ChatPage{}, err
}
page := domain.ChatPage{Items: items}
if page.Items == nil {
page.Items = make([]domain.Chat, 0)
}
if hasMore {
last := page.Items[len(page.Items)-1]
next, encodeErr := s.cursors.EncodeChat(domain.ChatCursor{
CreatedAt: last.CreatedAt, ChatID: last.ID, UserID: actorID,
})
if encodeErr != nil {
return domain.ChatPage{}, encodeErr
}
page.NextCursor = &next
}
return page, nil
}
+38
View File
@@ -0,0 +1,38 @@
package application
import "io"
type CreateUserCommand struct {
Username string
DisplayName string
Password string
}
type CreateSessionCommand struct {
Username string
Password string
}
type CreateChatCommand struct {
ActorID string
Title string
MemberIDs []string
}
type SendMessageCommand struct {
ActorID string
ChatID string
Text string
AttachmentIDs []string
Method string
CanonicalPath string
IdempotencyKey string
}
type UploadAttachmentCommand struct {
ActorID string
ChatID string
Filename string
DeclaredContentType string
Body io.Reader
}
+121
View File
@@ -0,0 +1,121 @@
package application
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"fmt"
"strings"
"time"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
)
const cursorVersion = 1
type CursorCodec struct {
key []byte
}
type cursorPayload struct {
Version int `json:"v"`
Kind string `json:"kind"`
CreatedAt string `json:"created_at"`
ID string `json:"id"`
ScopeID string `json:"scope_id"`
}
func NewCursorCodec(key string) (*CursorCodec, error) {
if len(key) < 32 {
return nil, fmt.Errorf("cursor signing key must contain at least 32 bytes")
}
return &CursorCodec{key: []byte(key)}, nil
}
func (c *CursorCodec) EncodeChat(cursor domain.ChatCursor) (string, error) {
return c.encode(cursorPayload{
Version: cursorVersion, Kind: "chat", CreatedAt: cursor.CreatedAt.UTC().Format(time.RFC3339Nano),
ID: cursor.ChatID, ScopeID: cursor.UserID,
})
}
func (c *CursorCodec) DecodeChat(token, expectedUserID string) (*domain.ChatCursor, error) {
payload, err := c.decode(token, "chat", expectedUserID)
if err != nil {
return nil, err
}
return &domain.ChatCursor{CreatedAt: payload.createdAt, ChatID: payload.id, UserID: payload.scopeID}, nil
}
func (c *CursorCodec) EncodeMessage(cursor domain.MessageCursor) (string, error) {
return c.encode(cursorPayload{
Version: cursorVersion, Kind: "message", CreatedAt: cursor.CreatedAt.UTC().Format(time.RFC3339Nano),
ID: cursor.MessageID, ScopeID: cursor.ChatID,
})
}
func (c *CursorCodec) DecodeMessage(token, expectedChatID string) (*domain.MessageCursor, error) {
payload, err := c.decode(token, "message", expectedChatID)
if err != nil {
return nil, err
}
return &domain.MessageCursor{CreatedAt: payload.createdAt, MessageID: payload.id, ChatID: payload.scopeID}, nil
}
func (c *CursorCodec) encode(payload cursorPayload) (string, error) {
encodedPayload, err := json.Marshal(payload)
if err != nil {
return "", fmt.Errorf("encode cursor payload: %w", err)
}
mac := hmac.New(sha256.New, c.key)
_, _ = mac.Write(encodedPayload)
return base64.RawURLEncoding.EncodeToString(encodedPayload) + "." +
base64.RawURLEncoding.EncodeToString(mac.Sum(nil)), nil
}
type decodedCursor struct {
createdAt time.Time
id string
scopeID string
}
func (c *CursorCodec) decode(token, expectedKind, expectedScopeID string) (decodedCursor, error) {
parts := strings.Split(token, ".")
if len(parts) != 2 {
return decodedCursor{}, ErrInvalidCursor
}
payloadBytes, err := base64.RawURLEncoding.DecodeString(parts[0])
if err != nil {
return decodedCursor{}, ErrInvalidCursor
}
signature, err := base64.RawURLEncoding.DecodeString(parts[1])
if err != nil {
return decodedCursor{}, ErrInvalidCursor
}
mac := hmac.New(sha256.New, c.key)
_, _ = mac.Write(payloadBytes)
if !hmac.Equal(signature, mac.Sum(nil)) {
return decodedCursor{}, ErrInvalidCursor
}
var payload cursorPayload
if err = json.Unmarshal(payloadBytes, &payload); err != nil ||
payload.Version != cursorVersion || payload.Kind != expectedKind ||
payload.ScopeID != expectedScopeID {
return decodedCursor{}, ErrInvalidCursor
}
createdAt, err := time.Parse(time.RFC3339Nano, payload.CreatedAt)
if err != nil {
return decodedCursor{}, ErrInvalidCursor
}
if _, err = uuid.Parse(payload.ID); err != nil {
return decodedCursor{}, ErrInvalidCursor
}
if _, err = uuid.Parse(payload.ScopeID); err != nil {
return decodedCursor{}, ErrInvalidCursor
}
return decodedCursor{createdAt: createdAt.UTC(), id: payload.ID, scopeID: payload.ScopeID}, nil
}
+96
View File
@@ -0,0 +1,96 @@
package application
import (
"encoding/base64"
"errors"
"strings"
"testing"
"time"
"mtusi2026lab5/internal/domain"
)
const cursorTestKey = "cursor-test-key-with-more-than-thirty-two-bytes"
func TestCursorCodecRoundTrip(t *testing.T) {
codec, err := NewCursorCodec(cursorTestKey)
if err != nil {
t.Fatal(err)
}
expected := domain.MessageCursor{
CreatedAt: time.Date(2026, 10, 18, 12, 30, 0, 123, time.UTC),
MessageID: "42eea32e-d9b5-4bc6-b4fc-94e9b0477adf",
ChatID: "9fa3f49c-e62e-4209-8414-d6d5f69805bf",
}
token, err := codec.EncodeMessage(expected)
if err != nil {
t.Fatal(err)
}
actual, err := codec.DecodeMessage(token, expected.ChatID)
if err != nil {
t.Fatal(err)
}
if *actual != expected {
t.Fatalf("cursor changed after round trip: got %#v, want %#v", *actual, expected)
}
}
func TestCursorCodecRejectsTamperingAndWrongScope(t *testing.T) {
codec, err := NewCursorCodec(cursorTestKey)
if err != nil {
t.Fatal(err)
}
token, err := codec.EncodeChat(domain.ChatCursor{
CreatedAt: time.Now().UTC(),
ChatID: "42eea32e-d9b5-4bc6-b4fc-94e9b0477adf",
UserID: "9fa3f49c-e62e-4209-8414-d6d5f69805bf",
})
if err != nil {
t.Fatal(err)
}
parts := strings.Split(token, ".")
signature, err := base64.RawURLEncoding.DecodeString(parts[1])
if err != nil {
t.Fatal(err)
}
signature[0] ^= 1
tampered := parts[0] + "." + base64.RawURLEncoding.EncodeToString(signature)
if _, err = codec.DecodeChat(tampered, "9fa3f49c-e62e-4209-8414-d6d5f69805bf"); !errors.Is(err, ErrInvalidCursor) {
t.Fatalf("tampered cursor: got %v, want ErrInvalidCursor", err)
}
if _, err = codec.DecodeChat(token, "e6ca4af0-69ed-4784-8ce0-ee035299fe08"); !errors.Is(err, ErrInvalidCursor) {
t.Fatalf("wrong scope: got %v, want ErrInvalidCursor", err)
}
if _, err = codec.DecodeMessage(token, "9fa3f49c-e62e-4209-8414-d6d5f69805bf"); !errors.Is(err, ErrInvalidCursor) {
t.Fatalf("wrong cursor kind: got %v, want ErrInvalidCursor", err)
}
}
func TestCursorCodecRequiresStrongSharedKey(t *testing.T) {
if _, err := NewCursorCodec("too-short"); err == nil {
t.Fatal("expected short cursor signing key to be rejected")
}
}
func TestCursorCodecRejectsSignedInvalidFieldTypesBeforeSQL(t *testing.T) {
codec, err := NewCursorCodec(cursorTestKey)
if err != nil {
t.Fatal(err)
}
chatID := "9fa3f49c-e62e-4209-8414-d6d5f69805bf"
validMessageID := "42eea32e-d9b5-4bc6-b4fc-94e9b0477adf"
testCases := []cursorPayload{
{Version: cursorVersion, Kind: "message", CreatedAt: "not-a-time", ID: validMessageID, ScopeID: chatID},
{Version: cursorVersion, Kind: "message", CreatedAt: time.Now().UTC().Format(time.RFC3339Nano), ID: "not-a-uuid", ScopeID: chatID},
}
for _, payload := range testCases {
token, encodeErr := codec.encode(payload)
if encodeErr != nil {
t.Fatal(encodeErr)
}
if _, decodeErr := codec.DecodeMessage(token, chatID); !errors.Is(decodeErr, ErrInvalidCursor) {
t.Fatalf("invalid signed cursor returned %v, want ErrInvalidCursor", decodeErr)
}
}
}
+16
View File
@@ -0,0 +1,16 @@
package application
import "errors"
var (
ErrInvalidCursor = errors.New("invalid cursor")
ErrInvalidCredentials = errors.New("invalid credentials")
ErrInvalidInput = errors.New("invalid input")
ErrCredentialState = errors.New("invalid stored credential state")
ErrIdempotencyConflict = errors.New("idempotency key is already used for another request")
ErrAttachmentNotReady = errors.New("attachment is not ready")
ErrPayloadTooLarge = errors.New("payload too large")
ErrUnsupportedMediaType = errors.New("unsupported media type")
ErrInvalidImage = errors.New("invalid image")
ErrStorageUnavailable = errors.New("object storage unavailable")
)
+88
View File
@@ -0,0 +1,88 @@
package application
import (
"context"
"crypto/sha256"
"encoding/json"
"fmt"
"mtusi2026lab5/internal/domain"
"github.com/google/uuid"
)
type canonicalMessageRequest struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}
func (s *Service) SendMessage(ctx context.Context, command SendMessageCommand) (domain.Message, error) {
attachmentIDs := append([]string(nil), command.AttachmentIDs...)
if attachmentIDs == nil {
attachmentIDs = make([]string, 0)
}
if err := domain.ValidateMessageInput(command.Text, attachmentIDs); err != nil {
return domain.Message{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
for index, attachmentID := range attachmentIDs {
attachmentIDs[index] = uuid.MustParse(attachmentID).String()
}
canonicalBody, err := json.Marshal(canonicalMessageRequest{
Text: command.Text,
AttachmentIDs: attachmentIDs,
})
if err != nil {
return domain.Message{}, fmt.Errorf("canonicalize message request: %w", err)
}
return s.repository.CreateMessageIdempotently(ctx, IdempotentMessageWrite{
ActorID: command.ActorID,
ChatID: command.ChatID,
Text: command.Text,
AttachmentIDs: attachmentIDs,
Method: command.Method,
CanonicalPath: command.CanonicalPath,
Key: command.IdempotencyKey,
RequestHash: sha256.Sum256(canonicalBody),
TTL: s.idempotencyTTL,
})
}
func (s *Service) ListMessages(
ctx context.Context,
actorID string,
chatID string,
limit int,
cursorToken string,
) (domain.MessagePage, error) {
var cursor *domain.MessageCursor
if cursorToken != "" {
decoded, err := s.cursors.DecodeMessage(cursorToken, chatID)
if err != nil {
return domain.MessagePage{}, ErrInvalidCursor
}
cursor = decoded
}
items, hasMore, err := s.repository.GetMessages(ctx, chatID, actorID, limit, cursor)
if err != nil {
return domain.MessagePage{}, err
}
page := domain.MessagePage{Items: items}
if page.Items == nil {
page.Items = make([]domain.Message, 0)
}
if hasMore {
last := page.Items[len(page.Items)-1]
next, encodeErr := s.cursors.EncodeMessage(domain.MessageCursor{
CreatedAt: last.CreatedAt, MessageID: last.ID, ChatID: chatID,
})
if encodeErr != nil {
return domain.MessagePage{}, encodeErr
}
page.NextCursor = &next
}
return page, nil
}
+80
View File
@@ -0,0 +1,80 @@
package application
import (
"context"
"io"
"time"
"mtusi2026lab5/internal/domain"
)
type UserRepository interface {
CreateUser(ctx context.Context, username, displayName, passwordHash string) (domain.User, error)
GetUserByUsername(ctx context.Context, username string) (domain.User, string, error)
}
type SessionRepository interface {
CreateSession(ctx context.Context, tokenHash []byte, userID string, expiresAt time.Time) error
GetUserBySession(ctx context.Context, tokenHash []byte) (domain.User, error)
DeleteSession(ctx context.Context, tokenHash []byte) error
}
type ChatRepository interface {
CreateChat(ctx context.Context, title string, memberIDs []string) (domain.Chat, error)
GetChatByID(ctx context.Context, chatID, callerID string) (domain.Chat, error)
GetChatsForUser(ctx context.Context, userID string, limit int, cursor *domain.ChatCursor) ([]domain.Chat, bool, error)
}
type IdempotentMessageWrite struct {
ActorID string
ChatID string
Text string
AttachmentIDs []string
Method string
CanonicalPath string
Key string
RequestHash [32]byte
TTL time.Duration
}
type MessageRepository interface {
CreateMessageIdempotently(ctx context.Context, write IdempotentMessageWrite) (domain.Message, error)
GetMessages(ctx context.Context, chatID, callerID string, limit int, cursor *domain.MessageCursor) ([]domain.Message, bool, error)
}
type AttachmentRepository interface {
CreateAttachment(ctx context.Context, attachment domain.Attachment) (domain.Attachment, error)
MarkAttachmentReady(ctx context.Context, attachmentID string, updatedAt time.Time) (domain.Attachment, error)
MarkAttachmentFailed(ctx context.Context, attachmentID, errorCode string, updatedAt time.Time) error
GetAttachment(ctx context.Context, attachmentID, callerID string) (domain.Attachment, error)
}
type AttachmentQueueRepository interface {
CreateQueuedAttachment(ctx context.Context, attachment domain.Attachment, job domain.AttachmentJob) (domain.Attachment, error)
}
type Repository interface {
UserRepository
SessionRepository
ChatRepository
MessageRepository
AttachmentRepository
}
type ObjectPut struct {
Key string
ContentType string
SizeBytes int64
Body io.Reader
}
type ObjectContent struct {
Body io.ReadCloser
SizeBytes int64
}
type ObjectStore interface {
Put(ctx context.Context, object ObjectPut) error
Get(ctx context.Context, key string) (ObjectContent, error)
Delete(ctx context.Context, key string) error
}
+86
View File
@@ -0,0 +1,86 @@
package application
import (
"fmt"
"time"
)
const MinimumIdempotencyTTL = 24 * time.Hour
const defaultAttachmentCleanupTimeout = time.Second
const defaultAttachmentUploadConcurrency = 4
const defaultAttachmentDecodeConcurrency = 1
const defaultJobMaxAttempts = 5
type ServiceOption func(*Service) error
type Service struct {
repository Repository
cursors *CursorCodec
sessionTTL time.Duration
idempotencyTTL time.Duration
now func() time.Time
objectStore ObjectStore
attachmentCleanupTimeout time.Duration
attachmentUploadSlots chan struct{}
attachmentDecodeSlots chan struct{}
jobMaxAttempts int
}
func NewService(repository Repository, cursors *CursorCodec, sessionTTL time.Duration, options ...ServiceOption) (*Service, error) {
if repository == nil {
return nil, fmt.Errorf("repository is required")
}
if cursors == nil {
return nil, fmt.Errorf("cursor codec is required")
}
if sessionTTL <= 0 {
return nil, fmt.Errorf("session TTL must be positive")
}
service := &Service{
repository: repository,
cursors: cursors,
sessionTTL: sessionTTL,
idempotencyTTL: MinimumIdempotencyTTL,
now: func() time.Time { return time.Now().UTC() },
attachmentCleanupTimeout: defaultAttachmentCleanupTimeout,
attachmentUploadSlots: make(chan struct{}, defaultAttachmentUploadConcurrency),
attachmentDecodeSlots: make(chan struct{}, defaultAttachmentDecodeConcurrency),
jobMaxAttempts: defaultJobMaxAttempts,
}
for _, option := range options {
if err := option(service); err != nil {
return nil, err
}
}
return service, nil
}
func WithIdempotencyTTL(ttl time.Duration) ServiceOption {
return func(service *Service) error {
if ttl < MinimumIdempotencyTTL {
return fmt.Errorf("idempotency TTL must be at least %s", MinimumIdempotencyTTL)
}
service.idempotencyTTL = ttl
return nil
}
}
func WithObjectStore(objectStore ObjectStore) ServiceOption {
return func(service *Service) error {
if objectStore == nil {
return fmt.Errorf("object store is required")
}
service.objectStore = objectStore
return nil
}
}
func WithJobMaxAttempts(attempts int) ServiceOption {
return func(service *Service) error {
if attempts < 1 {
return fmt.Errorf("job max attempts must be positive")
}
service.jobMaxAttempts = attempts
return nil
}
}
+57
View File
@@ -0,0 +1,57 @@
package application
import (
"context"
"errors"
"fmt"
"mtusi2026lab5/internal/domain"
"mtusi2026lab5/internal/security"
)
const dummyPasswordHash = "$argon2id$v=19$m=19456,t=2,p=1$" +
"AAAAAAAAAAAAAAAAAAAAAA$" +
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
func (s *Service) CreateSession(ctx context.Context, command CreateSessionCommand) (domain.Session, error) {
user, passwordHash, err := s.repository.GetUserByUsername(ctx, command.Username)
userNotFound := errors.Is(err, domain.ErrNotFound)
if userNotFound {
passwordHash = dummyPasswordHash
} else if err != nil {
return domain.Session{}, err
}
passwordMatches, verifyErr := security.VerifyPassword(command.Password, passwordHash)
if verifyErr != nil {
return domain.Session{}, fmt.Errorf("%w: %v", ErrCredentialState, verifyErr)
}
if userNotFound || !passwordMatches {
return domain.Session{}, ErrInvalidCredentials
}
token, tokenHash, err := security.GenerateSessionToken()
if err != nil {
return domain.Session{}, fmt.Errorf("generate session token: %w", err)
}
expiresAt := s.now().Add(s.sessionTTL)
if err = s.repository.CreateSession(ctx, tokenHash, user.ID, expiresAt); err != nil {
return domain.Session{}, err
}
return domain.Session{
Token: token, TokenType: "Bearer", ExpiresAt: expiresAt, User: user,
}, nil
}
func (s *Service) Authenticate(ctx context.Context, token string) (domain.User, []byte, error) {
tokenHash := security.HashSessionToken(token)
user, err := s.repository.GetUserBySession(ctx, tokenHash)
if err != nil {
return domain.User{}, nil, err
}
return user, tokenHash, nil
}
func (s *Service) DeleteSession(ctx context.Context, tokenHash []byte) error {
return s.repository.DeleteSession(ctx, tokenHash)
}
+29
View File
@@ -0,0 +1,29 @@
package application
import (
"context"
"fmt"
"mtusi2026lab5/internal/domain"
"mtusi2026lab5/internal/security"
)
func (s *Service) CreateUser(ctx context.Context, command CreateUserCommand) (domain.User, error) {
if err := domain.ValidateUser(command.Username, command.DisplayName); err != nil {
return domain.User{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
if err := security.ValidatePassword(command.Password); err != nil {
return domain.User{}, fmt.Errorf("%w: %v", ErrInvalidInput, err)
}
passwordHash, err := security.HashPassword(command.Password)
if err != nil {
return domain.User{}, fmt.Errorf("hash password: %w", err)
}
return s.repository.CreateUser(
ctx,
command.Username,
command.DisplayName,
passwordHash,
)
}
+540
View File
@@ -0,0 +1,540 @@
package config
import (
"errors"
"fmt"
"net"
"os"
"regexp"
"strconv"
"strings"
"time"
)
type Config struct {
HTTPHost string
HTTPPort string
InstanceID string
SessionTTL time.Duration
IdempotencyTTL time.Duration
SessionCookieSecure bool
CursorSigningKey string
DatabaseURL string
DatabaseMaxConns int32
DatabaseMinConns int32
DatabaseMaxConnLifetime time.Duration
DatabaseMaxConnIdleTime time.Duration
DatabaseHealthCheckPeriod time.Duration
DatabaseConnectTimeout time.Duration
DatabaseQueryTimeout time.Duration
RedisURL string
RedisCacheTTL time.Duration
RedisOperationTimeout time.Duration
RedisPoolSize int
S3Endpoint string
S3Region string
S3Bucket string
S3AccessKeyID string
S3SecretAccessKey string
S3OperationTimeout time.Duration
BrokerURL string
WorkerConcurrency int
JobMaxAttempts int
JobTimeout time.Duration
JobRetryBase time.Duration
JobRetryMax time.Duration
JobLease time.Duration
StagingRetention time.Duration
StagingCleanupInterval time.Duration
ReadinessTimeout time.Duration
ShutdownDrainDelay time.Duration
ShutdownTimeout time.Duration
}
func Load() (Config, error) { return load(true, true) }
func LoadWorker() (Config, error) { return load(false, true) }
func LoadDispatcher() (Config, error) { return load(false, false) }
func load(requireCursor, requireS3 bool) (Config, error) {
instanceID, err := instanceIDFromEnv()
if err != nil {
return Config{}, err
}
sessionTTL, err := secondsDurationFromEnv(
"SESSION_TTL_SECONDS",
3600,
)
if err != nil {
return Config{}, err
}
idempotencyTTL, err := secondsDurationFromEnv(
"IDEMPOTENCY_TTL_SECONDS",
86400,
)
if err != nil {
return Config{}, err
}
sessionCookieSecure, err := boolFromEnv("SESSION_COOKIE_SECURE", false)
if err != nil {
return Config{}, err
}
databaseURL, err := requiredValueOrFile(
"DATABASE_URL",
"DATABASE_URL_FILE",
)
if err != nil {
return Config{}, err
}
cursorSigningKey, err := roleValueOrFile(requireCursor,
"CURSOR_SIGNING_KEY",
"CURSOR_SIGNING_KEY_FILE",
)
if err != nil {
return Config{}, err
}
s3AccessKeyID, err := roleValueOrFile(requireS3,
"S3_ACCESS_KEY_ID",
"S3_ACCESS_KEY_ID_FILE",
)
if err != nil {
return Config{}, err
}
s3SecretAccessKey, err := roleValueOrFile(requireS3,
"S3_SECRET_ACCESS_KEY",
"S3_SECRET_ACCESS_KEY_FILE",
)
if err != nil {
return Config{}, err
}
s3OperationTimeout, err := durationFromEnv("S3_OPERATION_TIMEOUT", 5*time.Second)
if err != nil {
return Config{}, err
}
brokerURL, err := optionalValueOrFile("BROKER_URL", "BROKER_URL_FILE")
if err != nil {
return Config{}, err
}
workerConcurrency, err := int32FromEnv("WORKER_CONCURRENCY", 2, 1)
if err != nil {
return Config{}, err
}
jobMaxAttempts, err := int32FromEnv("JOB_MAX_ATTEMPTS", 5, 1)
if err != nil {
return Config{}, err
}
jobTimeout, err := secondsDurationFromEnv("JOB_TIMEOUT_SECONDS", 60)
if err != nil {
return Config{}, err
}
jobRetryBase, err := durationFromEnv("JOB_RETRY_BASE", 250*time.Millisecond)
if err != nil {
return Config{}, err
}
jobRetryMax, err := durationFromEnv("JOB_RETRY_MAX", 4*time.Second)
if err != nil {
return Config{}, err
}
jobLease, err := secondsDurationFromEnv("JOB_LEASE_SECONDS", 75)
if err != nil {
return Config{}, err
}
stagingRetention, err := secondsDurationFromEnv("STAGING_RETENTION_SECONDS", 86400)
if err != nil {
return Config{}, err
}
stagingCleanupInterval, err := secondsDurationFromEnv("STAGING_CLEANUP_INTERVAL_SECONDS", 30)
if err != nil {
return Config{}, err
}
databaseMaxConns, err := int32FromEnv("DB_MAX_CONNS", 10, 1)
if err != nil {
return Config{}, err
}
databaseMinConns, err := int32FromEnv("DB_MIN_CONNS", 2, 0)
if err != nil {
return Config{}, err
}
databaseMaxConnLifetime, err := durationFromEnv(
"DB_MAX_CONN_LIFETIME",
30*time.Minute,
)
if err != nil {
return Config{}, err
}
databaseMaxConnIdleTime, err := durationFromEnv(
"DB_MAX_CONN_IDLE_TIME",
5*time.Minute,
)
if err != nil {
return Config{}, err
}
databaseHealthCheckPeriod, err := durationFromEnv(
"DB_HEALTH_CHECK_PERIOD",
30*time.Second,
)
if err != nil {
return Config{}, err
}
databaseConnectTimeout, err := durationFromEnv(
"DB_CONNECT_TIMEOUT",
5*time.Second,
)
if err != nil {
return Config{}, err
}
databaseQueryTimeout, err := durationFromEnv(
"DB_QUERY_TIMEOUT",
3*time.Second,
)
if err != nil {
return Config{}, err
}
redisURL, err := optionalValueOrFile("CACHE_URL", "CACHE_URL_FILE")
if err != nil {
return Config{}, err
}
redisCacheTTL, err := durationFromEnv(
"CACHE_TTL",
5*time.Minute,
)
if err != nil {
return Config{}, err
}
redisOperationTimeout, err := durationFromEnv(
"CACHE_OPERATION_TIMEOUT",
250*time.Millisecond,
)
if err != nil {
return Config{}, err
}
redisPoolSize, err := int32FromEnv("CACHE_POOL_SIZE", 10, 1)
if err != nil {
return Config{}, err
}
readinessTimeout, err := durationFromEnv(
"READINESS_TIMEOUT",
2*time.Second,
)
if err != nil {
return Config{}, err
}
shutdownDrainDelay, err := durationFromEnv(
"SHUTDOWN_DRAIN_DELAY",
2*time.Second,
)
if err != nil {
return Config{}, err
}
shutdownTimeout, err := durationFromEnv(
"SHUTDOWN_TIMEOUT",
10*time.Second,
)
if err != nil {
return Config{}, err
}
if databaseMinConns > databaseMaxConns {
return Config{}, errors.New(
"DB_MIN_CONNS must not be greater than DB_MAX_CONNS",
)
}
if idempotencyTTL < 24*time.Hour {
return Config{}, errors.New(
"IDEMPOTENCY_TTL_SECONDS must be at least 86400",
)
}
if shutdownDrainDelay >= shutdownTimeout {
return Config{}, errors.New(
"SHUTDOWN_DRAIN_DELAY must be less than SHUTDOWN_TIMEOUT",
)
}
if jobRetryMax < jobRetryBase {
return Config{}, errors.New("JOB_RETRY_MAX must not be less than JOB_RETRY_BASE")
}
if jobLease <= jobTimeout {
return Config{}, errors.New("JOB_LEASE_SECONDS must be greater than JOB_TIMEOUT_SECONDS")
}
return Config{
HTTPHost: envOrDefault("APP_HOST", "0.0.0.0"),
HTTPPort: envOrDefault("APP_PORT", "8080"),
InstanceID: instanceID,
SessionTTL: sessionTTL,
IdempotencyTTL: idempotencyTTL,
SessionCookieSecure: sessionCookieSecure,
CursorSigningKey: cursorSigningKey,
DatabaseURL: databaseURL,
DatabaseMaxConns: databaseMaxConns,
DatabaseMinConns: databaseMinConns,
DatabaseMaxConnLifetime: databaseMaxConnLifetime,
DatabaseMaxConnIdleTime: databaseMaxConnIdleTime,
DatabaseHealthCheckPeriod: databaseHealthCheckPeriod,
DatabaseConnectTimeout: databaseConnectTimeout,
DatabaseQueryTimeout: databaseQueryTimeout,
RedisURL: redisURL,
RedisCacheTTL: redisCacheTTL,
RedisOperationTimeout: redisOperationTimeout,
RedisPoolSize: int(redisPoolSize),
S3Endpoint: envOrDefault("S3_ENDPOINT", "http://minio:9000"),
S3Region: envOrDefault("S3_REGION", "us-east-1"),
S3Bucket: envOrDefault("S3_BUCKET", "messenger-attachments"),
S3AccessKeyID: s3AccessKeyID,
S3SecretAccessKey: s3SecretAccessKey,
S3OperationTimeout: s3OperationTimeout,
BrokerURL: brokerURL,
WorkerConcurrency: int(workerConcurrency),
JobMaxAttempts: int(jobMaxAttempts),
JobTimeout: jobTimeout,
JobRetryBase: jobRetryBase,
JobRetryMax: jobRetryMax,
JobLease: jobLease,
StagingRetention: stagingRetention,
StagingCleanupInterval: stagingCleanupInterval,
ReadinessTimeout: readinessTimeout,
ShutdownDrainDelay: shutdownDrainDelay,
ShutdownTimeout: shutdownTimeout,
}, nil
}
var instanceIDPattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$`)
func instanceIDFromEnv() (string, error) {
instanceID := strings.TrimSpace(os.Getenv("INSTANCE_ID"))
if instanceID == "" {
hostname, err := os.Hostname()
if err != nil {
return "", fmt.Errorf("resolve instance id from hostname: %w", err)
}
instanceID = hostname
}
if !instanceIDPattern.MatchString(instanceID) {
return "", errors.New(
"INSTANCE_ID or hostname must match [A-Za-z0-9][A-Za-z0-9._-]{0,127}",
)
}
return instanceID, nil
}
func (c Config) HTTPAddress() string {
return net.JoinHostPort(c.HTTPHost, c.HTTPPort)
}
func roleValueOrFile(required bool, valueEnv, fileEnv string) (string, error) {
if required {
return requiredValueOrFile(valueEnv, fileEnv)
}
return optionalValueOrFile(valueEnv, fileEnv)
}
func requiredValueOrFile(valueEnv, fileEnv string) (string, error) {
value, valueExists := os.LookupEnv(valueEnv)
filePath, fileExists := os.LookupEnv(fileEnv)
if valueExists && fileExists {
return "", fmt.Errorf(
"%s and %s must not be set at the same time",
valueEnv,
fileEnv,
)
}
if valueExists {
value = strings.TrimSpace(value)
if value == "" {
return "", fmt.Errorf("%s must not be empty", valueEnv)
}
return value, nil
}
if fileExists {
filePath = strings.TrimSpace(filePath)
if filePath == "" {
return "", fmt.Errorf("%s must not be empty", fileEnv)
}
data, err := os.ReadFile(filePath)
if err != nil {
return "", fmt.Errorf("read %s: %w", fileEnv, err)
}
value = strings.TrimSpace(string(data))
if value == "" {
return "", fmt.Errorf("file from %s must not be empty", fileEnv)
}
return value, nil
}
return "", fmt.Errorf("%s or %s must be set", valueEnv, fileEnv)
}
func optionalValueOrFile(valueEnv, fileEnv string) (string, error) {
value, valueExists := os.LookupEnv(valueEnv)
filePath, fileExists := os.LookupEnv(fileEnv)
if valueExists && fileExists {
return "", fmt.Errorf(
"%s and %s must not be set at the same time",
valueEnv,
fileEnv,
)
}
if valueExists {
value = strings.TrimSpace(value)
if value == "" {
return "", fmt.Errorf("%s must not be empty", valueEnv)
}
return value, nil
}
if fileExists {
filePath = strings.TrimSpace(filePath)
if filePath == "" {
return "", fmt.Errorf("%s must not be empty", fileEnv)
}
data, err := os.ReadFile(filePath)
if err != nil {
return "", fmt.Errorf("read %s: %w", fileEnv, err)
}
value = strings.TrimSpace(string(data))
if value == "" {
return "", fmt.Errorf("file from %s must not be empty", fileEnv)
}
return value, nil
}
return "", nil
}
func envOrDefault(name, fallback string) string {
value := strings.TrimSpace(os.Getenv(name))
if value == "" {
return fallback
}
return value
}
func int32FromEnv(name string, fallback, minimum int32) (int32, error) {
raw := strings.TrimSpace(os.Getenv(name))
if raw == "" {
return fallback, nil
}
value, err := strconv.ParseInt(raw, 10, 32)
if err != nil {
return 0, fmt.Errorf("%s must be an integer: %w", name, err)
}
if value < int64(minimum) {
return 0, fmt.Errorf("%s must be at least %d", name, minimum)
}
return int32(value), nil
}
func boolFromEnv(name string, fallback bool) (bool, error) {
raw := strings.TrimSpace(os.Getenv(name))
if raw == "" {
return fallback, nil
}
value, err := strconv.ParseBool(raw)
if err != nil {
return false, fmt.Errorf("%s must be true or false: %w", name, err)
}
return value, nil
}
func durationFromEnv(name string, fallback time.Duration) (time.Duration, error) {
raw := strings.TrimSpace(os.Getenv(name))
if raw == "" {
return fallback, nil
}
value, err := time.ParseDuration(raw)
if err != nil {
return 0, fmt.Errorf(
"%s must be a Go duration such as 3s or 5m: %w",
name,
err,
)
}
if value <= 0 {
return 0, fmt.Errorf("%s must be positive", name)
}
return value, nil
}
func secondsDurationFromEnv(
name string,
fallbackSeconds int64,
) (time.Duration, error) {
raw := strings.TrimSpace(os.Getenv(name))
if raw == "" {
raw = strconv.FormatInt(fallbackSeconds, 10)
}
seconds, err := strconv.ParseInt(raw, 10, 64)
if err != nil {
return 0, fmt.Errorf(
"%s must be an integer number of seconds: %w",
name,
err,
)
}
if seconds <= 0 {
return 0, fmt.Errorf("%s must be positive", name)
}
duration, err := time.ParseDuration(raw + "s")
if err != nil {
return 0, fmt.Errorf("%s is too large: %w", name, err)
}
return duration, nil
}
+35
View File
@@ -0,0 +1,35 @@
package config
import "testing"
func TestInstanceIDFromEnvironment(t *testing.T) {
t.Setenv("INSTANCE_ID", "api-replica_01")
instanceID, err := instanceIDFromEnv()
if err != nil {
t.Fatal(err)
}
if instanceID != "api-replica_01" {
t.Fatalf("got %q, want api-replica_01", instanceID)
}
}
func TestInstanceIDRejectsUnsafeHeaderValue(t *testing.T) {
t.Setenv("INSTANCE_ID", "api-1\r\nX-Forged: true")
if _, err := instanceIDFromEnv(); err == nil {
t.Fatal("expected unsafe instance ID to be rejected")
}
}
func TestInstanceIDFallsBackToHostname(t *testing.T) {
t.Setenv("INSTANCE_ID", "")
instanceID, err := instanceIDFromEnv()
if err != nil {
t.Fatal(err)
}
if instanceID == "" {
t.Fatal("hostname fallback returned an empty instance ID")
}
}
+29
View File
@@ -0,0 +1,29 @@
package config
import "testing"
func TestBoolFromEnv(t *testing.T) {
t.Run("fallback", func(t *testing.T) {
t.Setenv("TEST_BOOL", "")
value, err := boolFromEnv("TEST_BOOL", true)
if err != nil || !value {
t.Fatalf("boolFromEnv() = %v, %v; want true, nil", value, err)
}
})
t.Run("explicit false", func(t *testing.T) {
t.Setenv("TEST_BOOL", "false")
value, err := boolFromEnv("TEST_BOOL", true)
if err != nil || value {
t.Fatalf("boolFromEnv() = %v, %v; want false, nil", value, err)
}
})
t.Run("invalid", func(t *testing.T) {
t.Setenv("TEST_BOOL", "sometimes")
_, err := boolFromEnv("TEST_BOOL", false)
if err == nil {
t.Fatal("boolFromEnv() error = nil, want validation error")
}
})
}
+40
View File
@@ -0,0 +1,40 @@
package database
import (
"context"
"fmt"
"mtusi2026lab5/internal/config"
"github.com/jackc/pgx/v5/pgxpool"
)
func Open(
ctx context.Context,
cfg config.Config,
) (*pgxpool.Pool, error) {
poolConfig, err := pgxpool.ParseConfig(cfg.DatabaseURL)
if err != nil {
return nil, fmt.Errorf("parse PostgreSQL configuration: %w", err)
}
poolConfig.MaxConns = cfg.DatabaseMaxConns
poolConfig.MinConns = cfg.DatabaseMinConns
poolConfig.MaxConnLifetime = cfg.DatabaseMaxConnLifetime
poolConfig.MaxConnIdleTime = cfg.DatabaseMaxConnIdleTime
poolConfig.HealthCheckPeriod = cfg.DatabaseHealthCheckPeriod
pool, err := pgxpool.NewWithConfig(ctx, poolConfig)
if err != nil {
return nil, fmt.Errorf("create PostgreSQL pool: %w", err)
}
// NewWithConfig создаёт структуру пула, но не гарантирует,
// что PostgreSQL уже доступен. Ping обеспечивает fail-fast.
if err := pool.Ping(ctx); err != nil {
pool.Close()
return nil, fmt.Errorf("ping PostgreSQL: %w", err)
}
return pool, nil
}
+126
View File
@@ -0,0 +1,126 @@
package domain
import (
"encoding/hex"
"fmt"
"strings"
"time"
"unicode"
"unicode/utf8"
)
const (
MaxAttachmentFilenameCodePoints = 255
MaxAttachmentSizeBytes = 10 * 1024 * 1024
MaxAttachmentPixels = 40_000_000
)
type AttachmentVariant struct {
Name string
ContentType string
SizeBytes int64
Width int
Height int
SHA256 string
ObjectKey string
PipelineVersion int
}
type AttachmentStatus string
const (
AttachmentStatusQueued AttachmentStatus = "queued"
AttachmentStatusProcessing AttachmentStatus = "processing"
AttachmentStatusReady AttachmentStatus = "ready"
AttachmentStatusFailed AttachmentStatus = "failed"
// Source-compatible alias for the lab4 reconciliation code.
AttachmentStatusPending = AttachmentStatusQueued
)
// Attachment contains metadata only. ObjectKey points to bytes in the
// private object store and must never be derived from Filename.
type Attachment struct {
ID string
ChatID string
OwnerID string
Filename string
ObjectKey string
ContentType string
SizeBytes int64
SHA256 string
Width int
Height int
StagingKey string
PipelineVersion int
Status AttachmentStatus
Variants []AttachmentVariant
ErrorCode *string
CreatedAt time.Time
UpdatedAt time.Time
}
func ValidateAttachmentFilename(filename string) error {
if !utf8.ValidString(filename) {
return fmt.Errorf("filename must be valid UTF-8")
}
filenameLength := utf8.RuneCountInString(filename)
if filenameLength < 1 || filenameLength > MaxAttachmentFilenameCodePoints {
return fmt.Errorf("filename length must be between 1 and %d code points", MaxAttachmentFilenameCodePoints)
}
if strings.TrimSpace(filename) == "" || filename == "." || filename == ".." {
return fmt.Errorf("filename is unsafe")
}
if strings.ContainsAny(filename, `/\\`) {
return fmt.Errorf("filename must not contain path separators")
}
for _, character := range filename {
if unicode.IsControl(character) {
return fmt.Errorf("filename must not contain control characters")
}
}
return nil
}
func ValidateAttachmentContentType(contentType string) error {
if contentType != "image/png" && contentType != "image/jpeg" {
return fmt.Errorf("content type must be image/png or image/jpeg")
}
return nil
}
// ValidateReadyAttachmentMetadata checks the bounded metadata produced after
// the upload stream has been identified, decoded and hashed. It deliberately
// does not trust an HTTP Content-Type header.
func ValidateReadyAttachmentMetadata(
filename string,
contentType string,
sizeBytes int64,
sha256Hex string,
width int,
height int,
) error {
if err := ValidateAttachmentFilename(filename); err != nil {
return err
}
if err := ValidateAttachmentContentType(contentType); err != nil {
return err
}
if sizeBytes < 1 || sizeBytes > MaxAttachmentSizeBytes {
return fmt.Errorf("attachment size must be between 1 and %d bytes", MaxAttachmentSizeBytes)
}
if width < 1 || height < 1 {
return fmt.Errorf("image dimensions must be positive and contain at most %d pixels", MaxAttachmentPixels)
}
if int64(width) > int64(MaxAttachmentPixels)/int64(height) {
return fmt.Errorf("image dimensions must be positive and contain at most %d pixels", MaxAttachmentPixels)
}
if len(sha256Hex) != 64 || sha256Hex != strings.ToLower(sha256Hex) {
return fmt.Errorf("sha256 must contain 64 lowercase hexadecimal characters")
}
decodedHash, err := hex.DecodeString(sha256Hex)
if err != nil || len(decodedHash) != 32 {
return fmt.Errorf("sha256 must contain 64 lowercase hexadecimal characters")
}
return nil
}
+55
View File
@@ -0,0 +1,55 @@
package domain
import "time"
const AttachmentJobType = "attachment.process.v1"
type AttachmentJobStatus string
const (
AttachmentJobQueued AttachmentJobStatus = "queued"
AttachmentJobProcessing AttachmentJobStatus = "processing"
AttachmentJobSucceeded AttachmentJobStatus = "succeeded"
AttachmentJobFailed AttachmentJobStatus = "failed"
AttachmentJobSuperseded AttachmentJobStatus = "superseded"
)
type AttachmentJob struct {
SchemaVersion int
JobID string
Type string
AttachmentID string
PipelineVersion int
Attempt int
MaxAttempts int
Status AttachmentJobStatus
ErrorCode *string
AvailableAt time.Time
LeaseUntil *time.Time
LeasedBy *string
ReplayCount int
CreatedAt time.Time
UpdatedAt time.Time
}
type AttachmentJobMessage struct {
SchemaVersion int `json:"schema_version"`
JobID string `json:"job_id"`
Type string `json:"type"`
AttachmentID string `json:"attachment_id"`
PipelineVersion int `json:"pipeline_version"`
Attempt int `json:"attempt"`
CreatedAt time.Time `json:"created_at"`
}
func (job AttachmentJob) Message() AttachmentJobMessage {
return AttachmentJobMessage{
SchemaVersion: job.SchemaVersion,
JobID: job.JobID,
Type: job.Type,
AttachmentID: job.AttachmentID,
PipelineVersion: job.PipelineVersion,
Attempt: job.Attempt,
CreatedAt: job.CreatedAt.UTC(),
}
}
+59
View File
@@ -0,0 +1,59 @@
package domain
import (
"math"
"strings"
"testing"
)
func TestValidateReadyAttachmentMetadata(t *testing.T) {
validHash := strings.Repeat("ab", 32)
testCases := []struct {
name string
filename string
contentType string
sizeBytes int64
sha256 string
width int
height int
wantError bool
}{
{name: "png", filename: "кот.png", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1},
{name: "jpeg at limits", filename: strings.Repeat("界", 255), contentType: "image/jpeg", sizeBytes: MaxAttachmentSizeBytes, sha256: validHash, width: 8_000, height: 5_000},
{name: "empty filename", filename: "", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "blank filename", filename: " ", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "dot segment", filename: "..", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "forward slash", filename: "folder/image.png", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "backslash", filename: `folder\\image.png`, contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "control character", filename: "image\n.png", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "C1 control character", filename: "image\u0085.png", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "invalid UTF-8", filename: string([]byte{'x', 0xff, '.', 'p', 'n', 'g'}), contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "filename too long", filename: strings.Repeat("a", 256), contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "unsupported MIME", filename: "image.gif", contentType: "image/gif", sizeBytes: 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "empty file", filename: "image.png", contentType: "image/png", sizeBytes: 0, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "file too large", filename: "image.png", contentType: "image/png", sizeBytes: MaxAttachmentSizeBytes + 1, sha256: validHash, width: 1, height: 1, wantError: true},
{name: "zero width", filename: "image.png", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 0, height: 1, wantError: true},
{name: "too many pixels", filename: "image.png", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: 8_001, height: 5_000, wantError: true},
{name: "dimension multiplication cannot overflow", filename: "image.png", contentType: "image/png", sizeBytes: 1, sha256: validHash, width: math.MaxInt, height: math.MaxInt, wantError: true},
{name: "short hash", filename: "image.png", contentType: "image/png", sizeBytes: 1, sha256: "ab", width: 1, height: 1, wantError: true},
{name: "uppercase hash", filename: "image.png", contentType: "image/png", sizeBytes: 1, sha256: strings.ToUpper(validHash), width: 1, height: 1, wantError: true},
{name: "non-hex hash", filename: "image.png", contentType: "image/png", sizeBytes: 1, sha256: strings.Repeat("zz", 32), width: 1, height: 1, wantError: true},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
err := ValidateReadyAttachmentMetadata(
testCase.filename,
testCase.contentType,
testCase.sizeBytes,
testCase.sha256,
testCase.width,
testCase.height,
)
if (err != nil) != testCase.wantError {
t.Fatalf("ValidateReadyAttachmentMetadata() error = %v, wantError %v", err, testCase.wantError)
}
})
}
}
+21
View File
@@ -0,0 +1,21 @@
package domain
import "time"
type Chat struct {
ID string
Title string
MemberIDs []string
CreatedAt time.Time
}
type ChatCursor struct {
CreatedAt time.Time
ChatID string
UserID string
}
type ChatPage struct {
Items []Chat
NextCursor *string
}
+8
View File
@@ -0,0 +1,8 @@
package domain
import "errors"
var (
ErrNotFound = errors.New("not found")
ErrConflict = errors.New("conflict")
)
+23
View File
@@ -0,0 +1,23 @@
package domain
import "time"
type Message struct {
ID string
ChatID string
SenderID string
Text string
AttachmentIDs []string
CreatedAt time.Time
}
type MessageCursor struct {
CreatedAt time.Time
MessageID string
ChatID string
}
type MessagePage struct {
Items []Message
NextCursor *string
}
+70
View File
@@ -0,0 +1,70 @@
package domain
import (
"strings"
"testing"
)
func TestValidateMessageInput(t *testing.T) {
validAttachment := "11111111-1111-4111-8111-111111111111"
testCases := []struct {
name string
text string
attachmentIDs []string
wantError bool
}{
{name: "text only", text: "hello"},
{name: "attachment only", attachmentIDs: []string{validAttachment}},
{name: "whitespace with attachment", text: " ", attachmentIDs: []string{validAttachment}},
{name: "empty", wantError: true},
{name: "whitespace only", text: " ", wantError: true},
{name: "text too long", text: strings.Repeat("界", 4001), wantError: true},
{name: "invalid attachment uuid", text: "hello", attachmentIDs: []string{"not-a-uuid"}, wantError: true},
{
name: "duplicate attachment uuid ignores case",
text: "hello",
attachmentIDs: []string{
"AAAAAAAA-AAAA-4AAA-8AAA-AAAAAAAAAAAA",
"aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
},
wantError: true,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
err := ValidateMessageInput(testCase.text, testCase.attachmentIDs)
if (err != nil) != testCase.wantError {
t.Fatalf("ValidateMessageInput() error = %v, wantError %v", err, testCase.wantError)
}
})
}
}
func TestValidateMessageInputAttachmentLimit(t *testing.T) {
attachmentIDs := []string{
"00000000-0000-4000-8000-000000000001",
"00000000-0000-4000-8000-000000000002",
"00000000-0000-4000-8000-000000000003",
"00000000-0000-4000-8000-000000000004",
"00000000-0000-4000-8000-000000000005",
"00000000-0000-4000-8000-000000000006",
"00000000-0000-4000-8000-000000000007",
"00000000-0000-4000-8000-000000000008",
"00000000-0000-4000-8000-000000000009",
"00000000-0000-4000-8000-000000000010",
}
if err := ValidateMessageInput("", attachmentIDs); err != nil {
t.Fatalf("10 attachments must be accepted: %v", err)
}
attachmentIDs = append(
attachmentIDs,
"00000000-0000-4000-8000-000000000011",
)
if err := ValidateMessageInput("hello", attachmentIDs); err == nil {
t.Fatal("11 attachments must be rejected")
}
}
+10
View File
@@ -0,0 +1,10 @@
package domain
import "time"
type Session struct {
Token string
TokenType string
ExpiresAt time.Time
User User
}
+11
View File
@@ -0,0 +1,11 @@
package domain
import "time"
// User is the transport-independent representation of a messenger user.
type User struct {
ID string
Username string
DisplayName string
CreatedAt time.Time
}
+101
View File
@@ -0,0 +1,101 @@
package domain
import (
"fmt"
"regexp"
"strings"
"unicode/utf8"
"github.com/google/uuid"
)
const MaxMessageAttachments = 10
var usernameRegex = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
func ValidateUser(username, displayName string) error {
if !usernameRegex.MatchString(username) {
return fmt.Errorf("username must match [a-z0-9_]{3,32}")
}
nameRunes := utf8.RuneCountInString(displayName)
if nameRunes < 1 || nameRunes > 100 {
return fmt.Errorf("display_name length must be between 1 and 100 code points")
}
if strings.TrimSpace(displayName) == "" {
return fmt.Errorf("display_name cannot be only whitespace")
}
return nil
}
// Validate remains as a compatibility convenience for existing callers.
func (u User) Validate() error {
return ValidateUser(u.Username, u.DisplayName)
}
func ValidateChatInput(title string, memberIDs []string, callerID string) error {
titleRunes := utf8.RuneCountInString(title)
if titleRunes < 1 || titleRunes > 100 || strings.TrimSpace(title) == "" {
return fmt.Errorf("invalid chat title")
}
if len(memberIDs) == 0 {
return fmt.Errorf("member_ids cannot be empty")
}
if len(memberIDs) > 100 {
return fmt.Errorf("member_ids must contain at most 100 users")
}
hasCaller := false
seen := make(map[string]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, err := uuid.Parse(id); err != nil {
return fmt.Errorf("invalid member uuid: %s", id)
}
if _, exists := seen[id]; exists {
return fmt.Errorf("duplicate member_id: %s", id)
}
seen[id] = struct{}{}
if id == callerID {
hasCaller = true
}
}
if !hasCaller {
return fmt.Errorf("caller must be in member_ids")
}
return nil
}
func ValidateMessageInput(text string, attachmentIDs []string) error {
textRunes := utf8.RuneCountInString(text)
if textRunes > 4000 {
return fmt.Errorf("message text length must be at most 4000 code points")
}
if len(attachmentIDs) > MaxMessageAttachments {
return fmt.Errorf("attachment_ids must contain at most %d items", MaxMessageAttachments)
}
seen := make(map[string]struct{}, len(attachmentIDs))
for _, attachmentID := range attachmentIDs {
parsedID, err := uuid.Parse(attachmentID)
if err != nil {
return fmt.Errorf("invalid attachment uuid: %s", attachmentID)
}
canonicalID := parsedID.String()
if _, exists := seen[canonicalID]; exists {
return fmt.Errorf("duplicate attachment_id: %s", attachmentID)
}
seen[canonicalID] = struct{}{}
}
if strings.TrimSpace(text) == "" && len(attachmentIDs) == 0 {
return fmt.Errorf("message must contain non-blank text or at least one attachment")
}
return nil
}
// ValidateMessageText remains for callers that create text-only messages.
func ValidateMessageText(text string) error {
return ValidateMessageInput(text, nil)
}
+203
View File
@@ -0,0 +1,203 @@
package reconcile
import (
"context"
"fmt"
"sort"
"time"
"mtusi2026lab5/internal/adapter/objectstore"
"mtusi2026lab5/internal/domain"
)
const (
IssueOrphanObject = "orphan_object"
IssueMissingObject = "missing_object"
IssueFailedObject = "failed_object"
IssueReferencedMissing = "referenced_missing_object"
)
type AttachmentRecord struct {
ID string
ObjectKey string
AdditionalObjectKeys []string
Status domain.AttachmentStatus
UpdatedAt time.Time
Referenced bool
}
type MetadataStore interface {
ListAttachmentInventory(ctx context.Context) ([]AttachmentRecord, error)
MarkAttachmentFailedIfUnreferenced(
ctx context.Context,
attachmentID string,
expectedStatus domain.AttachmentStatus,
updatedBefore time.Time,
errorCode string,
updatedAt time.Time,
) (bool, error)
}
type ObjectInventory interface {
List(ctx context.Context, prefix string) ([]objectstore.StoredObject, error)
Delete(ctx context.Context, key string) error
}
type Issue struct {
Kind string `json:"kind"`
AttachmentID string `json:"attachment_id,omitempty"`
ObjectKey string `json:"object_key"`
Protected bool `json:"protected,omitempty"`
Action string `json:"action"`
}
type Result struct {
DryRun bool `json:"dry_run"`
GracePeriod time.Duration `json:"-"`
GracePeriodSeconds int64 `json:"grace_period_seconds"`
ScannedAttachments int `json:"scanned_attachments"`
ScannedObjects int `json:"scanned_objects"`
Issues []Issue `json:"issues"`
DeletedObjects int `json:"deleted_objects"`
FailedAttachments int `json:"failed_attachments"`
Duration time.Duration `json:"-"`
DurationMillis int64 `json:"duration_ms"`
}
type Reconciler struct {
metadata MetadataStore
objects ObjectInventory
now func() time.Time
}
func New(metadata MetadataStore, objects ObjectInventory) (*Reconciler, error) {
if metadata == nil || objects == nil {
return nil, fmt.Errorf("metadata and object stores are required")
}
return &Reconciler{
metadata: metadata,
objects: objects,
now: func() time.Time { return time.Now().UTC() },
}, nil
}
func (r *Reconciler) Run(
ctx context.Context,
gracePeriod time.Duration,
apply bool,
) (Result, error) {
if gracePeriod <= 0 {
return Result{}, fmt.Errorf("grace period must be positive")
}
startedAt := r.now().UTC()
cutoff := startedAt.Add(-gracePeriod)
result := Result{
DryRun: !apply,
GracePeriod: gracePeriod,
GracePeriodSeconds: int64(gracePeriod / time.Second),
Issues: make([]Issue, 0),
}
attachments, err := r.metadata.ListAttachmentInventory(ctx)
if err != nil {
return Result{}, fmt.Errorf("list attachment metadata: %w", err)
}
objects, err := r.objects.List(ctx, "attachments/")
if err != nil {
return Result{}, fmt.Errorf("list attachment objects: %w", err)
}
result.ScannedAttachments = len(attachments)
result.ScannedObjects = len(objects)
attachmentsByKey := make(map[string]AttachmentRecord, len(attachments))
for _, attachment := range attachments {
attachmentsByKey[attachment.ObjectKey] = attachment
for _, objectKey := range attachment.AdditionalObjectKeys {
if objectKey != "" {
attachmentsByKey[objectKey] = attachment
}
}
}
objectsByKey := make(map[string]objectstore.StoredObject, len(objects))
for _, object := range objects {
objectsByKey[object.Key] = object
if _, exists := attachmentsByKey[object.Key]; exists {
continue
}
if object.LastModified.IsZero() || object.LastModified.After(cutoff) {
continue
}
issue := Issue{Kind: IssueOrphanObject, ObjectKey: object.Key, Action: "would_delete"}
if apply {
if err = r.objects.Delete(ctx, object.Key); err != nil {
return result, fmt.Errorf("delete orphan object %q: %w", object.Key, err)
}
issue.Action = "deleted"
result.DeletedObjects++
}
result.Issues = append(result.Issues, issue)
}
for _, attachment := range attachments {
if attachment.UpdatedAt.After(cutoff) {
continue
}
_, objectExists := objectsByKey[attachment.ObjectKey]
switch {
case attachment.Status == domain.AttachmentStatusReady && !objectExists:
issue := Issue{
Kind: IssueMissingObject,
AttachmentID: attachment.ID,
ObjectKey: attachment.ObjectKey,
Protected: attachment.Referenced,
Action: "would_mark_failed",
}
if attachment.Referenced {
issue.Kind = IssueReferencedMissing
issue.Action = "manual_repair_required"
} else if apply {
changed, markError := r.metadata.MarkAttachmentFailedIfUnreferenced(
ctx, attachment.ID, attachment.Status, cutoff,
"reconciler_missing_object", startedAt,
)
if markError != nil {
return result, fmt.Errorf("mark missing attachment %q failed: %w", attachment.ID, markError)
}
if changed {
issue.Action = "marked_failed"
result.FailedAttachments++
} else {
issue.Action = "skipped_concurrent_change"
}
}
result.Issues = append(result.Issues, issue)
case attachment.Status == domain.AttachmentStatusFailed && objectExists:
issue := Issue{
Kind: IssueFailedObject, AttachmentID: attachment.ID,
ObjectKey: attachment.ObjectKey, Protected: attachment.Referenced,
Action: "would_delete",
}
if attachment.Referenced {
issue.Action = "manual_repair_required"
} else if apply {
if err = r.objects.Delete(ctx, attachment.ObjectKey); err != nil {
return result, fmt.Errorf("delete failed attachment object %q: %w", attachment.ObjectKey, err)
}
issue.Action = "deleted"
result.DeletedObjects++
}
result.Issues = append(result.Issues, issue)
}
}
sort.Slice(result.Issues, func(i, j int) bool {
if result.Issues[i].ObjectKey == result.Issues[j].ObjectKey {
return result.Issues[i].Kind < result.Issues[j].Kind
}
return result.Issues[i].ObjectKey < result.Issues[j].ObjectKey
})
result.Duration = r.now().UTC().Sub(startedAt)
result.DurationMillis = result.Duration.Milliseconds()
return result, nil
}
+228
View File
@@ -0,0 +1,228 @@
package reconcile
import (
"context"
"errors"
"testing"
"time"
"mtusi2026lab5/internal/adapter/objectstore"
"mtusi2026lab5/internal/domain"
)
type fakeMetadataStore struct {
records []AttachmentRecord
markError error
skipMark bool
}
func (store *fakeMetadataStore) ListAttachmentInventory(
context.Context,
) ([]AttachmentRecord, error) {
return append([]AttachmentRecord(nil), store.records...), nil
}
func (store *fakeMetadataStore) MarkAttachmentFailedIfUnreferenced(
_ context.Context,
attachmentID string,
expectedStatus domain.AttachmentStatus,
updatedBefore time.Time,
errorCode string,
updatedAt time.Time,
) (bool, error) {
if store.markError != nil {
return false, store.markError
}
if store.skipMark {
return false, nil
}
for index := range store.records {
record := &store.records[index]
if record.ID != attachmentID || record.Status != expectedStatus ||
record.UpdatedAt.After(updatedBefore) || record.Referenced {
continue
}
record.Status = domain.AttachmentStatusFailed
record.UpdatedAt = updatedAt
_ = errorCode
return true, nil
}
return false, nil
}
func TestReconcilerDoesNotTouchActiveAttachments(t *testing.T) {
old := time.Now().UTC().Add(-2 * time.Hour)
metadata := &fakeMetadataStore{
records: []AttachmentRecord{
{
ID: "queued-old", ObjectKey: "attachments/queued-old",
AdditionalObjectKeys: []string{"attachments/queued-old-staging"},
Status: domain.AttachmentStatusQueued, UpdatedAt: old,
},
{
ID: "processing-old", ObjectKey: "attachments/processing-old",
Status: domain.AttachmentStatusProcessing, UpdatedAt: old,
},
},
}
objects := &fakeObjectInventory{objects: map[string]objectstore.StoredObject{
"attachments/queued-old": {Key: "attachments/queued-old", LastModified: old},
"attachments/queued-old-staging": {Key: "attachments/queued-old-staging", LastModified: old},
"attachments/processing-old": {Key: "attachments/processing-old", LastModified: old},
}}
reconciler, err := New(metadata, objects)
if err != nil {
t.Fatal(err)
}
result, err := reconciler.Run(context.Background(), time.Hour, true)
if err != nil {
t.Fatal(err)
}
if result.DeletedObjects != 0 || result.FailedAttachments != 0 {
t.Fatalf("active attachments must not be reconciled as stale: %+v", result)
}
if len(result.Issues) != 0 {
t.Fatalf("active attachments must not produce reconciliation issues: %+v", result.Issues)
}
if len(objects.objects) != 3 {
t.Fatal("reconciler deleted an object belonging to an active attachment")
}
}
type fakeObjectInventory struct {
objects map[string]objectstore.StoredObject
deleteError error
}
func (store *fakeObjectInventory) List(
context.Context,
string,
) ([]objectstore.StoredObject, error) {
objects := make([]objectstore.StoredObject, 0, len(store.objects))
for _, object := range store.objects {
objects = append(objects, object)
}
return objects, nil
}
func (store *fakeObjectInventory) Delete(_ context.Context, key string) error {
if store.deleteError != nil {
return store.deleteError
}
delete(store.objects, key)
return nil
}
func TestReconcilerDryRunApplyAndRepeat(t *testing.T) {
now := time.Now().UTC()
old := now.Add(-2 * time.Hour)
fresh := now.Add(-5 * time.Minute)
metadata := &fakeMetadataStore{records: []AttachmentRecord{
{
ID: "ready-present", ObjectKey: "attachments/ready-present",
AdditionalObjectKeys: []string{"attachments/ready-present-thumbnail"},
Status: domain.AttachmentStatusReady, UpdatedAt: old,
},
{ID: "ready-missing", ObjectKey: "attachments/ready-missing", Status: domain.AttachmentStatusReady, UpdatedAt: old},
{ID: "ready-used-missing", ObjectKey: "attachments/ready-used-missing", Status: domain.AttachmentStatusReady, UpdatedAt: old, Referenced: true},
{ID: "queued-old", ObjectKey: "attachments/queued-old", Status: domain.AttachmentStatusQueued, UpdatedAt: old},
{ID: "failed-old", ObjectKey: "attachments/failed-old", Status: domain.AttachmentStatusFailed, UpdatedAt: old},
{ID: "queued-fresh", ObjectKey: "attachments/queued-fresh", Status: domain.AttachmentStatusQueued, UpdatedAt: fresh},
}}
objects := &fakeObjectInventory{objects: map[string]objectstore.StoredObject{
"attachments/ready-present": {Key: "attachments/ready-present", LastModified: old},
"attachments/ready-present-thumbnail": {Key: "attachments/ready-present-thumbnail", LastModified: old},
"attachments/queued-old": {Key: "attachments/queued-old", LastModified: old},
"attachments/failed-old": {Key: "attachments/failed-old", LastModified: old},
"attachments/orphan-old": {Key: "attachments/orphan-old", LastModified: old},
"attachments/orphan-fresh": {Key: "attachments/orphan-fresh", LastModified: fresh},
}}
reconciler, err := New(metadata, objects)
if err != nil {
t.Fatal(err)
}
dryRun, err := reconciler.Run(context.Background(), time.Hour, false)
if err != nil {
t.Fatal(err)
}
if !dryRun.DryRun || len(dryRun.Issues) != 4 ||
dryRun.DeletedObjects != 0 || dryRun.FailedAttachments != 0 {
t.Fatalf("unexpected dry-run result: %+v", dryRun)
}
if len(objects.objects) != 6 {
t.Fatal("dry-run changed object storage")
}
for _, record := range metadata.records {
if record.ID == "ready-missing" && record.Status != domain.AttachmentStatusReady {
t.Fatal("dry-run changed metadata")
}
}
applied, err := reconciler.Run(context.Background(), time.Hour, true)
if err != nil {
t.Fatal(err)
}
if applied.DeletedObjects != 2 || applied.FailedAttachments != 1 {
t.Fatalf("unexpected apply result: %+v", applied)
}
if _, exists := objects.objects["attachments/orphan-old"]; exists {
t.Fatal("old orphan was not deleted")
}
if _, exists := objects.objects["attachments/orphan-fresh"]; !exists {
t.Fatal("fresh orphan must be protected by grace period")
}
if _, exists := objects.objects["attachments/ready-present"]; !exists {
t.Fatal("healthy object was deleted")
}
if _, exists := objects.objects["attachments/ready-present-thumbnail"]; !exists {
t.Fatal("managed variant object was deleted as an orphan")
}
if _, exists := objects.objects["attachments/queued-old"]; !exists {
t.Fatal("active queued attachment object was deleted")
}
for _, issue := range applied.Issues {
if issue.AttachmentID == "ready-used-missing" &&
(!issue.Protected || issue.Action != "manual_repair_required") {
t.Fatalf("referenced attachment was not protected: %+v", issue)
}
}
repeated, err := reconciler.Run(context.Background(), time.Hour, true)
if err != nil {
t.Fatal(err)
}
if repeated.DeletedObjects != 0 || repeated.FailedAttachments != 0 {
t.Fatalf("repeat must be mutation-idempotent: %+v", repeated)
}
if len(repeated.Issues) != 1 || !repeated.Issues[0].Protected {
t.Fatalf("repeat should retain only protected manual issue: %+v", repeated)
}
}
func TestReconcilerReportsMutationFailures(t *testing.T) {
old := time.Now().UTC().Add(-2 * time.Hour)
metadata := &fakeMetadataStore{records: []AttachmentRecord{
{ID: "missing", ObjectKey: "attachments/missing", Status: domain.AttachmentStatusReady, UpdatedAt: old},
}}
metadata.markError = errors.New("injected database failure")
objects := &fakeObjectInventory{objects: make(map[string]objectstore.StoredObject)}
reconciler, err := New(metadata, objects)
if err != nil {
t.Fatal(err)
}
if _, err = reconciler.Run(context.Background(), time.Hour, true); err == nil {
t.Fatal("injected database mutation failure was hidden")
}
metadata.records = nil
metadata.markError = nil
objects.objects["attachments/orphan"] = objectstore.StoredObject{
Key: "attachments/orphan", LastModified: old,
}
objects.deleteError = errors.New("injected object-store failure")
if _, err = reconciler.Run(context.Background(), time.Hour, true); err == nil {
t.Fatal("injected object-store mutation failure was hidden")
}
}
+164
View File
@@ -0,0 +1,164 @@
package security
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strings"
"unicode/utf8"
"golang.org/x/crypto/argon2"
)
const (
argonMemory uint32 = 19 * 1024
argonIterations uint32 = 2
argonParallelism uint8 = 1
argonSaltLength = 16
argonKeyLength uint32 = 32
minPasswordLength = 12
maxPasswordLength = 128
)
var ErrInvalidPasswordHash = errors.New("invalid password hash")
func ValidatePassword(password string) error {
if !utf8.ValidString(password) {
return errors.New("password must be valid UTF-8")
}
length := utf8.RuneCountInString(password)
if length < minPasswordLength || length > maxPasswordLength {
return fmt.Errorf(
"password length must be between %d and %d code points",
minPasswordLength,
maxPasswordLength,
)
}
return nil
}
func HashPassword(password string) (string, error) {
if err := ValidatePassword(password); err != nil {
return "", err
}
salt := make([]byte, argonSaltLength)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("generate password salt: %w", err)
}
hash := argon2.IDKey(
[]byte(password),
salt,
argonIterations,
argonMemory,
argonParallelism,
argonKeyLength,
)
encodedSalt := base64.RawStdEncoding.EncodeToString(salt)
encodedHash := base64.RawStdEncoding.EncodeToString(hash)
encoded := fmt.Sprintf(
"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version,
argonMemory,
argonIterations,
argonParallelism,
encodedSalt,
encodedHash,
)
return encoded, nil
}
func VerifyPassword(
password string,
encodedHash string,
) (bool, error) {
parameters, salt, expectedHash, err := decodePasswordHash(encodedHash)
if err != nil {
return false, err
}
actualHash := argon2.IDKey(
[]byte(password),
salt,
parameters.iterations,
parameters.memory,
parameters.parallelism,
uint32(len(expectedHash)),
)
matches := subtle.ConstantTimeCompare(
actualHash,
expectedHash,
) == 1
return matches, nil
}
type argonParameters struct {
memory uint32
iterations uint32
parallelism uint8
}
func decodePasswordHash(
encodedHash string,
) (argonParameters, []byte, []byte, error) {
parts := strings.Split(encodedHash, "$")
if len(parts) != 6 ||
parts[0] != "" ||
parts[1] != "argon2id" {
return argonParameters{}, nil, nil, ErrInvalidPasswordHash
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil {
return argonParameters{}, nil, nil, ErrInvalidPasswordHash
}
if version != argon2.Version {
return argonParameters{}, nil, nil, ErrInvalidPasswordHash
}
var parameters argonParameters
if _, err := fmt.Sscanf(
parts[3],
"m=%d,t=%d,p=%d",
&parameters.memory,
&parameters.iterations,
&parameters.parallelism,
); err != nil {
return argonParameters{}, nil, nil, ErrInvalidPasswordHash
}
// Ограничения не позволяют повреждённой строке из БД запросить
// гигантский объём памяти или процессорного времени.
if parameters.memory < 8*1024 ||
parameters.memory > 256*1024 ||
parameters.iterations < 1 ||
parameters.iterations > 10 ||
parameters.parallelism < 1 ||
parameters.parallelism > 8 {
return argonParameters{}, nil, nil, ErrInvalidPasswordHash
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil || len(salt) < 16 || len(salt) > 64 {
return argonParameters{}, nil, nil, ErrInvalidPasswordHash
}
hash, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil || len(hash) < 16 || len(hash) > 64 {
return argonParameters{}, nil, nil, ErrInvalidPasswordHash
}
return parameters, salt, hash, nil
}
+105
View File
@@ -0,0 +1,105 @@
package security
import (
"strings"
"testing"
)
func TestPasswordHashAndVerify(t *testing.T) {
password := "Correct-password-123"
encodedHash, err := HashPassword(password)
if err != nil {
t.Fatalf("HashPassword returned error: %v", err)
}
if strings.Contains(encodedHash, password) {
t.Fatal("encoded hash contains plaintext password")
}
matches, err := VerifyPassword(password, encodedHash)
if err != nil {
t.Fatalf("VerifyPassword returned error: %v", err)
}
if !matches {
t.Fatal("correct password did not match")
}
matches, err = VerifyPassword("Wrong-password-123", encodedHash)
if err != nil {
t.Fatalf("VerifyPassword returned error: %v", err)
}
if matches {
t.Fatal("wrong password matched")
}
}
func TestPasswordHashesUseDifferentSalts(t *testing.T) {
password := "Correct-password-123"
firstHash, err := HashPassword(password)
if err != nil {
t.Fatalf("first HashPassword returned error: %v", err)
}
secondHash, err := HashPassword(password)
if err != nil {
t.Fatalf("second HashPassword returned error: %v", err)
}
if firstHash == secondHash {
t.Fatal("equal passwords produced equal encoded hashes")
}
}
func TestPasswordValidation(t *testing.T) {
testCases := []struct {
name string
password string
wantErr bool
}{
{
name: "minimum length",
password: "123456789012",
wantErr: false,
},
{
name: "unicode",
password: "пароль-проверка-123",
wantErr: false,
},
{
name: "colon is allowed",
password: "password:with:colon",
wantErr: false,
},
{
name: "too short",
password: "short",
wantErr: true,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
err := ValidatePassword(testCase.password)
if testCase.wantErr && err == nil {
t.Fatal("expected validation error")
}
if !testCase.wantErr && err != nil {
t.Fatalf("unexpected validation error: %v", err)
}
})
}
}
func TestMalformedPasswordHash(t *testing.T) {
_, err := VerifyPassword(
"Correct-password-123",
"not-an-argon2-hash",
)
if err == nil {
t.Fatal("expected malformed hash error")
}
}

Some files were not shown because too many files have changed in this diff Show More