Author SHA1 Message Date
d1frend 63c1f06b84 feat(lab6): add observability and SLO burn-rate alerts 2026-11-15 06:54:54 +03:00
204 changed files with 25348 additions and 37 deletions
+19 -10
View File
@@ -1,30 +1,39 @@
# 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
GRAFANA_PORT=3000
PROMETHEUS_PORT=9090
LOKI_PORT=3100
TEMPO_PORT=3200
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
OTEL_SERVICE_NAME=messenger-api
# Worker must set a distinct service.name.
STAGING_CLEANUP_INTERVAL_SECONDS=30
API_GO_MEMORY_LIMIT=220MiB
WORKER_GO_MEMORY_LIMIT=448MiB
WORKER_MEMORY_LIMIT=512M
# Both API and worker use this OTLP/HTTP endpoint; service.name is assigned in code.
OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab
OTEL_EXPORTER_OTLP_TIMEOUT=3000
+41 -3
View File
@@ -1,4 +1,4 @@
name: Skeleton contracts
name: Lab 6 checks
on: [push, pull_request]
permissions:
contents: read
@@ -12,5 +12,43 @@ jobs:
python-version: '3.12'
- run: python -m pip install -r requirements-dev.txt
- run: make check validate PYTHON=python
# This job validates the skeleton, not a student solution.
# Add build, readiness and make test in a separate application job.
application:
runs-on: ubuntu-latest
needs: contracts
timeout-minutes: 25
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- uses: actions/setup-go@v6
with:
go-version-file: go.mod
cache: true
- name: Audit Go code and dependencies
run: |
go mod verify
go test -race -count=1 ./...
go vet ./...
go run golang.org/x/vuln/cmd/govulncheck@v1.9.0 ./...
- name: Initialize local CI configuration
run: |
cp .env.example .env
make init-secrets
- name: Validate and start the complete stack
run: |
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
- name: Run public API smoke test
run: make test
- name: Verify the telemetry path
run: make test-observability-grade4
- name: Show service state and logs on failure
if: failure()
run: |
docker compose ps -a
docker compose logs --no-color --tail=300
- name: Remove ephemeral CI resources
if: always()
run: docker compose down --volumes --remove-orphans
+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"]
+88 -2
View File
@@ -2,12 +2,20 @@ PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
RECONCILE_GRACE ?= 15m
PROMETHEUS_URL ?= http://localhost:9090
LOKI_URL ?= http://localhost:3100
TEMPO_URL ?= http://localhost:3200
GRAFANA_URL ?= http://localhost:3000
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-observability-grade3 test-observability-grade4 test-observability-retry-trace test-observability-alerts test-telemetry-backend-outage test-slo-burn-rate test-histogram-calibration test-observability-incidents 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 cleanup-lab
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "check: offline structure; validate: full OpenAPI; test: running API; cleanup-lab: stop lab6 and remove only its locally built images"
init-secrets:
./scripts/init-secrets.sh
check:
$(PYTHON) scripts/check_contract.py
@@ -21,6 +29,69 @@ test:
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-observability-grade3:
$(PYTHON) tests/observability_grade3.py --prometheus-url "$(PROMETHEUS_URL)" --loki-url "$(LOKI_URL)" --tempo-url "$(TEMPO_URL)" --grafana-url "$(GRAFANA_URL)"
test-observability-grade4:
$(PYTHON) tests/observability_grade4.py --base-url "$(BASE_URL)" --prometheus-url "$(PROMETHEUS_URL)" --loki-url "$(LOKI_URL)" --tempo-url "$(TEMPO_URL)" --grafana-url "$(GRAFANA_URL)"
test-observability-retry-trace:
$(PYTHON) tests/observability_retry_trace.py --base-url "$(BASE_URL)" --loki-url "$(LOKI_URL)" --tempo-url "$(TEMPO_URL)"
test-observability-alerts:
$(PYTHON) tests/observability_alerts.py --base-url "$(BASE_URL)" --prometheus-url "$(PROMETHEUS_URL)" --loki-url "$(LOKI_URL)" --tempo-url "$(TEMPO_URL)"
test-telemetry-backend-outage:
$(PYTHON) tests/telemetry_backend_outage.py --base-url "$(BASE_URL)" --prometheus-url "$(PROMETHEUS_URL)" --loki-url "$(LOKI_URL)" --tempo-url "$(TEMPO_URL)"
test-slo-burn-rate:
$(PYTHON) tests/slo_burn_rate.py --base-url "$(BASE_URL)" --prometheus-url "$(PROMETHEUS_URL)" --loki-url "$(LOKI_URL)" --tempo-url "$(TEMPO_URL)" --grafana-url "$(GRAFANA_URL)"
test-histogram-calibration:
$(PYTHON) tests/histogram_calibration.py --base-url "$(BASE_URL)" --prometheus-url "$(PROMETHEUS_URL)"
test-observability-incidents:
$(MAKE) test-async-resilience BASE_URL="$(BASE_URL)"
$(MAKE) test-storage-outage BASE_URL="$(BASE_URL)"
$(PYTHON) tests/observability_incidents.py --prometheus-url "$(PROMETHEUS_URL)" --loki-url "$(LOKI_URL)" --tempo-url "$(TEMPO_URL)"
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 +99,18 @@ 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
cleanup-lab:
./scripts/cleanup-lab.sh
+184 -22
View File
@@ -1,37 +1,199 @@
# Отчёт — лабораторная 6
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Чурилин Данила, БВТ2301
- Текущий подготовленный уровень: оценка «5», трек 2 «SLO и обнаружение инцидентов»
- Ветка: `solution/bvt2301-churilin`
- Commit/PR: не создавались
- Использованные источники, библиотеки и помощь ИИ: OpenTelemetry Go SDK 1.46.0, OpenTelemetry Collector Contrib 0.165.0, Prometheus 3.16.0, Loki 3.7.9, Tempo 2.10.5, Grafana 13.3.0; официальная документация OpenTelemetry, Prometheus и Grafana; OpenAI Codex использован для анализа требований, реализации, тестирования и оформления отчёта
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Engine с Compose v2, GNU Make, Python 3.9+ и OpenSSL. Локальный Go для запуска стенда не обязателен.
## Архитектура и решения
```sh
cp .env.example .env
make init-secrets
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab5, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
make check
make test
make test-observability-grade3
make test-observability-grade4
make test-observability-retry-trace
make test-observability-alerts
make test-telemetry-backend-outage
make test-slo-burn-rate
```
## Доказательства критериев
`make init-secrets` создаёт игнорируемые Git файлы в `secrets/` с mode 600 и не перезаписывает существующие значения. Миграции выполняет одноразовый `migrate`, а `minio-bootstrap` идемпотентно создаёт приватный bucket и ограниченного S3-пользователя.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
Порты по умолчанию: приложение `127.0.0.1:8080`, Grafana `:3000`, Prometheus `:9090`, Loki `:3100`, Tempo `:3200`. Они привязаны к loopback и переопределяются переменными из `.env.example`.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
После проверки каждого уровня (3, 4, 5) и после завершения лабораторной выполняется:
## Эксперименты и отказы
```sh
make cleanup-lab
```
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Команда делает `docker compose down --remove-orphans` и удаляет только пять локально собранных образов с точными именами `mtusi2026lab6-*`. Именованные volumes, pulled-образы и ресурсы других лабораторных сохраняются. Намеренный полный сброс учебных данных остаётся отдельной командой `docker compose down --volumes` и в автоматическую очистку не входит.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Архитектура и причинная связь
## Ограничения и следующие шаги
```text
client -> HAProxy -> API x2 -> PostgreSQL + staging S3
|
W3C traceparent/tracestate
v
outbox -> dispatcher -- producer span --> RabbitMQ
|
v
consumer span
worker
-> S3 + PostgreSQL
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
API / dispatcher / worker -- OTLP --> Collector -- metrics --> Prometheus
| -- logs ----> Loki
'---------- traces ---> Tempo
Prometheus + Loki + Tempo ----------------------------------> Grafana
```
PostgreSQL — источник истины для metadata и outbox/job, MinIO — для объектов, RabbitMQ — persistent at-least-once transport, Redis — восстанавливаемый cache. Бизнес-ответ и обработка job не зависят от успешности экспорта телеметрии.
API инжектирует W3C `traceparent`/`tracestate` в атомарно созданную outbox job. Dispatcher извлекает сохранённый context, создаёт `PRODUCER` span, помещает новый context в AMQP headers. Worker извлекает headers до claim и создаёт `CONSUMER` span. При retry исходный parent сохраняется, а новая producer/consumer-пара остаётся в той же трассе. S3 и PostgreSQL операции — дочерние `CLIENT` spans. `postgresql.acquire` отдельно показывает timeout выдачи соединения из pool, даже если SQL ещё не начал выполняться.
Общие Resource attributes: `service.name`, `service.version=6.0.0`, `service.instance.id`, `deployment.environment.name=lab`. В metric labels нет user/chat/message/attachment/request ID, URL, filename и текста ошибок. Логи не содержат тела сообщений, изображения, tokens или credentials.
## Метрики, запросы и единицы
Provisioned dashboards: основной UID `mtusi-lab6-grade4` и SLO dashboard UID `mtusi-lab6-grade5`. Оба JSON лежат в `infrastructure/telemetry/grafana/dashboards/` и импортируются без ручной настройки.
| Сигнал | PromQL | Единица |
| --- | --- | --- |
| API RPS | `sum(rate(messenger_http_server_requests_total[1m]))` | requests/s |
| Доля 5xx | `sum(rate(...{status_class="5xx"}[1m])) / sum(rate(...[1m]))` | доля 0..1 |
| API p50/p95/p99 | `histogram_quantile(q, sum by (le) (rate(messenger_http_server_duration_seconds_bucket[5m])))` | секунды |
| Queue depth | `max(messenger_queue_depth)` | jobs |
| Старейшая job | `max(messenger_queue_oldest_job_age_seconds)` | секунды |
| Worker saturation | `max(messenger_worker_busy) / max(messenger_worker_capacity)` | доля 0..1 |
| Time to ready p50/p95/p99 | `histogram_quantile(q, sum by (le) (rate(messenger_attachment_ready_duration_seconds_bucket[5m])))` | секунды |
| DB pool | `sum by (service_name,state) (messenger_db_pool_connections)` | connections |
| DB waits | `sum by (service_name) (rate(messenger_db_pool_waits_total[5m]))` | waits/s |
| CPU процесса | `sum by (service_name) (rate(messenger_process_cpu_time_seconds_total[5m]))` | CPU-seconds/s |
| RSS процесса | `max by (service_name) (messenger_process_memory_bytes)` | bytes |
| Collector queues | `otelcol_exporter_queue_size`, `otelcol_exporter_queue_capacity` | batches |
| Потери Collector | сумма rate `otelcol_exporter_send_failed_*` | signals/s |
Percentiles вычисляются из histogram buckets; средние значения и усреднение готовых p99 между репликами не используются.
Отдельная калибровка `make test-histogram-calibration` сравнила 400 клиентских измерений с Prometheus: HTTP p95 3.570 ms на клиенте и 4.910 ms по histogram (ratio 1.38), ready p95 1.013/0.946 s, worker p95 97.5 ms. Таким образом, единицы действительно секунды, а ошибка на три порядка из-за слишком крупных default buckets отсутствует.
## SLI, SLO и alerts
Для трека 2 заданы два request/event-based SLO с policy window 7 дней, совпадающим с `--storage.tsdb.retention.time=7d` Prometheus:
- API availability: не менее 99% instrumented HTTP-запросов завершаются без 5xx; error budget — 1% запросов;
- attachment ready: не менее 99% успешно завершённых attachments переходят в `ready` не позднее 10 секунд после durable acceptance; error budget — 1% завершённых jobs.
Порог 10 секунд включает очередь и обработку и потому лучше пользовательского результата, чем только worker execution time. Значение совпадает с bucket `le="10.0"`, поэтому bad events считаются без приближения percentile.
Policy-window recording rules `messenger:slo_api_success_ratio_7d` и `messenger:slo_attachment_ready_ratio_7d` вычисляются через `increase(...[7d])`; SLO можно проверить напрямую на dashboard, а не выводить из коротких alert windows.
Правила лежат в `infrastructure/telemetry/prometheus/rules/alerts.yaml`:
- `MessengerAPIHighErrorRate`: более 1% 5xx при достаточном трафике за 1 минуту, `for: 10s`;
- `MessengerQueueLagGrowing`: depth > 0 и oldest age > 10 секунд, `for: 10s`.
Для уровня 5 добавлены две policy-window и восемь burn-window recording rules по окнам 30s/1m/2m/5m, а также четыре multi-window alerts:
- Fast: оба окна 30s и 2m превышают 14.4x burn rate, `for: 10s`, severity `page`;
- Slow: оба окна 1m и 5m превышают 6x burn rate, `for: 20s`, severity `ticket`;
- одинаковая схема применяется к API 5xx и attachment >10s;
- traffic guard исключает алерт при отсутствии запросов/jobs.
Факторы 14.4x и 6x выражают скорость расходования 1% бюджета независимо от масштаба окна. Окна намеренно сжаты до минут для воспроизводимой лабораторной проверки; production-вариант использовал бы, например, 5m/1h и 30m/6h. Runbooks: `infrastructure/telemetry/runbooks/level4.md` и `level5.md`.
## Collector и bounded degradation
Обе telemetry-очереди имеют capacity 256 batches и 2 consumers. `memory_limiter`: limit 192 MiB, spike 48 MiB, проверка раз в секунду. `batch`: 256, максимум 512, timeout 1 секунда. Export timeout 3 секунды, retry ограничен 30 секундами. Container memory limit — 256 MiB.
При остановке Loki и Tempo 400 HTTP-запросов завершились с 200, attachment перешёл в `ready`. Collector принял дополнительно 3170 log/span records; после исчерпания retry budget 75 сигналов были явно учтены как `send_failed`, а не накапливались бесконечно. Queue peak в момент измерения — 34 из 256 batches; container RSS peak — 261305139 из 268435456 bytes. После восстановления backend новый log и trace `01806671c8d2cee14dc504f63a60197b` появились снова. Бизнес-данные не потеряны; допустимая деградация — потеря части телеметрии после bounded retry.
## Контролируемые инциденты
### 1. Worker остановлен
Гипотеза: queue depth и oldest age растут, бизнес-upload остаётся durable queued, затем после возврата worker job завершается.
Методика: остановить worker, загрузить PNG, дождаться `MessengerQueueLagGrowing=firing`, запустить worker, дождаться `ready` и отсутствия активного alert.
Результат: firing через 26.075 s, depth=1, oldest age=21.157 s; resolved через 8.009 s после восстановления. Диагностика: dashboard queue → worker saturation/logs → consumer trace.
### 2. PostgreSQL приостановлен
Гипотеза: API возвращает bounded 503 через DB query timeout; HTTP trace содержит error на ожидании pool, high-error alert срабатывает и снимается после восстановления.
Методика: `docker compose pause postgres`, восемь параллельных authenticated GET, ожидание alert, `unpause`, readiness, поиск request ID в Loki и trace в Tempo.
Результат: восемь 503; `MessengerAPIHighErrorRate=firing` через 19.044 s; trace `db176205d463b89b73c737780e58cf06` содержит `postgresql.acquire` со статусом error; resolved через 44.049 s. Это отличает DB pool timeout от медленного handler без DB child/error span.
### Retry и единая трасса
MinIO был остановлен после durable staging upload, worker выполнил неуспешную попытку, затем MinIO восстановлен. Attachment завершился `ready`. В trace `0df6d4041008c05e5c2c77b0c2bd2ddf` видны сервисы API/dispatcher/worker, producer attempts 1/2 и consumer attempts 1/2, всего 46 spans, включая S3 и PostgreSQL.
## Эксперимент уровня 5: SLO и обнаружение
Гипотеза: multi-window burn-rate не реагирует на ограниченный краткий всплеск ниже скорости расходования бюджета, но обнаруживает длительную деградацию; после восстановления и достаточного успешного трафика оба окна возвращаются ниже порога.
Методика полностью реализована в `tests/slo_burn_rate.py`:
1. создать 400 успешных запросов baseline;
2. кратко pause PostgreSQL и получить 4 контролируемых 503, затем 25 секунд наблюдать оба состояния alerts;
3. повторно pause PostgreSQL и поддерживать восемь concurrent error streams до firing Fast/Slow;
4. восстановить DB, создать успешный трафик, измерить resolved и найти root cause по log/trace;
5. для ready SLO создать 20 быстрых jobs, остановить worker, выдержать пять jobs более 10 секунд, восстановить worker и дождаться Fast/Slow;
6. создать 100 быстрых jobs и измерить resolved.
Результаты API:
- краткий burst: 4 ошибки, `pending_or_firing=0`; максимум 30s ratio 3.846%, 5m ratio 0.783%; контролируемых ложных срабатываний нет;
- длительная деградация: 136 ответов 503;
- `MessengerAPIBurnRateSlow` firing через 42.194 s, Fast через 52.212 s;
- resolved обоих правил через 38.851 s после восстановления и успешного трафика;
- trace `abac9b8b51c9b4bd3d05c26dab3e37ea`, root cause span `postgresql.acquire`.
Результаты attachment ready:
- 20 baseline jobs ≤10s, 5 jobs >10s, 100 recovery jobs ≤10s;
- Fast firing через 20.039 s после поступления slow observations, Slow — через 30.056 s;
- resolved через 8.016 s после recovery samples;
- итоговый 5m slow ratio 4.794%, то есть ниже 6% slow burn threshold.
В этом локальном профиле Slow API alert обнаружился раньше Fast: длинное окно уже превысило 6%, тогда как 30s окно Fast сначала было разбавлено baseline-трафиком. Это ожидаемое следствие данных, а не гарантия порядка severity. Проверка false positive ограничена одним воспроизводимым сценарием и не является статистической оценкой реальной частоты ложных тревог.
## Доказательства и проверки
| Критерий | Команда | Результат |
| --- | --- | --- |
| Contract/OpenAPI | `make check`, `make validate` | PASS |
| Публичный API | `make test` | PASS |
| Уровень 3 | `make test-observability-grade3` | PASS |
| W3C chain + grade-4 metrics/dashboard | `make test-observability-grade4` | PASS, 3 services, 4 span kinds, 36 spans |
| Retry в одной трассе | `make test-observability-retry-trace` | PASS, attempts 1/2, 2 producer + 2 consumer |
| Alerts | `make test-observability-alerts` | PASS, оба firing/resolved |
| Telemetry backend outage | `make test-telemetry-backend-outage` | PASS, business ready, bounded queue/RAM/loss |
| Grade-5 SLO experiment | `make test-slo-burn-rate` | PASS, short burst filtered; API/ready Fast+Slow firing/resolved |
| Histogram calibration | `make test-histogram-calibration` | PASS, HTTP client/Prom p95 3.570/4.910 ms; ready 1.013/0.946 s |
| Collector config | Collector `validate` | PASS |
| Prometheus rules | `promtool check config/rules` | PASS, 17 rules |
| Go | `go test -race -count=1 ./...`, `go vet ./...`, `go build ./...`, `go mod verify` | PASS |
| Go dependencies | `govulncheck -show verbose ./...` | PASS, no symbol/package/module vulnerabilities found after dependency updates |
| Shell scripts | `bash -n`, ShellCheck 0.11.0 | PASS |
| Compose/dashboard | `docker compose config --quiet`, JSON parse, Grafana API | PASS |
| CI application job | `.github/workflows/contracts.yml` | race/vet/vulnerability audit, Compose build/wait, public smoke, telemetry path, failure logs, cleanup |
Полный машинно-читаемый вывод и параметры прогонов сохранены в `evidence/lab6-grade4.md` и `evidence/lab6-grade5.md`.
## Ограничения
Заявлен уровень 5, трек 2. Стенд проверен на одном Docker-host, поэтому потеря host/volumes не покрыта. Окна burn-rate сжаты для лабораторной повторяемости и не заменяют многонедельное production-наблюдение. DB incident использует полную pause, а не реалистичное распределение latency. Независимый студент ещё не выполнял runbook drill; вместо этого шаги автоматически повторяет black-box сценарий, а root cause подтверждён через Loki/Tempo. Пик RSS Collector в outage-тесте близок к container limit, но не превысил его, контейнер не перезапускался, очередь оставалась bounded, а потери были измерены. Обычная очистка сохраняет named volumes; для освобождения места, занятого volumes, нужен отдельный осознанный экспорт/удаление данных.
+162
View File
@@ -0,0 +1,162 @@
package main
import (
"context"
"errors"
"log"
"os"
"os/signal"
"syscall"
"time"
"mtusi2026lab6/internal/adapter/broker"
"mtusi2026lab6/internal/adapter/postgres"
"mtusi2026lab6/internal/config"
"mtusi2026lab6/internal/database"
"mtusi2026lab6/internal/domain"
apptelemetry "mtusi2026lab6/internal/telemetry"
"mtusi2026lab6/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()
telemetryRuntime, err := apptelemetry.Start(ctx, "messenger-dispatcher", cfg.InstanceID, "lab")
if err != nil {
log.Fatalf("[FATAL] OpenTelemetry initialization failed: %v", err)
}
defer func() {
shutdownContext, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if shutdownErr := telemetryRuntime.Shutdown(shutdownContext); shutdownErr != nil {
log.Printf("[WARN] OpenTelemetry shutdown failed: %v", shutdownErr)
}
}()
pool, err := database.Open(ctx, cfg)
if err != nil {
log.Fatalf("[FATAL] PostgreSQL initialization failed: %v", err)
}
defer pool.Close()
if err = apptelemetry.RegisterDBPool(telemetryRuntime, pool); err != nil {
log.Fatalf("[FATAL] DB pool observability initialization failed: %v", err)
}
store := postgres.NewPostgreSQLStore(pool, cfg.DatabaseQueryTimeout)
queueRecorder, err := apptelemetry.NewQueueRecorder(telemetryRuntime)
if err != nil {
log.Fatalf("[FATAL] Queue observability initialization failed: %v", err)
}
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")
nextQueueObservation := time.Time{}
for {
now := time.Now().UTC()
if !now.Before(nextQueueObservation) {
depth, ageSeconds, statsErr := store.AttachmentQueueStats(ctx, now)
if statsErr != nil {
if ctx.Err() == nil {
log.Printf("[WARN] Read queue stats failed: %v", statsErr)
}
} else {
queueRecorder.Record(ctx, depth, ageSeconds)
}
nextQueueObservation = now.Add(time.Second)
}
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"
"mtusi2026lab6/internal/adapter/broker"
"mtusi2026lab6/internal/adapter/objectstore"
"mtusi2026lab6/internal/adapter/postgres"
"mtusi2026lab6/internal/application"
"mtusi2026lab6/internal/config"
"mtusi2026lab6/internal/database"
"mtusi2026lab6/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"
"mtusi2026lab6/internal/adapter/objectstore"
"mtusi2026lab6/internal/adapter/postgres"
"mtusi2026lab6/internal/config"
"mtusi2026lab6/internal/database"
"mtusi2026lab6/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")
}
}
+283
View File
@@ -0,0 +1,283 @@
package main
import (
"context"
"errors"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
cacheadapter "mtusi2026lab6/internal/adapter/cache"
"mtusi2026lab6/internal/adapter/health"
"mtusi2026lab6/internal/adapter/objectstore"
"mtusi2026lab6/internal/adapter/postgres"
redisadapter "mtusi2026lab6/internal/adapter/redis"
"mtusi2026lab6/internal/application"
"mtusi2026lab6/internal/config"
"mtusi2026lab6/internal/database"
apptelemetry "mtusi2026lab6/internal/telemetry"
"mtusi2026lab6/internal/transport/http/handlers"
"mtusi2026lab6/internal/transport/http/middleware"
)
func main() {
cfg, err := config.Load()
if err != nil {
log.Fatalf("[FATAL] Invalid configuration: %v", err)
}
telemetryRuntime, err := apptelemetry.Start(
context.Background(),
"messenger-api",
cfg.InstanceID,
"lab",
)
if err != nil {
log.Fatalf("[FATAL] OpenTelemetry initialization failed: %v", err)
}
defer func() {
shutdownContext, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if shutdownErr := telemetryRuntime.Shutdown(shutdownContext); shutdownErr != nil {
log.Printf("[WARN] OpenTelemetry shutdown failed: %v", shutdownErr)
}
}()
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()
if err = apptelemetry.RegisterDBPool(telemetryRuntime, databasePool); err != nil {
log.Fatalf("[FATAL] DB pool observability initialization failed: %v", err)
}
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, err = middleware.Observability(telemetryRuntime, rootHandler)
if err != nil {
log.Fatalf("[FATAL] HTTP observability initialization failed: %v", err)
}
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.")
}
}
+273
View File
@@ -0,0 +1,273 @@
package main
import (
"context"
"errors"
"fmt"
"log"
"os"
"os/signal"
"sync"
"syscall"
"time"
"mtusi2026lab6/internal/adapter/broker"
"mtusi2026lab6/internal/adapter/objectstore"
"mtusi2026lab6/internal/adapter/postgres"
"mtusi2026lab6/internal/config"
"mtusi2026lab6/internal/database"
"mtusi2026lab6/internal/domain"
apptelemetry "mtusi2026lab6/internal/telemetry"
"mtusi2026lab6/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()
telemetryRuntime, err := apptelemetry.Start(
ctx,
"messenger-worker",
cfg.InstanceID,
"lab",
)
if err != nil {
log.Fatalf("[FATAL] OpenTelemetry initialization failed: %v", err)
}
defer func() {
shutdownContext, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if shutdownErr := telemetryRuntime.Shutdown(shutdownContext); shutdownErr != nil {
log.Printf("[WARN] OpenTelemetry shutdown failed: %v", shutdownErr)
}
}()
jobRecorder, err := apptelemetry.NewJobRecorder(telemetryRuntime, cfg.WorkerConcurrency)
if err != nil {
log.Fatalf("[FATAL] Worker observability initialization failed: %v", err)
}
pool, err := database.Open(ctx, cfg)
if err != nil {
log.Fatalf("[FATAL] PostgreSQL initialization failed: %v", err)
}
defer pool.Close()
if err = apptelemetry.RegisterDBPool(telemetryRuntime, pool); err != nil {
log.Fatalf("[FATAL] DB pool observability initialization failed: %v", err)
}
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 {
deliveryContext := broker.ContextFromDelivery(ctx, delivery)
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(
deliveryContext,
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(deliveryContext, cfg.JobTimeout)
jobContext, observedAttempt := jobRecorder.Start(
jobContext,
domain.AttachmentJobType,
broker.QueueName,
job.Attempt,
job.CreatedAt,
)
processErr := processor.Process(jobContext, job)
observedAttempt.End(processErr)
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")
}
+614
View File
@@ -0,0 +1,614 @@
services:
load-balancer:
build:
context: .
dockerfile: infrastructure/haproxy/Dockerfile
image: mtusi2026lab6-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: mtusi2026lab6-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: mtusi2026lab6-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: mtusi2026lab6-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: mtusi2026lab6-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
OTEL_EXPORTER_OTLP_ENDPOINT: ${OTEL_EXPORTER_OTLP_ENDPOINT:-http://otel-collector:4318}
OTEL_EXPORTER_OTLP_PROTOCOL: http/protobuf
OTEL_EXPORTER_OTLP_TIMEOUT: ${OTEL_EXPORTER_OTLP_TIMEOUT:-3000}
OTEL_TRACES_SAMPLER: parentbased_always_on
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: mtusi2026lab6-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}
OTEL_EXPORTER_OTLP_ENDPOINT: ${OTEL_EXPORTER_OTLP_ENDPOINT:-http://otel-collector:4318}
OTEL_EXPORTER_OTLP_PROTOCOL: http/protobuf
OTEL_EXPORTER_OTLP_TIMEOUT: ${OTEL_EXPORTER_OTLP_TIMEOUT:-3000}
OTEL_TRACES_SAMPLER: parentbased_always_on
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: mtusi2026lab6-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}
OTEL_EXPORTER_OTLP_ENDPOINT: ${OTEL_EXPORTER_OTLP_ENDPOINT:-http://otel-collector:4318}
OTEL_EXPORTER_OTLP_PROTOCOL: http/protobuf
OTEL_EXPORTER_OTLP_TIMEOUT: ${OTEL_EXPORTER_OTLP_TIMEOUT:-3000}
OTEL_TRACES_SAMPLER: parentbased_always_on
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
loki:
image: grafana/loki:3.7.9
command: ["-config.file=/etc/loki/config.yaml"]
ports:
- "127.0.0.1:${LOKI_PORT:-3100}:3100"
volumes:
- ./infrastructure/telemetry/loki/config.yaml:/etc/loki/config.yaml:ro
- loki_data:/loki
expose:
- "3100"
healthcheck:
test: ["CMD", "/usr/bin/loki", "-version"]
interval: 10s
timeout: 5s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.50"
memory: 384M
tempo:
image: grafana/tempo:2.10.5
command: ["-config.file=/etc/tempo/config.yaml"]
ports:
- "127.0.0.1:${TEMPO_PORT:-3200}:3200"
volumes:
- ./infrastructure/telemetry/tempo/config.yaml:/etc/tempo/config.yaml:ro
- tempo_data:/var/tempo
expose:
- "3200"
- "4318"
healthcheck:
test: ["CMD", "/tempo", "-version"]
interval: 10s
timeout: 5s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.50"
memory: 384M
otel-collector:
image: otel/opentelemetry-collector-contrib:0.165.0
command: ["--config=/etc/otelcol-contrib/config.yaml"]
volumes:
- ./infrastructure/telemetry/otel-collector/config.yaml:/etc/otelcol-contrib/config.yaml:ro
expose:
- "4318"
- "8888"
- "8889"
- "13133"
depends_on:
loki:
condition: service_healthy
tempo:
condition: service_healthy
healthcheck:
test: ["CMD", "/otelcol-contrib", "components"]
interval: 10s
timeout: 5s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.50"
memory: 256M
prometheus:
image: prom/prometheus:v3.16.0
command:
- --config.file=/etc/prometheus/prometheus.yaml
- --storage.tsdb.path=/prometheus
- --storage.tsdb.retention.time=7d
ports:
- "127.0.0.1:${PROMETHEUS_PORT:-9090}:9090"
volumes:
- ./infrastructure/telemetry/prometheus/prometheus.yaml:/etc/prometheus/prometheus.yaml:ro
- ./infrastructure/telemetry/prometheus/rules:/etc/prometheus/rules:ro
- prometheus_data:/prometheus
expose:
- "9090"
depends_on:
otel-collector:
condition: service_healthy
healthcheck:
test: ["CMD", "/bin/prometheus", "--version"]
interval: 10s
timeout: 5s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.50"
memory: 384M
grafana:
image: grafana/grafana:13.3.0
ports:
- "127.0.0.1:${GRAFANA_PORT:-3000}:3000"
environment:
GF_AUTH_ANONYMOUS_ENABLED: "true"
GF_AUTH_ANONYMOUS_ORG_ROLE: Viewer
GF_AUTH_DISABLE_LOGIN_FORM: "true"
GF_USERS_DEFAULT_THEME: dark
GF_ANALYTICS_CHECK_FOR_UPDATES: "false"
GF_ANALYTICS_REPORTING_ENABLED: "false"
GF_PLUGINS_PREINSTALL_DISABLED: "true"
GF_PLUGINS_PREINSTALL_AUTO_UPDATE: "false"
GF_PLUGINS_PLUGIN_ADMIN_ENABLED: "false"
GF_SECURITY_X_XSS_PROTECTION: "false"
volumes:
- grafana_data:/var/lib/grafana
- ./infrastructure/telemetry/grafana/provisioning:/etc/grafana/provisioning:ro
- ./infrastructure/telemetry/grafana/dashboards:/var/lib/grafana/dashboards:ro
depends_on:
prometheus:
condition: service_healthy
loki:
condition: service_healthy
tempo:
condition: service_healthy
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:3000/api/health >/dev/null || exit 1"]
interval: 10s
timeout: 5s
retries: 20
start_period: 10s
restart: unless-stopped
deploy:
resources:
limits:
cpus: "0.50"
memory: 384M
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:
prometheus_data:
loki_data:
tempo_data:
grafana_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
+31
View File
@@ -0,0 +1,31 @@
# Lab 6 — final audit
Date: 2026-11-12.
## Confirmed fixes from the audit
1. SLO policy window previously said 30 days while Prometheus retained 7 days. The policy is now explicitly 7 days and has verifiable `messenger:slo_*_ratio_7d` recording rules.
2. The skeleton-only CI had no application job. CI now builds the complete Compose stack, waits for readiness, runs the public smoke and telemetry-path tests, prints logs on failure and removes ephemeral volumes.
3. Histogram calibration was added to guard against seconds/milliseconds and default-bucket mistakes.
4. `govulncheck` found 19 reachable vulnerabilities in the original AMQP and image dependencies. `github.com/rabbitmq/amqp091-go` was upgraded to v1.14.0 and `golang.org/x/image` to v0.45.0. Fixed transitive versions of `grpc`, `x/net`, `x/crypto` and `klauspost/compress` removed six additional non-reachable findings.
## Verification
- `git diff --check`: PASS.
- `git add --dry-run .`: `.env`, `secrets/`, `__pycache__` and build artifacts excluded.
- Secret scan: no committed local credential value found.
- `go test -race -count=1 ./...`: PASS.
- `go vet ./...`, `go build ./...`, `go mod verify`: PASS.
- `govulncheck -show verbose ./...`: PASS; no symbol, package or module vulnerabilities found.
- Python compileall: PASS.
- frontend `npm ci`, `npm test`, `npm run build`: PASS; npm reported 0 vulnerabilities.
- Compose config and all dashboard JSON files: PASS.
- Prometheus `promtool`: PASS, 17 rules.
- Public smoke, grade-4 telemetry regression, grade-5 SLO experiment: PASS.
- Histogram calibration: PASS; HTTP client/Prometheus p95 3.570/4.910 ms, ready p95 1.013/0.946 s, worker p95 97.5 ms.
## Remaining limitations
- The seven-day SLO policy is locally verifiable but the burn windows are intentionally compressed for the laboratory experiment.
- No independent human performed the runbook drill; the black-box scenario follows it automatically.
- Repository shell scripts passed `bash -n` and ShellCheck 0.11.0 after resolving four SC1007 warnings.
+132
View File
@@ -0,0 +1,132 @@
# Lab6 — доказательства уровня 3
Дата прогона: 2026-11-10. Стенд: WSL2, Docker Compose, ветка `solution/bvt2301-churilin`. Чтобы не останавливать lab5, lab6 проверялась на loopback-портах 18080/13000/19090/13100/13200.
## Сборка и базовые проверки
```text
make check
PASS
make validate PYTHON=/home/d1frend/HL/mtusi2026lab5/.venv/bin/python
PASS
go test -count=1 ./...
PASS
go vet ./...
PASS
go build ./...
PASS
docker compose --env-file .env config --quiet
exit 0
```
После `docker compose --env-file .env up -d --build` healthy: обе API-реплики, load balancer, frontend, PostgreSQL, Redis, MinIO, RabbitMQ, Collector, Prometheus, Loki, Tempo и Grafana. Одноразовые migrate/minio-bootstrap завершились успешно.
## Публичный smoke
```text
make test BASE_URL=http://127.0.0.1:18080
PASS: signup/signin/session/me/search/chats/messages/cursors/attachments/auth/error format
```
## Наблюдаемость
Команда:
```sh
python3 tests/observability_grade3.py \
--prometheus-url http://127.0.0.1:19090 \
--loki-url http://127.0.0.1:13100 \
--tempo-url http://127.0.0.1:13200 \
--grafana-url http://127.0.0.1:13000 \
--timeout 90
```
Фактический итог:
```text
PASS: grade-3 metrics, structured logs, traces and Grafana dashboard verified.
api_metric_series=14
worker_metric_series=2
api_trace_id=e18612a970f7515c85473ed980f0fa12
worker_trace_id=5af46620fe843e5448bf60562ca92b0e
dashboard_uid=mtusi-lab6-grade3
```
После `make test` сценарий проверяет сохранённые сигналы:
1. проверяет API counter/histogram и worker counter/histogram в Prometheus;
2. проверяет `service_name`, `service_version`, `service_instance_id`, `deployment_environment_name=lab`;
3. отклоняет forbidden high-cardinality labels;
4. находит структурированные API/worker events в Loki и извлекает trace ID;
5. запрашивает соответствующие traces в Tempo;
6. проверяет health Grafana и provisioned dashboard UID.
Trace ID — диагностические идентификаторы, не секреты. В доказательства не включены credentials, токены, тела сообщений или байты вложений.
## Проверка сохранности бизнес-функций
Проверка выполнена после подключения instrumentation и после финального recreate сервисов. Публичный smoke прошёл повторно; Collector был перезапущен отдельно, при этом API оставался healthy. После восстановления Collector observability test снова увидел метрики, логи и трассы. Это подтверждает неблокирующий экспорт в проверенной модели кратковременной недоступности Collector.
## Два контролируемых отказа
Воспроизводимая команда для чистого стенда:
```sh
make test-observability-incidents
```
Она последовательно запускает `test-async-resilience`, `test-storage-outage` и затем проверяет сохранённые сигналы. На стенде с альтернативными портами финальный verifier дал:
```text
PASS
api_5xx_total=1
worker_failed_total=5
storage event=http_request_completed
storage route=POST /api/v1/chats/{chat_id}/attachments
storage status_code=503
storage trace_id=7773146a1f76d4048d2eca50f54a7443
worker event=attachment_job_failed
worker outcome=failed
worker attempt=1
worker trace_id=6a131a33b296ca076056c08015dc2a9e
```
Обе trace ID запрошены через Tempo API и содержат реальные batches/spans. Диагноз первого инцидента: S3/MinIO недоступен на upload-path, потому что API route одновременно дал 503/5xx и trace. Диагноз второго: worker не завершил attachment job и дошёл до bounded failure; это одновременно видно по `outcome=failed`, warn event и consumer trace.
Фактический fault injection MinIO:
```text
readiness_503_seconds=2.005
upload_503_seconds=5.009
original_bytes_verified=111817
PASS: MinIO outage returns bounded JSON 503 and preserves existing originals.
```
Фактический async resilience:
```text
PASS: durable recovery, idempotent redelivery and bounded final failure verified.
```
После этих экспериментов `go test -race -count=1 ./...` прошёл для всех пакетов.
## Контрольная нагрузка
```text
workload=closed-loop POST messages; no automatic retries
duration=30.016 s
concurrency=4
successful_requests=11556
failed_requests=0
successful_rps=384.99
p50=7.426 ms
p95=32.466 ms
p99=51.370 ms
```
Percentile относятся только к успешным запросам. Closed-loop создаёт coordinated omission, результат включает client overhead и служит проверкой генерации/наблюдаемости сигналов, а не переносимым performance benchmark.
+95
View File
@@ -0,0 +1,95 @@
# Lab 6 — evidence for grade 4
Environment: local Docker Compose, alternate loopback ports `18080/13000/19090/13100/13200`, 2026-11-12.
## Static and configuration checks
- `go test -count=1 ./...`: PASS.
- `docker compose config --quiet`: PASS.
- Collector `validate`: PASS.
- `promtool check config` and `promtool check rules`: PASS, 3 rules.
- Grafana dashboard UID `mtusi-lab6-grade4`: provisioned.
## End-to-end W3C trace
`make test-observability-grade4 ...`: PASS.
```json
{
"trace_id": "e219baae473d961c30c97857bbfb19dd",
"services": ["messenger-api", "messenger-dispatcher", "messenger-worker"],
"span_kinds": ["CLIENT", "CONSUMER", "PRODUCER", "SERVER"],
"span_count": 36,
"queue_metric_series": 2,
"db_pool_series": 12,
"dashboard_uid": "mtusi-lab6-grade4"
}
```
## Retry in the same trace
`make test-observability-retry-trace ...`: PASS.
```json
{
"trace_id": "0df6d4041008c05e5c2c77b0c2bd2ddf",
"attachment_status": "ready",
"attempts": [1, 2],
"producer_spans": 2,
"consumer_spans": 2,
"span_count": 46
}
```
The first attempt observed MinIO unavailable. After MinIO recovery, the second attempt succeeded. Both attempts, DB spans and S3 spans use the original upload trace ID.
## Alert firing and resolution
`make test-observability-alerts ...`: PASS.
```json
{
"queue_lag": {
"firing_after_seconds": 26.075,
"depth": 1,
"oldest_age_seconds": 21.156533,
"resolved_after_seconds": 8.009
},
"database_outage": {
"firing_after_seconds": 19.044,
"failed_requests": 8,
"trace_id": "db176205d463b89b73c737780e58cf06",
"error_span": "postgresql.acquire",
"resolved_after_seconds": 44.049
}
}
```
## Telemetry backend outage
`make test-telemetry-backend-outage ...`: PASS.
```json
{
"business_requests": 400,
"attachment_status": "ready",
"accepted_signal_delta": 3170,
"dropped_signal_delta": 75,
"collector_queue_size": 34,
"collector_queue_capacity": 256,
"collector_peak_memory_bytes": 261305139,
"collector_container_limit_bytes": 268435456,
"recovery_trace_id": "01806671c8d2cee14dc504f63a60197b"
}
```
No business request failed and the attachment reached `ready`. Telemetry loss began only after the bounded 30-second retry budget. Loki/Tempo recovery was confirmed by a fresh correlated log and Tempo trace.
## Lifecycle cleanup
At the end of the grade-4 work, `make cleanup-lab` completed successfully. Verified postcondition:
- no running/stopped `mtusi2026lab6-*` Compose containers;
- no locally built `mtusi2026lab6-*` images;
- named volumes remain for an intentional later resume: `broker_data`, `grafana_data`, `loki_data`, `minio_data`, `postgres_data`, `prometheus_data`, `tempo_data`;
- pulled third-party images and other labs are untouched.
+97
View File
@@ -0,0 +1,97 @@
# Lab 6 — evidence for grade 5, track 2
Date: 2026-11-12. Environment: local Docker Compose, alternate loopback ports `18080/13000/19090/13100/13200`.
## Configuration
- Track: SLO and incident detection.
- Policy window: 7 days, matching Prometheus retention.
- API SLO: 99% non-5xx, 1% error budget, recording rule `messenger:slo_api_success_ratio_7d`.
- Attachment SLO: 99% ready in no more than 10 seconds, 1% error budget, recording rule `messenger:slo_attachment_ready_ratio_7d`.
- Fast burn: 14.4x, 30s + 2m, `for: 10s`.
- Slow burn: 6x, 1m + 5m, `for: 20s`.
- Prometheus validation: PASS, 17 rules after the final audit.
- Grafana dashboard: `mtusi-lab6-grade5` provisioned.
- Runbook: `infrastructure/telemetry/runbooks/level5.md`.
The windows are intentionally compressed for a repeatable laboratory experiment. Burn factors remain dimensionless; production windows would be substantially longer.
## Reproducible command
```sh
make test-slo-burn-rate \
BASE_URL=http://127.0.0.1:18080 \
PROMETHEUS_URL=http://127.0.0.1:19090 \
LOKI_URL=http://127.0.0.1:13100 \
TEMPO_URL=http://127.0.0.1:13200 \
GRAFANA_URL=http://127.0.0.1:13000
```
Result: PASS.
```json
{
"api_slo": {
"brief_spike_failures": 4,
"false_positive": {
"pending_or_firing": 0,
"max_30s_ratio": 0.038461538461538464,
"max_5m_ratio": 0.007827788649706457
},
"sustained_failures": 136,
"detection_seconds": {
"MessengerAPIBurnRateSlow": 42.194,
"MessengerAPIBurnRateFast": 52.212
},
"recovery_seconds": 38.851,
"trace_id": "abac9b8b51c9b4bd3d05c26dab3e37ea",
"root_cause_span": "postgresql.acquire"
},
"attachment_ready_slo": {
"baseline_fast": 20,
"slow_over_10s": 5,
"recovery_fast": 100,
"detection_seconds": {
"MessengerAttachmentReadyBurnRateFast": 20.039,
"MessengerAttachmentReadyBurnRateSlow": 30.056
},
"recovery_seconds": 8.016,
"final_5m_slow_ratio": 0.04794240000000012
}
}
```
## Interpretation
The bounded four-error spike remained below both burn thresholds and produced no pending/firing state during the observation window. Sustained PostgreSQL unavailability fired both API alerts; Loki correlation and Tempo identified `postgresql.acquire`, so the runbook distinguishes pool/backend failure from handler latency.
Five delayed jobs consumed the ready SLO budget and fired both ready alerts. One hundred fast completions reduced the five-minute slow ratio below 6%, after which both alerts resolved.
False-positive evidence covers this controlled workload only. It is not a statistically significant production false-positive rate. No independent human runbook drill was performed; the black-box script follows the same steps automatically.
## Histogram calibration
`make test-histogram-calibration ...`: PASS.
```json
{
"samples": {"http": 400, "attachments": 12},
"http_p95_seconds": {
"client": 0.003569880000213743,
"prometheus": 0.004909843739733048,
"ratio": 1.375352599930271
},
"ready_p95_seconds": {
"client_polling_upper_bound": 1.0131328810002742,
"prometheus": 0.9458333333333333,
"ratio": 0.9335728324200716
},
"worker_p95_seconds": 0.0975
}
```
Exported HTTP buckets begin at 5 ms, worker buckets at 50 ms and ready buckets at 100 ms. The client/Prometheus values have the same order of magnitude and use seconds consistently.
## Lifecycle cleanup
`make cleanup-lab` completed successfully after the grade-5 regression. A Docker inventory confirmed no lab1–lab6 containers, locally built images or Compose networks remain. Lab5 and lab6 named volumes were intentionally preserved; no pulled third-party image or unrelated Docker resource was selected for removal.
+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"],
},
});
+60
View File
@@ -0,0 +1,60 @@
module mtusi2026lab6
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.14.0
github.com/redis/go-redis/v9 v9.23.0
go.opentelemetry.io/otel v1.46.0
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.22.0
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0
go.opentelemetry.io/otel/log v0.22.0
go.opentelemetry.io/otel/metric v1.46.0
go.opentelemetry.io/otel/sdk v1.46.0
go.opentelemetry.io/otel/sdk/log v0.22.0
go.opentelemetry.io/otel/sdk/metric v1.46.0
go.opentelemetry.io/otel/trace v1.46.0
golang.org/x/crypto v0.58.1-0.20261009181718-2f1f834330b2
golang.org/x/image v0.45.0
)
require (
github.com/cenkalti/backoff/v5 v5.0.3 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/go-logr/logr v1.4.4 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/klauspost/compress v1.20.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.opentelemetry.io/auto/sdk v1.2.1 // indirect
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 // indirect
go.opentelemetry.io/proto/otlp v1.11.0 // indirect
go.uber.org/atomic v1.12.0 // indirect
go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/net v0.62.0 // indirect
golang.org/x/sync v0.24.0 // indirect
golang.org/x/sys v0.49.0 // indirect
golang.org/x/text v0.43.0 // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 // indirect
google.golang.org/grpc v1.83.2 // indirect
google.golang.org/protobuf v1.36.12 // indirect
gopkg.in/ini.v1 v1.67.3 // indirect
)
+142
View File
@@ -0,0 +1,142 @@
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/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
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/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.4.4 h1:tG4xh9yMsRCAiodLVTxyrkzSZ9+o0L1Kg/+cPVcbP/8=
github.com/go-logr/logr v1.4.4/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 h1:/Tnpcb2E0Pz/tN9s3bfEY2Q8ePCEX9iuS+cneUwncnw=
github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0/go.mod h1:zOBXOsUaBSjKgmH4OGzV1esUpR3oUSCPYVd2cUBjKYY=
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.20.2 h1:v5tiZvm1KGLyg5d5oXdXe3lsSPrbEUiKoXGia//I7Qo=
github.com/klauspost/compress v1.20.2/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
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.14.0 h1:RSaT7aOKt/OrkVUyswPDW29lnRz9psuGmfZFBmLqLek=
github.com/rabbitmq/amqp091-go v1.14.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.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
go.opentelemetry.io/otel v1.46.0 h1:FHt5/CDyVxi/8IM1CH7VE/rRgq3kLHa2mSTVMO8AWyc=
go.opentelemetry.io/otel v1.46.0/go.mod h1:Gj3SEScelsNC45tp4nSxRYlS+f5iez7W8XPMCt905kE=
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.22.0 h1:lYk7RmxdLK865qLwibroNGldHa1U7SWKYYvNjlK7PIo=
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.22.0/go.mod h1:6GvlND0H0xdUJanOtIAn0xfwLkauh1tmsYEEVSMDdqY=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0 h1:AP23h/mFgb/lc7tdck1Kfn9qxsM8TAeNPCU5C3pzaps=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.46.0/go.mod h1:K4EqCe1b4kGk5WR690ntg9LaBfsPoV32FwthbyoptuA=
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0 h1:OFnwLJr+pF3iHrlGSzbxyuo6/6HyBlnlN1CWEJmBVcw=
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.46.0/go.mod h1:716wFneO0ov19A2beH5hjfh9AK5z/VWNAtDijp1Y0/g=
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0 h1:KrC1YrQeSt46ITMWAbgQx1M1eV1/1TKzttrBzymPmss=
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.46.0/go.mod h1:zDSEzoEqsOrgBeGvH66KRgxh90VonFyJqBHA0Pk3+rM=
go.opentelemetry.io/otel/log v0.22.0 h1:5DBNnfvaJ6CVdkJ+Jle8Tzs50aSSv49TXGj9XRsEYw0=
go.opentelemetry.io/otel/log v0.22.0/go.mod h1:gzOt/R67vF2GniAqWu8Qv0SXy89f71muHcrkz76PCdc=
go.opentelemetry.io/otel/metric v1.46.0 h1:yBnkXvgV7AXFILZc5K6IZe/CBFF3OS7BJ8ov6/lj0K8=
go.opentelemetry.io/otel/metric v1.46.0/go.mod h1:iPmdWqifKUdzziPkvvzIJXITl56fQx2mGM/DHLB3/2o=
go.opentelemetry.io/otel/metric/x v0.68.0 h1:TA/cBT23D3MnxYPwHL7YFOdYGdx0A0v+s7Mzotpd1dU=
go.opentelemetry.io/otel/metric/x v0.68.0/go.mod h1:agudOmvWhwUTjgibWDzxD2PoWYnpw5Ht5jISYOD2Hd4=
go.opentelemetry.io/otel/sdk v1.46.0 h1:h5CNQQjEbuQXY/JfZtgt3i7HVFV3aHPO2OAwO2eTYPI=
go.opentelemetry.io/otel/sdk v1.46.0/go.mod h1:GAERFXFt5SYCEB+YiKUbMBeza6UaDH7GmGOZEfh2gSM=
go.opentelemetry.io/otel/sdk/log v0.22.0 h1:PRL+s6P63XT4E/bheEflopPUpVxuvANqZwtt89yhoGk=
go.opentelemetry.io/otel/sdk/log v0.22.0/go.mod h1:JNp0sBELrjCTcu5W3GzABVypeU6vDJjBS+X0JISuz+g=
go.opentelemetry.io/otel/sdk/log/logtest v0.22.0 h1:infPnfNrhCNgOUZRs3gWUg8vhoBUHihq02gwK05gzlg=
go.opentelemetry.io/otel/sdk/log/logtest v0.22.0/go.mod h1:gkQZA3z15Bv3KU9vigBTi8dFechSozRP7v94X4VZv+s=
go.opentelemetry.io/otel/sdk/metric v1.46.0 h1:0piZ26EG4RBfebb2jhDH6ERCYHoVWduc3kLgPCwSnSE=
go.opentelemetry.io/otel/sdk/metric v1.46.0/go.mod h1:I1PbKrdVc8Qu8HYVDNtqVIwLwjNrhsV/uFuxfwg8mO4=
go.opentelemetry.io/otel/trace v1.46.0 h1:OULy7ccdJnZtJ0UDYFOIGaCmiWzJ8Vi2G/Rsu60qs1c=
go.opentelemetry.io/otel/trace v1.46.0/go.mod h1:J7GAXweO77XSFkB/rmAqk9D6ihszhFjLU+d9WuUxDLI=
go.opentelemetry.io/proto/otlp v1.11.0 h1:5rrYs0Ykyj50sdU/JU0x8etU+LubXWb+gED6TbEdMIk=
go.opentelemetry.io/proto/otlp v1.11.0/go.mod h1:SmVizdCOAm3XBtG1g1NnOdhW6jtddT72hLMhv8VwA8E=
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.58.1-0.20261009181718-2f1f834330b2 h1:zGDaB+/Mus2mScKvZ23k+W9NAUbP56sNM9SptgvWI5A=
golang.org/x/crypto v0.58.1-0.20261009181718-2f1f834330b2/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/image v0.45.0 h1:FMb1nTbH5H9vF55SriQHgFw5GnNL9Jg6L25BwXKzhB0=
golang.org/x/image v0.45.0/go.mod h1:n62x/7RqlwXDvGsSU4u6IUTUf6KghUZ9Bt7cG/T9Fx4=
golang.org/x/net v0.62.0 h1:18ELalfM5+XNRwzM2nYqXsZQ9ByS1uhj2O/U7+5jqRY=
golang.org/x/net v0.62.0/go.mod h1:WgDCOTH8iwtB66T4/GfI94AHo/hhdb7Hah9NDseQfiI=
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688 h1:ax2KzoSRIZU/M0cIxri3pKxy99vniH1PVxWC6si/eZI=
google.golang.org/genproto/googleapis/api v0.0.0-20260819154853-08b0e4226688/go.mod h1:1RJ9BQGyNdZwkGc1eTqkErfRZ6RJyYPHZo73BZ1vQqI=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688 h1:cYNAzI2sUwhmCcoj9TxvihSrqsxt6uIkj3rDRhSDmW4=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260819154853-08b0e4226688/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA=
google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU=
google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8=
google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc=
google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/ini.v1 v1.67.3 h1:iM9Lhz5MRSGhHVGGwCuzG9KO8PoirCXj/m/qTmOJJQw=
gopkg.in/ini.v1 v1.67.3/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+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;
}
}
}
@@ -0,0 +1,80 @@
{
"annotations": {"list": []},
"editable": false,
"fiscalYearStartMonth": 0,
"graphTooltip": 1,
"id": null,
"links": [],
"liveNow": false,
"panels": [
{
"datasource": {"type": "prometheus", "uid": "prometheus"},
"fieldConfig": {"defaults": {"unit": "reqps"}, "overrides": []},
"gridPos": {"h": 8, "w": 8, "x": 0, "y": 0},
"id": 1,
"options": {"legend": {"displayMode": "table", "placement": "bottom"}},
"targets": [{"expr": "sum(rate(messenger_http_server_requests_total[1m]))", "legendFormat": "all requests", "refId": "A"}],
"title": "API request rate",
"type": "timeseries"
},
{
"datasource": {"type": "prometheus", "uid": "prometheus"},
"fieldConfig": {"defaults": {"unit": "reqps"}, "overrides": []},
"gridPos": {"h": 8, "w": 8, "x": 8, "y": 0},
"id": 2,
"options": {"legend": {"displayMode": "table", "placement": "bottom"}},
"targets": [{"expr": "sum by (status_class) (rate(messenger_http_server_requests_total[1m]))", "legendFormat": "{{status_class}}", "refId": "A"}],
"title": "API responses by status class",
"type": "timeseries"
},
{
"datasource": {"type": "prometheus", "uid": "prometheus"},
"fieldConfig": {"defaults": {"unit": "s"}, "overrides": []},
"gridPos": {"h": 8, "w": 8, "x": 16, "y": 0},
"id": 3,
"options": {"legend": {"displayMode": "table", "placement": "bottom"}},
"targets": [{"expr": "histogram_quantile(0.95, sum by (le) (rate(messenger_http_server_duration_seconds_bucket[5m])))", "legendFormat": "p95", "refId": "A"}],
"title": "API duration",
"type": "timeseries"
},
{
"datasource": {"type": "prometheus", "uid": "prometheus"},
"fieldConfig": {"defaults": {"unit": "jobs"}, "overrides": []},
"gridPos": {"h": 8, "w": 12, "x": 0, "y": 8},
"id": 4,
"options": {"legend": {"displayMode": "table", "placement": "bottom"}},
"targets": [{"expr": "sum by (outcome) (increase(messenger_worker_jobs_total[5m]))", "legendFormat": "{{outcome}}", "refId": "A"}],
"title": "Worker jobs by outcome",
"type": "timeseries"
},
{
"datasource": {"type": "prometheus", "uid": "prometheus"},
"fieldConfig": {"defaults": {"unit": "s"}, "overrides": []},
"gridPos": {"h": 8, "w": 12, "x": 12, "y": 8},
"id": 5,
"options": {"legend": {"displayMode": "table", "placement": "bottom"}},
"targets": [{"expr": "histogram_quantile(0.95, sum by (le, outcome) (rate(messenger_worker_job_duration_seconds_bucket[5m])))", "legendFormat": "p95 {{outcome}}", "refId": "A"}],
"title": "Worker processing duration",
"type": "timeseries"
},
{
"datasource": {"type": "loki", "uid": "loki"},
"gridPos": {"h": 10, "w": 24, "x": 0, "y": 16},
"id": 6,
"options": {"dedupStrategy": "none", "enableLogDetails": true, "showCommonLabels": false, "showLabels": false, "showTime": true, "sortOrder": "Descending", "wrapLogMessage": true},
"targets": [{"expr": "{service_name=~\"messenger-(api|worker)\"}", "queryType": "range", "refId": "A"}],
"title": "Correlated structured logs",
"type": "logs"
}
],
"refresh": "5s",
"schemaVersion": 41,
"tags": ["mtusi", "lab6", "grade3"],
"templating": {"list": []},
"time": {"from": "now-15m", "to": "now"},
"timepicker": {},
"timezone": "browser",
"title": "MTUSI Lab 6 — Grade 3",
"uid": "mtusi-lab6-grade3",
"version": 1
}
@@ -0,0 +1,543 @@
{
"annotations": {
"list": []
},
"editable": false,
"graphTooltip": 1,
"id": null,
"links": [],
"panels": [
{
"id": 1,
"title": "API RPS",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 6,
"x": 0,
"y": 0
},
"fieldConfig": {
"defaults": {
"unit": "reqps"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "sum(rate(messenger_http_server_requests_total[1m]))",
"legendFormat": "requests/s"
}
]
},
{
"id": 2,
"title": "API 5xx ratio",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 6,
"x": 6,
"y": 0
},
"fieldConfig": {
"defaults": {
"unit": "percentunit"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "sum(rate(messenger_http_server_requests_total{status_class=\"5xx\"}[1m])) / clamp_min(sum(rate(messenger_http_server_requests_total[1m])), 0.000001)",
"legendFormat": "5xx / all"
}
]
},
{
"id": 3,
"title": "API latency p50/p95/p99",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 12,
"x": 12,
"y": 0
},
"fieldConfig": {
"defaults": {
"unit": "s"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "histogram_quantile(0.50, sum by (le) (rate(messenger_http_server_duration_seconds_bucket[5m])))",
"legendFormat": "p50"
},
{
"refId": "B",
"expr": "histogram_quantile(0.95, sum by (le) (rate(messenger_http_server_duration_seconds_bucket[5m])))",
"legendFormat": "p95"
},
{
"refId": "C",
"expr": "histogram_quantile(0.99, sum by (le) (rate(messenger_http_server_duration_seconds_bucket[5m])))",
"legendFormat": "p99"
}
]
},
{
"id": 4,
"title": "Queue depth / oldest age seconds",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 0,
"y": 7
},
"fieldConfig": {
"defaults": {
"unit": "short"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "max(messenger_queue_depth)",
"legendFormat": "depth"
},
{
"refId": "B",
"expr": "max(messenger_queue_oldest_job_age_seconds)",
"legendFormat": "oldest age s"
}
]
},
{
"id": 5,
"title": "Worker saturation",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 8,
"y": 7
},
"fieldConfig": {
"defaults": {
"unit": "percentunit"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "max(messenger_worker_busy) / clamp_min(max(messenger_worker_capacity), 1)",
"legendFormat": "busy / capacity"
}
]
},
{
"id": 6,
"title": "Time to ready p50/p95/p99",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 16,
"y": 7
},
"fieldConfig": {
"defaults": {
"unit": "s"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "histogram_quantile(0.50, sum by (le) (rate(messenger_attachment_ready_duration_seconds_bucket[5m])))",
"legendFormat": "p50"
},
{
"refId": "B",
"expr": "histogram_quantile(0.95, sum by (le) (rate(messenger_attachment_ready_duration_seconds_bucket[5m])))",
"legendFormat": "p95"
},
{
"refId": "C",
"expr": "histogram_quantile(0.99, sum by (le) (rate(messenger_attachment_ready_duration_seconds_bucket[5m])))",
"legendFormat": "p99"
}
]
},
{
"id": 7,
"title": "PostgreSQL pool used/idle/capacity",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 0,
"y": 14
},
"fieldConfig": {
"defaults": {
"unit": "short"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "sum by (service_name, state) (messenger_db_pool_connections)",
"legendFormat": "{{service_name}} {{state}}"
}
]
},
{
"id": 8,
"title": "PostgreSQL pool waits",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 8,
"y": 14
},
"fieldConfig": {
"defaults": {
"unit": "ops"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "sum by (service_name) (rate(messenger_db_pool_waits_total[5m]))",
"legendFormat": "{{service_name}} waits/s"
}
]
},
{
"id": 9,
"title": "Process CPU",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 16,
"y": 14
},
"fieldConfig": {
"defaults": {
"unit": "percentunit"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "sum by (service_name) (rate(messenger_process_cpu_time_seconds_total[5m]))",
"legendFormat": "{{service_name}}"
}
]
},
{
"id": 10,
"title": "Process RSS",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 0,
"y": 21
},
"fieldConfig": {
"defaults": {
"unit": "bytes"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "max by (service_name) (messenger_process_memory_bytes)",
"legendFormat": "{{service_name}}"
}
]
},
{
"id": 11,
"title": "Worker jobs and p95 duration",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 8,
"y": 21
},
"fieldConfig": {
"defaults": {
"unit": "short"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "sum by (outcome) (rate(messenger_worker_jobs_total[5m]))",
"legendFormat": "jobs/s {{outcome}}"
},
{
"refId": "B",
"expr": "histogram_quantile(0.95, sum by (le, outcome) (rate(messenger_worker_job_duration_seconds_bucket[5m])))",
"legendFormat": "p95 s {{outcome}}"
}
]
},
{
"id": 12,
"title": "Collector bounded queues / drops",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 16,
"y": 21
},
"fieldConfig": {
"defaults": {
"unit": "short"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "otelcol_exporter_queue_size",
"legendFormat": "queue {{exporter}}"
},
{
"refId": "B",
"expr": "otelcol_exporter_queue_capacity",
"legendFormat": "capacity {{exporter}}"
},
{
"refId": "C",
"expr": "(sum(rate(otelcol_exporter_send_failed_log_records[5m])) or vector(0)) + (sum(rate(otelcol_exporter_send_failed_spans[5m])) or vector(0))",
"legendFormat": "drops/s"
}
]
},
{
"id": 13,
"title": "Alert state",
"type": "timeseries",
"datasource": {
"type": "prometheus",
"uid": "prometheus"
},
"gridPos": {
"h": 7,
"w": 8,
"x": 0,
"y": 28
},
"fieldConfig": {
"defaults": {
"unit": "short"
},
"overrides": []
},
"options": {
"legend": {
"displayMode": "table",
"placement": "bottom"
}
},
"targets": [
{
"refId": "A",
"expr": "ALERTS{alertname=~\"Messenger(APIHighErrorRate|QueueLagGrowing)\"}",
"legendFormat": "{{alertname}} {{alertstate}}"
}
]
},
{
"id": 14,
"title": "Correlated logs",
"type": "logs",
"datasource": {
"type": "loki",
"uid": "loki"
},
"gridPos": {
"h": 10,
"w": 16,
"x": 8,
"y": 28
},
"targets": [
{
"refId": "A",
"expr": "{service_name=~\"messenger-(api|worker|dispatcher)\"}",
"queryType": "range"
}
],
"options": {
"dedupStrategy": "none",
"enableLogDetails": true,
"showCommonLabels": false,
"showLabels": false,
"showTime": true,
"sortOrder": "Descending",
"wrapLogMessage": true
}
}
],
"refresh": "5s",
"schemaVersion": 41,
"tags": [
"mtusi",
"lab6",
"grade4"
],
"templating": {
"list": []
},
"time": {
"from": "now-30m",
"to": "now"
},
"timepicker": {},
"timezone": "browser",
"title": "MTUSI Lab 6 - Grade 4",
"uid": "mtusi-lab6-grade4",
"version": 1
}
@@ -0,0 +1,69 @@
{
"annotations": {"list": []},
"editable": false,
"graphTooltip": 1,
"id": null,
"panels": [
{
"id": 1,
"title": "API error ratio by burn window",
"type": "timeseries",
"datasource": {"type": "prometheus", "uid": "prometheus"},
"gridPos": {"h": 9, "w": 12, "x": 0, "y": 0},
"fieldConfig": {"defaults": {"unit": "percentunit"}, "overrides": []},
"targets": [
{"refId": "A", "expr": "messenger:sli_api_error_ratio_30s", "legendFormat": "30s"},
{"refId": "B", "expr": "messenger:sli_api_error_ratio_1m", "legendFormat": "1m"},
{"refId": "C", "expr": "messenger:sli_api_error_ratio_2m", "legendFormat": "2m"},
{"refId": "D", "expr": "messenger:sli_api_error_ratio_5m", "legendFormat": "5m"}
]
},
{
"id": 2,
"title": "Attachment >10s ratio by burn window",
"type": "timeseries",
"datasource": {"type": "prometheus", "uid": "prometheus"},
"gridPos": {"h": 9, "w": 12, "x": 12, "y": 0},
"fieldConfig": {"defaults": {"unit": "percentunit"}, "overrides": []},
"targets": [
{"refId": "A", "expr": "messenger:sli_attachment_slow_ratio_30s", "legendFormat": "30s"},
{"refId": "B", "expr": "messenger:sli_attachment_slow_ratio_1m", "legendFormat": "1m"},
{"refId": "C", "expr": "messenger:sli_attachment_slow_ratio_2m", "legendFormat": "2m"},
{"refId": "D", "expr": "messenger:sli_attachment_slow_ratio_5m", "legendFormat": "5m"}
]
},
{
"id": 3,
"title": "SLO compliance (7d policy window)",
"type": "timeseries",
"datasource": {"type": "prometheus", "uid": "prometheus"},
"gridPos": {"h": 8, "w": 12, "x": 0, "y": 9},
"fieldConfig": {"defaults": {"unit": "percentunit", "min": 0, "max": 1}, "overrides": []},
"targets": [
{"refId": "A", "expr": "messenger:slo_api_success_ratio_7d", "legendFormat": "API success"},
{"refId": "B", "expr": "messenger:slo_attachment_ready_ratio_7d", "legendFormat": "ready <=10s"},
{"refId": "C", "expr": "vector(0.99)", "legendFormat": "99% objective"}
]
},
{
"id": 4,
"title": "Burn-rate alert states",
"type": "timeseries",
"datasource": {"type": "prometheus", "uid": "prometheus"},
"gridPos": {"h": 8, "w": 12, "x": 12, "y": 9},
"fieldConfig": {"defaults": {"unit": "short"}, "overrides": []},
"targets": [
{"refId": "A", "expr": "ALERTS{alertname=~\"Messenger(API|AttachmentReady)BurnRate(Fast|Slow)\"}", "legendFormat": "{{alertname}} {{alertstate}}"}
]
}
],
"refresh": "5s",
"schemaVersion": 42,
"tags": ["mtusi", "lab6", "grade5", "slo", "burn-rate"],
"templating": {"list": []},
"time": {"from": "now-30m", "to": "now"},
"timezone": "browser",
"title": "MTUSI Lab 6 - Grade 5 SLO",
"uid": "mtusi-lab6-grade5",
"version": 1
}
@@ -0,0 +1,12 @@
apiVersion: 1
providers:
- name: MTUSI Lab 6
orgId: 1
folder: Lab 6
type: file
disableDeletion: true
editable: false
updateIntervalSeconds: 10
options:
path: /var/lib/grafana/dashboards
@@ -0,0 +1,44 @@
apiVersion: 1
datasources:
- name: Prometheus
uid: prometheus
type: prometheus
access: proxy
url: http://prometheus:9090
isDefault: true
editable: false
- name: Loki
uid: loki
type: loki
access: proxy
url: http://loki:3100
editable: false
jsonData:
derivedFields:
- name: TraceID
matcherRegex: '([0-9a-f]{32})'
datasourceUid: tempo
url: '$${__value.raw}'
- name: Tempo
uid: tempo
type: tempo
access: proxy
url: http://tempo:3200
editable: false
jsonData:
tracesToLogsV2:
datasourceUid: loki
spanStartTimeShift: -1m
spanEndTimeShift: 1m
tags:
- key: service.name
value: service_name
filterByTraceID: true
filterBySpanID: true
serviceMap:
datasourceUid: prometheus
nodeGraph:
enabled: true
+34
View File
@@ -0,0 +1,34 @@
auth_enabled: false
server:
http_listen_port: 3100
common:
path_prefix: /loki
replication_factor: 1
ring:
kvstore:
store: inmemory
storage:
filesystem:
chunks_directory: /loki/chunks
rules_directory: /loki/rules
schema_config:
configs:
- from: 2024-01-01
store: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
limits_config:
allow_structured_metadata: true
retention_period: 168h
compactor:
working_directory: /loki/compactor
retention_enabled: true
delete_request_store: filesystem
@@ -0,0 +1,72 @@
extensions:
health_check:
endpoint: 0.0.0.0:13133
receivers:
otlp:
protocols:
http:
endpoint: 0.0.0.0:4318
processors:
memory_limiter:
check_interval: 1s
limit_mib: 192
spike_limit_mib: 48
batch:
timeout: 1s
send_batch_size: 256
send_batch_max_size: 512
exporters:
prometheus:
endpoint: 0.0.0.0:8889
resource_constant_labels:
included: [service.name, service.version, service.instance.id, deployment.environment.name]
otlp_http/tempo:
endpoint: http://tempo:4318
timeout: 3s
sending_queue:
enabled: true
num_consumers: 2
queue_size: 256
retry_on_failure:
enabled: true
initial_interval: 1s
max_interval: 5s
max_elapsed_time: 30s
otlp_http/loki:
endpoint: http://loki:3100/otlp
timeout: 3s
sending_queue:
enabled: true
num_consumers: 2
queue_size: 256
retry_on_failure:
enabled: true
initial_interval: 1s
max_interval: 5s
max_elapsed_time: 30s
service:
extensions: [health_check]
pipelines:
metrics:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [prometheus]
logs:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlp_http/loki]
traces:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlp_http/tempo]
telemetry:
logs:
level: info
metrics:
level: detailed
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
@@ -0,0 +1,12 @@
global:
scrape_interval: 5s
evaluation_interval: 5s
rule_files:
- /etc/prometheus/rules/*.yaml
scrape_configs:
- job_name: application-telemetry
static_configs:
- targets: [otel-collector:8889]
- job_name: collector-internal
static_configs:
- targets: [otel-collector:8888]
@@ -0,0 +1,97 @@
groups:
- name: messenger-level4
interval: 5s
rules:
- record: messenger:sli_api_success_ratio_5m
expr: 1 - (sum(rate(messenger_http_server_requests_total{status_class="5xx"}[5m])) / clamp_min(sum(rate(messenger_http_server_requests_total[5m])), 0.000001))
- alert: MessengerAPIHighErrorRate
expr: (sum(rate(messenger_http_server_requests_total{status_class="5xx"}[1m])) / clamp_min(sum(rate(messenger_http_server_requests_total[1m])), 0.000001)) > 0.01 and sum(rate(messenger_http_server_requests_total[1m])) > 0.05
for: 10s
labels:
severity: warning
slo: api-availability
annotations:
summary: API 5xx ratio exceeds the 99% availability SLO
description: More than 1% of business HTTP requests were 5xx during the last minute.
runbook: infrastructure/telemetry/runbooks/level4.md#api-high-error-rate
- alert: MessengerQueueLagGrowing
expr: max(messenger_queue_depth) > 0 and max(messenger_queue_oldest_job_age_seconds) > 10
for: 10s
labels:
severity: warning
slo: attachment-ready
annotations:
summary: Attachment queue lag is growing
description: At least one job has remained queued for more than 10 seconds.
runbook: infrastructure/telemetry/runbooks/level4.md#queue-lag-growing
- name: messenger-level5-burn-rate
interval: 5s
rules:
- record: messenger:slo_api_success_ratio_7d
expr: (1 - (sum(increase(messenger_http_server_requests_total{status_class="5xx"}[7d])) / clamp_min(sum(increase(messenger_http_server_requests_total[7d])), 1))) and sum(increase(messenger_http_server_requests_total[7d])) > 0
- record: messenger:slo_attachment_ready_ratio_7d
expr: (sum(increase(messenger_attachment_ready_duration_seconds_bucket{le="10.0"}[7d])) / clamp_min(sum(increase(messenger_attachment_ready_duration_seconds_count[7d])), 1)) and sum(increase(messenger_attachment_ready_duration_seconds_count[7d])) > 0
- record: messenger:sli_api_error_ratio_30s
expr: sum(rate(messenger_http_server_requests_total{status_class="5xx"}[30s])) / clamp_min(sum(rate(messenger_http_server_requests_total[30s])), 0.000001)
- record: messenger:sli_api_error_ratio_1m
expr: sum(rate(messenger_http_server_requests_total{status_class="5xx"}[1m])) / clamp_min(sum(rate(messenger_http_server_requests_total[1m])), 0.000001)
- record: messenger:sli_api_error_ratio_2m
expr: sum(rate(messenger_http_server_requests_total{status_class="5xx"}[2m])) / clamp_min(sum(rate(messenger_http_server_requests_total[2m])), 0.000001)
- record: messenger:sli_api_error_ratio_5m
expr: sum(rate(messenger_http_server_requests_total{status_class="5xx"}[5m])) / clamp_min(sum(rate(messenger_http_server_requests_total[5m])), 0.000001)
- record: messenger:sli_attachment_slow_ratio_30s
expr: (sum(rate(messenger_attachment_ready_duration_seconds_count[30s])) - sum(rate(messenger_attachment_ready_duration_seconds_bucket{le="10.0"}[30s]))) / clamp_min(sum(rate(messenger_attachment_ready_duration_seconds_count[30s])), 0.000001)
- record: messenger:sli_attachment_slow_ratio_1m
expr: (sum(rate(messenger_attachment_ready_duration_seconds_count[1m])) - sum(rate(messenger_attachment_ready_duration_seconds_bucket{le="10.0"}[1m]))) / clamp_min(sum(rate(messenger_attachment_ready_duration_seconds_count[1m])), 0.000001)
- record: messenger:sli_attachment_slow_ratio_2m
expr: (sum(rate(messenger_attachment_ready_duration_seconds_count[2m])) - sum(rate(messenger_attachment_ready_duration_seconds_bucket{le="10.0"}[2m]))) / clamp_min(sum(rate(messenger_attachment_ready_duration_seconds_count[2m])), 0.000001)
- record: messenger:sli_attachment_slow_ratio_5m
expr: (sum(rate(messenger_attachment_ready_duration_seconds_count[5m])) - sum(rate(messenger_attachment_ready_duration_seconds_bucket{le="10.0"}[5m]))) / clamp_min(sum(rate(messenger_attachment_ready_duration_seconds_count[5m])), 0.000001)
- alert: MessengerAPIBurnRateFast
expr: messenger:sli_api_error_ratio_30s > (14.4 * 0.01) and messenger:sli_api_error_ratio_2m > (14.4 * 0.01) and sum(rate(messenger_http_server_requests_total[30s])) > 0.1
for: 10s
labels:
severity: page
slo: api-availability
burn_rate: fast
annotations:
summary: API consumes the 1% error budget at fast burn rate
description: Both 30s and 2m windows exceed 14.4x burn rate.
runbook: infrastructure/telemetry/runbooks/level5.md#api-burn-rate
- alert: MessengerAPIBurnRateSlow
expr: messenger:sli_api_error_ratio_1m > (6 * 0.01) and messenger:sli_api_error_ratio_5m > (6 * 0.01) and sum(rate(messenger_http_server_requests_total[1m])) > 0.05
for: 20s
labels:
severity: ticket
slo: api-availability
burn_rate: slow
annotations:
summary: API consumes the 1% error budget at sustained burn rate
description: Both 1m and 5m windows exceed 6x burn rate.
runbook: infrastructure/telemetry/runbooks/level5.md#api-burn-rate
- alert: MessengerAttachmentReadyBurnRateFast
expr: messenger:sli_attachment_slow_ratio_30s > (14.4 * 0.01) and messenger:sli_attachment_slow_ratio_2m > (14.4 * 0.01) and sum(rate(messenger_attachment_ready_duration_seconds_count[30s])) > 0
for: 10s
labels:
severity: page
slo: attachment-ready
burn_rate: fast
annotations:
summary: Attachment ready latency consumes its error budget quickly
description: More than 14.4% of completed attachments exceed 10s in both windows.
runbook: infrastructure/telemetry/runbooks/level5.md#attachment-ready-burn-rate
- alert: MessengerAttachmentReadyBurnRateSlow
expr: messenger:sli_attachment_slow_ratio_1m > (6 * 0.01) and messenger:sli_attachment_slow_ratio_5m > (6 * 0.01) and sum(rate(messenger_attachment_ready_duration_seconds_count[1m])) > 0
for: 20s
labels:
severity: ticket
slo: attachment-ready
burn_rate: slow
annotations:
summary: Attachment ready latency consumes its error budget persistently
description: More than 6% of completed attachments exceed 10s in both windows.
runbook: infrastructure/telemetry/runbooks/level5.md#attachment-ready-burn-rate
@@ -0,0 +1,24 @@
# Runbook уровня 4
## API high error rate
1. Сравнить error ratio с RPS на dashboard.
2. Найти в Loki `{service_name="messenger-api"} | status_class="5xx"`.
3. Открыть `trace_id` в Tempo.
4. Ошибочный `postgresql.*` client span указывает на БД; медленный server span без медленного DB child — на handler/внешнюю зависимость.
5. Проверить DB pool used/capacity и rate waits.
6. После восстановления создать успешные запросы и дождаться `resolved`.
## Queue lag growing
1. Сравнить `messenger_queue_depth` и `messenger_queue_oldest_job_age_seconds`.
2. Проверить worker busy/capacity и `attachment_job_failed` в Loki.
3. Открыть consumer trace и S3/PostgreSQL child spans.
4. Восстановить worker; depth/age должны вернуться к нулю, alert — в `resolved`.
## Telemetry backend unavailable
1. Проверить `otelcol_exporter_queue_size`, capacity и failure counters.
2. Memory limiter — 192 MiB при container limit 256 MiB; exporter queues — 256 batches.
3. API/очередь не зависят от Loki/Tempo. После 30 s retry telemetry может отбрасываться — это bounded degradation.
4. После восстановления backend проверить уменьшение очереди и появление новых сигналов.
@@ -0,0 +1,31 @@
# Runbook уровня 5: SLO burn rate
## SLO и приоритет
- Policy window — 7 дней, что совпадает с retention Prometheus.
- API availability SLO: не менее 99% HTTP-запросов без 5xx (`messenger:slo_api_success_ratio_7d`).
- Attachment ready SLO: не менее 99% успешно завершённых attachments переходят в `ready` не позднее 10 секунд после durable acceptance (`messenger:slo_attachment_ready_ratio_7d`).
- `fast` (14.4x, 30s + 2m) — page: бюджет расходуется достаточно быстро для немедленного вмешательства.
- `slow` (6x, 1m + 5m) — ticket: деградация устойчивее, но допускает более спокойную диагностику.
- Оба окна должны нарушаться одновременно. Traffic guard исключает алерт при отсутствии наблюдений.
## API burn rate
1. В Prometheus открыть `ALERTS{alertname=~"MessengerAPIBurnRate(Fast|Slow)"}` и записать `activeAt`.
2. Сравнить `messenger:sli_api_error_ratio_30s`, `_1m`, `_2m`, `_5m` и RPS. Одно короткое окно без длинного не считается burn-rate инцидентом.
3. В Loki выполнить `{service_name="messenger-api"} | status_class="5xx"` и взять свежие `request_id`/`trace_id`.
4. Открыть trace в Tempo. `postgresql.acquire` error означает исчерпание/недоступность pool; `postgresql.*` query error — ошибку операции; медленный server span без DB/S3 child указывает на handler.
5. Проверить `messenger_db_pool_connections`, `messenger_db_pool_waits_total`, process RAM/CPU и health зависимостей.
6. Восстановить зависимость, создать контрольные успешные запросы. Зафиксировать момент исчезновения alert и recovery time.
## Attachment ready burn rate
1. Сравнить `messenger:sli_attachment_slow_ratio_30s`, `_1m`, `_2m`, `_5m` с queue depth/oldest age.
2. Проверить `messenger_worker_busy / messenger_worker_capacity`; saturation около 1 при растущей очереди означает недостаточную worker capacity.
3. Найти `attachment_job_failed`/`attachment_job_completed` в Loki и перейти по trace ID к producer/consumer spans.
4. Ошибка `s3.*` указывает на object storage; `postgresql.*` — на DB; длинный разрыв между producer и consumer — на queue/worker.
5. Восстановить worker/backend. Убедиться, что новые attachments укладываются в 10 секунд, оба burn-rate alert исчезли, queue age вернулся к нулю.
## Проверка ложного срабатывания
`tests/slo_burn_rate.py` сначала создаёт большой успешный baseline, затем короткий ограниченный 5xx burst. В течение observation window ни `Fast`, ни `Slow` не должны перейти в `pending` или `firing`. Далее тот же тест создаёт длительную DB-деградацию и измеряет detection/recovery. Это отделяет чувствительность к реальному расходованию бюджета от реакции на единичную ошибку.
@@ -0,0 +1,21 @@
server:
http_listen_port: 3200
distributor:
receivers:
otlp:
protocols:
http:
endpoint: 0.0.0.0:4318
storage:
trace:
backend: local
wal:
path: /var/tempo/wal
local:
path: /var/tempo/blocks
compactor:
compaction:
block_retention: 168h
+170
View File
@@ -0,0 +1,170 @@
package broker
import (
"context"
"encoding/json"
"fmt"
"sync"
"time"
"mtusi2026lab6/internal/domain"
amqp "github.com/rabbitmq/amqp091-go"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/propagation"
"go.opentelemetry.io/otel/trace"
)
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) (err error) {
parentCarrier := propagation.MapCarrier{}
if job.TraceParent != "" {
parentCarrier.Set("traceparent", job.TraceParent)
}
if job.TraceState != "" {
parentCarrier.Set("tracestate", job.TraceState)
}
ctx = otel.GetTextMapPropagator().Extract(ctx, parentCarrier)
ctx, span := otel.Tracer("mtusi2026lab6/broker").Start(
ctx,
QueueName+" publish",
trace.WithSpanKind(trace.SpanKindProducer),
trace.WithAttributes(
attribute.String("messaging.system", "rabbitmq"),
attribute.String("messaging.destination.name", QueueName),
attribute.String("messaging.operation.name", "publish"),
attribute.Int("job.attempt", job.Attempt),
),
)
defer func() {
if err != nil {
span.SetStatus(codes.Error, "broker publish failed")
} else {
span.SetStatus(codes.Ok, "")
}
span.End()
}()
body, err := json.Marshal(job.Message())
if err != nil {
return fmt.Errorf("encode attachment job: %w", err)
}
traceCarrier := propagation.MapCarrier{}
otel.GetTextMapPropagator().Inject(ctx, traceCarrier)
headers := amqp.Table{}
for _, key := range traceCarrier.Keys() {
headers[key] = traceCarrier.Get(key)
}
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(),
Headers: headers,
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 ContextFromDelivery(ctx context.Context, delivery amqp.Delivery) context.Context {
carrier := propagation.MapCarrier{}
for key, value := range delivery.Headers {
if text, ok := value.(string); ok {
carrier.Set(key, text)
}
}
return otel.GetTextMapPropagator().Extract(ctx, carrier)
}
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"
"mtusi2026lab6/internal/adapter/redis"
"mtusi2026lab6/internal/application"
"mtusi2026lab6/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"
"mtusi2026lab6/internal/adapter/memory"
"mtusi2026lab6/internal/adapter/redis"
"mtusi2026lab6/internal/application"
"mtusi2026lab6/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 "mtusi2026lab6/internal/domain"
var (
ErrNotFound = domain.ErrNotFound
ErrConflict = domain.ErrConflict
)
+384
View File
@@ -0,0 +1,384 @@
package memory
import (
"context"
"fmt"
"sync"
"time"
"mtusi2026lab6/internal/application"
"mtusi2026lab6/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"
"mtusi2026lab6/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
}
+226
View File
@@ -0,0 +1,226 @@
package objectstore
import (
"bytes"
"context"
"fmt"
"io"
"net/url"
"strings"
"time"
"mtusi2026lab6/internal/application"
minio "github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/trace"
)
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 {
ctx, span := startObjectSpan(ctx, "put")
defer span.End()
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) {
ctx, span := startObjectSpan(ctx, "get")
defer span.End()
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) {
ctx, span := startObjectSpan(ctx, "list")
defer span.End()
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 {
ctx, span := startObjectSpan(ctx, "delete")
defer span.End()
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 {
ctx, span := startObjectSpan(ctx, "bucket_exists")
defer span.End()
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
}
func startObjectSpan(ctx context.Context, operation string) (context.Context, trace.Span) {
return otel.Tracer("mtusi2026lab6/s3").Start(
ctx,
"s3."+operation,
trace.WithSpanKind(trace.SpanKindClient),
trace.WithAttributes(
attribute.String("storage.system", "s3"),
attribute.String("storage.operation", operation),
),
)
}
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,906 @@
package postgres
import (
"context"
"errors"
"fmt"
"time"
"mtusi2026lab6/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,
COALESCE(traceparent, ''), COALESCE(tracestate, '')
`
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,
&job.TraceParent,
&job.TraceState,
)
}
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,
traceparent, tracestate
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)
`, job.JobID, job.AttachmentID, job.SchemaVersion, job.Type, job.PipelineVersion,
job.Attempt, job.MaxAttempts, job.Status, job.AvailableAt, job.CreatedAt, job.UpdatedAt,
job.TraceParent, job.TraceState)
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,
traceparent, tracestate
) VALUES ($1,$2,$3,$4,$5,$6,$7,'queued',$8,$9,$10,$11,$12)
`, job.JobID, attachmentID, job.SchemaVersion, job.Type, targetVersion,
job.Attempt, job.MaxAttempts, job.AvailableAt, job.CreatedAt, job.UpdatedAt,
job.TraceParent, job.TraceState)
}
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"
"mtusi2026lab6/internal/domain"
"mtusi2026lab6/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"
"mtusi2026lab6/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 "mtusi2026lab6/internal/application"
var _ application.Repository = (*PostgreSQLStore)(nil)
+8
View File
@@ -0,0 +1,8 @@
package postgres
import "mtusi2026lab6/internal/domain"
var (
ErrNotFound = domain.ErrNotFound
ErrConflict = domain.ErrConflict
)
+423
View File
@@ -0,0 +1,423 @@
package postgres
import (
"bytes"
"context"
"errors"
"fmt"
"time"
"mtusi2026lab6/internal/application"
"mtusi2026lab6/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
}
+31
View File
@@ -0,0 +1,31 @@
package postgres
import (
"context"
"fmt"
"time"
)
func (s *PostgreSQLStore) AttachmentQueueStats(
ctx context.Context,
now time.Time,
) (int64, float64, error) {
queryContext, cancel := s.withTimeout(ctx)
defer cancel()
var depth int64
var oldestAge float64
err := s.pool.QueryRow(queryContext, `
SELECT
COUNT(*),
COALESCE(EXTRACT(EPOCH FROM ($1::timestamptz - MIN(created_at))), 0)
FROM attachment_jobs
WHERE status = 'queued'
`, now).Scan(&depth, &oldestAge)
if err != nil {
return 0, 0, fmt.Errorf("read attachment queue stats: %w", err)
}
if oldestAge < 0 {
oldestAge = 0
}
return depth, oldestAge, nil
}
+108
View File
@@ -0,0 +1,108 @@
package postgres
import (
"context"
"errors"
"fmt"
"time"
"mtusi2026lab6/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"
"mtusi2026lab6/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"
"mtusi2026lab6/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"
"mtusi2026lab6/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
}
+182
View File
@@ -0,0 +1,182 @@
package application
import (
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"image"
_ "image/jpeg"
_ "image/png"
"io"
"os"
"mtusi2026lab6/internal/domain"
"github.com/google/uuid"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/propagation"
)
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)
}
traceCarrier := propagation.MapCarrier{}
otel.GetTextMapPropagator().Inject(ctx, traceCarrier)
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,
TraceParent: traceCarrier.Get("traceparent"),
TraceState: traceCarrier.Get("tracestate"),
}
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"
"mtusi2026lab6/internal/adapter/memory"
. "mtusi2026lab6/internal/application"
"mtusi2026lab6/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"
"mtusi2026lab6/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"
"mtusi2026lab6/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"
"mtusi2026lab6/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"
"mtusi2026lab6/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"
"mtusi2026lab6/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"
"mtusi2026lab6/internal/domain"
"mtusi2026lab6/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"
"mtusi2026lab6/internal/domain"
"mtusi2026lab6/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
}

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