ЛР 6 — БПИ2302 — Нурлыгаянова — на 3 #21

Closed
relationskat wants to merge 1 commits from relationskat/mtusi2026lab6:solution/bpi2302-nurlygayanova into main
164 changed files with 25947 additions and 29 deletions
+8 -2
View File
@@ -7,7 +7,7 @@ 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
SESSION_STORE=valkey
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
@@ -19,7 +19,7 @@ S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
BROKER_URL_FILE=/run/secrets/broker_url
WORKER_CONCURRENCY=2
WORKER_CONCURRENCY=1
JOB_MAX_ATTEMPTS=5
JOB_TIMEOUT_SECONDS=60
STAGING_RETENTION_SECONDS=86400
@@ -28,3 +28,9 @@ OTEL_SERVICE_NAME=messenger-api
OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab
API_PUBLISH_PORT=18086
POSTGRES_PORT=25436
VALKEY_PORT=26386
HISTORY_CACHE=off
MAX_CONCURRENT_UPLOADS=4
+119
View File
@@ -0,0 +1,119 @@
# syntax=docker/dockerfile:1.7
# Многоэтапная сборка: компилятор и исходники остаются в промежуточных этапах, а в итоговые
# образы попадают только готовые файлы. Какой этап собрать, задаёт target в compose.yaml.
# Версии образов закреплены, чтобы сборка повторялась.
# Этап 1: компиляция всех программ проекта.
FROM golang:1.26.10-alpine3.24 AS builder
WORKDIR /src
# Сначала только списки зависимостей: при изменении кода их загрузка берётся из кэша Docker.
COPY app/go.mod app/go.sum ./
RUN go mod download
# Затем весь код. Лишнее отсекает .dockerignore.
COPY app/ ./
# Основной сервер API. CGO_ENABLED=0 — статический файл без зависимостей от системных библиотек,
# -s -w убирают отладочные данные и уменьшают размер, -trimpath убирает локальные пути из файла.
RUN CGO_ENABLED=0 GOOS=linux go build \
-ldflags="-s -w" \
-trimpath \
-o /out/messenger ./cmd/messenger
# Генератор нагрузки для проверок под нагрузкой.
RUN CGO_ENABLED=0 GOOS=linux go build \
-ldflags="-s -w" \
-trimpath \
-o /out/loadgen ./cmd/loadgen
# Одноразовая подготовка S3-bucket.
RUN CGO_ENABLED=0 GOOS=linux go build \
-ldflags="-s -w" \
-trimpath \
-o /out/s3init ./cmd/s3init
# Очиститель объектов без метаданных и проверка прав S3 мимо API.
RUN CGO_ENABLED=0 GOOS=linux go build \
-ldflags="-s -w" \
-trimpath \
-o /out/janitor ./cmd/janitor
RUN CGO_ENABLED=0 GOOS=linux go build \
-ldflags="-s -w" \
-trimpath \
-o /out/s3check ./cmd/s3check
# Этап 2: сборка инструмента миграций goose. Версия закреплена, драйверы ненужных БД
# исключены тегами: нужен только PostgreSQL.
FROM golang:1.26.10-alpine3.24 AS goose-builder
RUN CGO_ENABLED=0 go install -trimpath -ldflags="-s -w" \
-tags='no_clickhouse no_libsql no_mssql no_mysql no_sqlite3 no_vertica no_ydb' \
github.com/pressly/goose/v3/cmd/goose@v3.26.0
# Образ одноразового сервиса migrate: только goose и файлы миграций.
# Адрес БД читается из секрета при запуске, поэтому в образ не попадает.
# exec заменяет оболочку на goose, и тот сам получает сигналы остановки.
FROM alpine:3.24.3 AS migrate
COPY --from=goose-builder /go/bin/goose /usr/local/bin/goose
COPY migrations /migrations
ENTRYPOINT ["/bin/sh", "-c", "exec goose -dir /migrations postgres \"$(cat \"$DATABASE_URL_FILE\")\" up"]
# Образ генератора нагрузки (профиль bench). Работает не от root.
FROM alpine:3.24.3 AS loadgen
COPY --from=builder /out/loadgen /usr/local/bin/loadgen
USER nobody
ENTRYPOINT ["/usr/local/bin/loadgen"]
# Образ одноразового сервиса s3-init. Credentials читаются из секретов при запуске. Работает не от root.
FROM alpine:3.24.3 AS s3init
COPY --from=builder /out/s3init /usr/local/bin/s3init
USER nobody
ENTRYPOINT ["/usr/local/bin/s3init"]
# Образ очистителя. Работает не от root.
FROM alpine:3.24.3 AS janitor
COPY --from=builder /out/janitor /usr/local/bin/janitor
USER nobody
ENTRYPOINT ["/usr/local/bin/janitor"]
# Образ проверки прав S3 (профиль tools). Работает не от root.
FROM alpine:3.24.3 AS s3check
COPY --from=builder /out/s3check /usr/local/bin/s3check
USER nobody
ENTRYPOINT ["/usr/local/bin/s3check"]
# Итоговый образ API. Это последний этап, поэтому он собирается, когда target не указан.
# В нём нет ни компилятора, ни goose, ни файлов миграций: реплики не могут запускать их при старте.
FROM alpine:3.24.3
# Метка версии сборки: видна в образе и в окружении. По ней rolling update показывает смену версии.
ARG APP_BUILD=dev
ENV APP_VERSION=$APP_BUILD
LABEL org.opencontainers.image.version=$APP_BUILD
# Корневые сертификаты и отдельный пользователь без прав: процесс работает не от root.
RUN apk add --no-cache ca-certificates && \
addgroup -S app && \
adduser -S -G app -H app
WORKDIR /app
# Из этапа сборки берётся только готовый файл.
COPY --from=builder /out/messenger /app/messenger
# Все следующие команды и сам сервер выполняются от этого пользователя.
USER app
# Документация порта. Наружу он не публикуется: снаружи доступен только LB.
EXPOSE 8080
# Docker останавливает контейнер этим сигналом: приложение выводит себя из балансировки
# и завершает открытые запросы.
STOPSIGNAL SIGTERM
# Проверка готовности для Docker (статус healthy). Трафик направляет не она, а собственные
# проверки LB. wget входит в alpine, отдельно его ставить не нужно.
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD wget --quiet --spider "http://127.0.0.1:${APP_PORT:-8080}/health/ready" || exit 1
ENTRYPOINT ["/app/messenger"]
+1 -1
View File
@@ -1,5 +1,5 @@
PYTHON ?= python3
BASE_URL ?= http://localhost:8080
BASE_URL ?= http://localhost:18086
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
+29
View File
@@ -0,0 +1,29 @@
## Лабораторная 6 — на 3
Автор / группа: Нурлыгаянова Екатерина, БПИ2302.
Целевая оценка: 3. Трек 5 не заявлен.
Из собственной lab5 перенесены API, асинхронная обработка изображений, миграции,
PostgreSQL, Valkey, приватный SeaweedFS и две API-реплики за HAProxy.
Добавлены OTLP SDK API/worker, Collector, Prometheus/Loki/Tempo с томами,
Grafana provisioning и импортируемый dashboard. Запрос API и доставка job
имеют реальные spans и структурные логи с trace_id/span_id.
Запуск: `cp .env.example .env`, `sh scripts/init-secrets.sh`,
`docker compose up -d --build --wait`. API: http://localhost:18086,
Grafana: http://localhost:3000/d/messenger-lab6.
Инструкция, версии, ограничения и доказательства: [REPORT.md](REPORT.md).
Проверки: `make check`, `make test`, `go test ./...` в Go-контейнере,
`python3 student-tests/observability.py`, `python3 student-tests/incidents.py`.
Выводы и исходные наблюдения — в `evidence/`.
Ограничения: один Docker-host; SLO/alerts и исследования уровней 4/5 не заявлены.
Использована помощь Codex; источники и библиотеки перечислены в отчёте.
- [x] Обязательный минимум сохранён с объявленными переходами.
- [x] Контракт и публичные тесты не ослаблены.
- [x] make check и make test выполнены; приложен реальный вывод.
- [x] Отказы worker и S3 воспроизведены с восстановлением.
- [x] Секреты и приватные ключи находятся вне Git.
- [x] README задания сохранён, REPORT.md содержит инструкцию решения.
+130 -22
View File
@@ -1,37 +1,145 @@
# Отчёт — лабораторная 6
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Целевая оценка: **3**.
- Автор/группа: Нурлыгаянова Екатерина, БПИ2302.
- Commit/PR: публикация не выполнялась.
- Основа: собственная реализация из `../mtusi2026lab5` (исходники Go API, Python worker, миграции, инфраструктура). Контракт и публичные tests взяты из lab6 без изменений.
- Помощь ИИ: Codex — перенос, SDK-инструментация, конфигурации, dashboard, проверки и отчёт. Использованы библиотеки из `app/go.mod` и `worker/requirements.txt`.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Engine с Compose v2, Python 3.9+, make. Go локально не нужен.
## Архитектура и решения
```sh
cp .env.example .env
sh scripts/init-secrets.sh
docker compose config --quiet
docker compose up -d --build --wait
make check
make test
python3 student-tests/observability.py
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load.json
python3 student-tests/incidents.py
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab5, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Внешние точки: API http://localhost:18086, Grafana http://localhost:3000,
Prometheus http://localhost:19091, Loki http://localhost:3100, Tempo http://localhost:3200.
Все опубликованные порты привязаны к loopback. В Grafana разрешён локальный anonymous Viewer.
Dashboard уже находится в Dashboards → Lab6 → Messenger — Lab 6.
## Доказательства критериев
Подготовка: `init-secrets.sh` генерирует новые локальные ключи и пароли (вне Git).
Compose запускает PostgreSQL, применяет все миграции через goose 3.26.0,
готовит приватный S3 bucket, затем запускает две API-реплики, dispatcher и worker.
Не переносить `.env`, secrets и volumes из пятой: lab6 использует свой проект `mtusi-lab6`.
Имена переменных `.env.example` используются непосредственно API/worker либо Compose;
SESSION_STORE=valkey, HISTORY_CACHE=off. Worker принудительно задаёт свой service.name в SDK.
OTLP endpoint используется обоими приложениями; протокол HTTP/protobuf закреплён экспортёрами.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
Остановка с сохранением истории: `docker compose down`.
Повторный запуск: `docker compose up -d --wait`.
**Намеренное удаление всех учебных данных:** `docker compose down -v`.
Пароли в secrets нельзя менять при сохранённом PostgreSQL volume.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Архитектура
## Эксперименты и отказы
HAProxy → две Go API → PostgreSQL (источник истины), Valkey (сессии), SeaweedFS S3 (байты).
API сохраняет attachment и durable job intent в одной транзакции PostgreSQL.
Dispatcher публикует intent в Valkey Streams; worker читает job, делает thumbnail,
пишет результат в S3 и БД, затем подтверждает доставку. Повторная доставка защищена
advisory lock и терминальным состоянием. Сохранены идемпотентность сообщений и доступ участников чата.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
API и worker → OTLP HTTP → Collector → Prometheus / Loki / Tempo → Grafana.
Prometheus хранит метрики, Loki — структурные логи, Tempo — трассы.
Collector принимает, ограничивает память и группирует данные; Grafana визуализирует их.
Каждый backend и Grafana имеют отдельный persistent volume; retention сигналов 72 часа.
Grafana provisioning, JSON dashboard и backend configs включены в Git.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Версии: Go 1.26.10, Python 3.13.9, Go OTel SDK 1.38.0 (logs 0.14.0), Python OTel 1.38.0,
Collector contrib 0.137.0, Prometheus 3.5.0, Loki 3.5.5, Tempo 2.8.2, Grafana 12.2.0,
PostgreSQL 17.6, Valkey 8.1.3, SeaweedFS 4.00, HAProxy 3.2.9.
Образы закреплены в Dockerfile/compose.yaml; списки прямых зависимостей закреплены.
## Ограничения и следующие шаги
## Сигналы и поиск причины
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Полное соответствие имён и единиц — `infra/otel/README.md`.
| Контракт | Реализация |
| --- | --- |
| HTTP counter | `api_requests_total{method,route,status_class}` |
| HTTP histogram | `api_duration_seconds_bucket` |
| Job counter | `worker_jobs_total{job_type,outcome}` |
| Job histogram | `worker_duration_seconds_bucket` |
| Resource | service.name, service.version, service.instance.id, deployment.environment.name=lab |
| Structured logs | OTLP timestamp/severity/resource, event, trace_id/span_id; API добавляет request_id |
| Traces | API SERVER span вокруг настоящего handler; worker CONSUMER span вокруг настоящей доставки |
API возвращает `X-Trace-Id` и `X-Request-Id`. В Loki:
`{service_name="messenger-api"} | trace_id="ID"`.
В Tempo вставить этот trace ID. Для worker:
`{service_name="messenger-worker"} | event="job.success"`, затем открыть его trace_id в Tempo.
Контекст API → broker → worker передаётся в реализации; для оценки 3 достаточно реальных API и worker traces и связанных логов.
Dashboard показывает RPS, error ratio (5xx / все бизнес-запросы, без health), API p95,
job counters по outcome, worker p95, логи и поиск traces.
Процентили: `histogram_quantile(0.95, sum by (le) (rate(..._bucket[1m])))`.
Latency — секунды, RPS/jobs rate — 1/с, ошибки — доля 0..1. Health исключён из API панелей.
Job counter считает попытки доставки; retry/error — ошибки попытки, failed — терминальная ошибка,
skipped — повторная/занятая доставка. Это не число уникальных файлов.
Labels метрик используют шаблоны маршрутов, а не UUID/raw URL; бизнес-идентификаторы и request_id
не labels. OTLP события экспортируются по явному списку технических полей. Тела сообщений,
картинки, HTTP headers, пароли, session tokens, signed URLs и exception messages не экспортируются.
Sampling — все spans, очереди SDK ограничены 1024 записями; Collector ограничен 192 MiB
и контейнером 256 MiB, очереди экспортёров — 256 batches, retry не дольше 30 с.
Долгий отказ backend может привести к потере telemetry; это не durable event journal.
## Доказательства
Результаты проверок и наблюдений сохранены в `evidence/`.
| Проверка | Результат | Доказательство |
| --- | --- | --- |
| `make check` | PASS | `evidence/check.txt` |
| `make test` с включённой телеметрией | PASS | `evidence/smoke.txt` |
| Go `go test ./...` в контейнере | PASS | `evidence/go-tests.txt` |
| API trace + связанный лог, worker trace + лог, четыре SDK-метрики | PASS | `evidence/observability.txt`, `evidence/telemetry.json` |
| Grafana provisioning | Dashboard загружен, 8 панелей | `evidence/grafana.json` |
| Остановка worker | queued сохраняется, после запуска ready; 5,931 с | `evidence/incidents.json` |
| Отказ S3 | В trace ошибка s3.get_object / ConnectionClosedError, job retry; контрольный upload после восстановления ready; 32,063 с | `evidence/incidents.json` |
| Перезапуск API и хранилищ | Сообщения, файл и прежняя сессия сохранены | `evidence/persistence.txt`, `evidence/persistence-containers.txt` |
Нагрузка: closed-loop POST messages, 30 секунд, concurrency=4, 44 206 успешных
запросов, 0 ошибок, 1473,386 RPS; p50=2,508 мс, p95=3,885 мс, p99=6,048 мс.
Исходный замер: `evidence/load.json`. Это учебный замер, не предел производительности;
перцентили относятся к успешным запросам, учитывают расходы клиента.
Docker Desktop: 12 vCPU, 8 216 776 704 байт RAM; ресурсы разделяются с другими сервисами.
Лимиты: API 1 CPU / 1 GiB на реплику, worker 1 CPU / 1 GiB,
PostgreSQL 2 CPU / 1 GiB, Collector 0,5 CPU / 256 MiB; остальные — в Compose.
Диагностика первого отказа: API продолжает принимать upload (202), статус остаётся queued,
обработка возобновляется после старта worker. Диагностика второго: worker consumer span
имеет outcome=retry, дочерний S3 client span содержит error.type=ConnectionClosedError;
это указывает на зависимость S3. Тела данных и credentials в сохранённых наблюдениях отсутствуют.
## Ограничения
Один Docker-host, одна БД, один broker/S3/LB — единственные точки отказа.
Уровни 4 и 5 не заявлены: SLO/alerts и исследовательского трека нет.
Telemetry хранится локально, не предназначена для публичного доступа.
Внешняя публикация, commit и PR не выполнялись. На защите нужно уметь объяснить конфиги
и повторить запрос/задание с поиском соответствующих лога и трассы.
Источники: [OTel Go exporters](https://opentelemetry.io/docs/languages/go/exporters/),
[Loki native OTLP](https://grafana.com/docs/loki/latest/send-data/otel/),
[Collector configuration](https://opentelemetry.io/docs/collector/configuration/).
## Дополнительные короткие проверки крайних случаев
`python3 student-tests/corners.py` — PASS, 24 сценария на запущенном стенде.
Проверены неверные limit/cursor/UUID/JSON/Bearer, границы текста 4000/4001,
повреждённое изображение, MIME, filename с обходом пути, upload >10 MiB,
изоляция чужих вложений, дубли attachment IDs, cursor другого чата, неизвестный variant
и восемь одновременных повторов одного Idempotency-Key через обе API-реплики.
Подтверждено: повторы возвращают один message ID; другой body даёт 409.
Вывод: `evidence/corners.txt`. Повторный публичный smoke также PASS (`evidence/smoke.txt`).
+104
View File
@@ -0,0 +1,104 @@
// janitor — очиститель объектов S3 без метаданных. Отдельный сервис со своими credentials S3: API
// не имеет права на листинг, а очиститель не имеет права читать содержимое файлов.
//
// Постоянная работа: janitor. Один проход: janitor -once. Только отчёт: janitor -once -dry-run.
// Настройки: JANITOR_GRACE_SECONDS, JANITOR_INTERVAL_SECONDS, JANITOR_MAX_DELETES, JANITOR_DRY_RUN.
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log/slog"
"os"
"os/signal"
"syscall"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/janitor"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/logging"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store/db"
)
// passTimeout ограничивает один проход: зависший S3 не должен останавливать очиститель навсегда.
const passTimeout = 10 * time.Minute
func main() {
once := flag.Bool("once", false, "выполнить один проход и завершиться")
dryRun := flag.Bool("dry-run", false, "только отчёт, ничего не удалять")
flag.Parse()
if err := run(*once, *dryRun); err != nil {
fmt.Fprintln(os.Stderr, "janitor:", err)
os.Exit(1)
}
}
func run(once, dryRun bool) error {
cfg, err := config.Load()
if err != nil {
return err
}
logger, err := logging.New(cfg.Logger.Level, cfg.Env, cfg.Version)
if err != nil {
return err
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
pool, err := db.Connect(ctx, cfg.Database)
if err != nil {
return err
}
storage := db.New(pool, time.Duration(cfg.Database.QueryTimeoutMs)*time.Millisecond)
defer storage.Close()
objects, err := objectstore.NewS3(cfg.S3)
if err != nil {
return err
}
opts := janitor.Options{
Prefix: service.ObjectKeyPrefix,
Grace: time.Duration(cfg.Janitor.GraceSeconds) * time.Second,
MaxDeletes: cfg.Janitor.MaxDeletes,
DryRun: cfg.Janitor.DryRun || dryRun,
Now: time.Now,
Logger: logger,
}
pass := func() error {
passCtx, cancel := context.WithTimeout(ctx, passTimeout)
defer cancel()
report, err := janitor.Run(passCtx, objects, storage.Attachments, opts)
logger.Info("janitor pass", slog.Any("report", report), slog.Duration("elapsed", report.Elapsed), slog.Any("err", err))
if once {
// Машиночитаемый итог для проверок: stdout содержит и этот объект, и строки журнала.
if line, jsonErr := json.Marshal(struct {
Report janitor.Report `json:"janitor_report"`
}{report}); jsonErr == nil {
fmt.Println(string(line))
}
}
return err
}
if once {
return pass()
}
// Первый проход сразу: после простоя очистителя мусор не ждёт ещё один интервал.
ticker := time.NewTicker(time.Duration(cfg.Janitor.IntervalSeconds) * time.Second)
defer ticker.Stop()
for {
// Ошибка прохода не фатальна: S3 или БД вернутся, следующий проход повторит работу.
if err := pass(); err != nil {
logger.Warn("janitor pass failed", slog.Any("err", err))
}
select {
case <-ctx.Done():
return nil
case <-ticker.C:
}
}
}
+601
View File
@@ -0,0 +1,601 @@
// loadgen — closed-loop генератор нагрузки для экспериментов с репликами.
//
// Смесь чтения истории и записи сообщений. Неподтверждённая запись повторяется с тем же
// Idempotency-Key, как у настоящего клиента. После прогона вся история сверяется с
// подтверждёнными сообщениями. Closed-loop занижает задержки при перегрузке (coordinated
// omission), поэтому результат показывает пропускную способность, а не задержку при заданной
// интенсивности. Токены и пароли не печатает.
//
// Запуск из корня проекта при поднятом стенде:
//
// docker compose --env-file .env --profile bench run --rm -T loadgen -duration 20s -concurrency 16
//
// Этапы: подготовка данных, прогрев, замер, сверка истории, запись результата.
// Код выхода ненулевой, если сверка нашла потери или дубли либо не смогла прочитать историю.
package main
import (
"bytes"
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"flag"
"fmt"
"io"
mathrand "math/rand/v2"
"net/http"
"net/url"
"os"
"slices"
"strconv"
"sync"
"time"
)
// options — параметры запуска из флагов командной строки.
type options struct {
baseURL string
duration time.Duration
warmup time.Duration
concurrency int
writeShare float64
chats int
seed int
timeout time.Duration
label string
out string
}
// actor — один клиент API: токен его сессии и его чат. Токен хранится только в памяти.
type actor struct {
token string
chatID string
}
// confirmed — запись, на которую сервер ответил 201. После замера она обязана быть в истории:
// chat — индекс чата, id — ID сообщения, text — уникальный текст для поиска дублей.
type confirmed struct {
chat int
id string
text string
}
// workerStats заполняется одной горутиной, поэтому без блокировок.
// Поля: задержки успешных чтений и записей; ошибки по видам (код ответа или net);
// записи, подтверждённые после повтора; запросы по репликам; успехи и ошибки по секундам;
// время каждой ошибки; подтверждённые записи.
type workerStats struct {
reads, writes []time.Duration
errors map[string]int
retried int
instances map[string]int
secOK, secErr map[int]int
errTimes []time.Duration
confirmed []confirmed
}
// main разбирает флаги и запускает прогон. Значения по умолчанию рассчитаны на запуск в сети Docker.
func main() {
var o options
flag.StringVar(&o.baseURL, "base-url", "http://lb:8080", "адрес балансировщика")
flag.DurationVar(&o.duration, "duration", 30*time.Second, "длительность замера")
flag.DurationVar(&o.warmup, "warmup", 5*time.Second, "прогрев, не входит в замер")
flag.IntVar(&o.concurrency, "concurrency", 16, "число клиентов closed-loop")
flag.Float64Var(&o.writeShare, "write-share", 0.2, "доля записей")
flag.IntVar(&o.chats, "chats", 8, "число пар пользователь+чат")
flag.IntVar(&o.seed, "seed", 100, "начальных сообщений на чат")
flag.DurationVar(&o.timeout, "timeout", 5*time.Second, "таймаут запроса")
flag.StringVar(&o.label, "label", "", "метка прогона")
flag.StringVar(&o.out, "out", "", "файл для JSON-результата")
flag.Parse()
if err := run(o); err != nil {
fmt.Fprintln(os.Stderr, "loadgen:", err)
os.Exit(1)
}
}
// run выполняет прогон целиком и возвращает ошибку, если проверка истории не пройдена.
func run(o options) error {
// Один общий клиент на всех. Запас простаивающих соединений нужен, чтобы клиенты повторно
// использовали их: иначе замер включал бы постоянную установку новых соединений.
client := &http.Client{
Timeout: o.timeout,
Transport: &http.Transport{
MaxIdleConns: o.concurrency * 2,
MaxIdleConnsPerHost: o.concurrency * 2,
IdleConnTimeout: 30 * time.Second,
},
}
// Подготовка до начала отсчёта: в замер не входит.
actors, err := setup(client, o)
if err != nil {
return fmt.Errorf("setup: %w", err)
}
// Границы замера. Клиенты работают и в прогреве, но запросы до measureFrom не учитываются.
start := time.Now()
measureFrom := start.Add(o.warmup)
end := measureFrom.Add(o.duration)
// Скрипты отказов ждут эту строку, чтобы привязать действия ко времени замера.
go func() {
time.Sleep(o.warmup)
fmt.Printf("measure_start unix=%d\n", time.Now().Unix())
}()
// У каждого клиента своя статистика и своя горутина. Общие данные появляются только после wg.Wait.
stats := make([]*workerStats, o.concurrency)
var wg sync.WaitGroup
for i := range o.concurrency {
stats[i] = newWorkerStats()
wg.Add(1)
go func() {
defer wg.Done()
work(client, o, i, actors, measureFrom, end, stats[i])
}()
}
wg.Wait()
// Сверка идёт уже после нагрузки, поэтому на RPS она не влияет.
res := summarize(o, stats)
res.Verify = verify(client, o, actors, stats)
if err := writeResult(o, res); err != nil {
return err
}
// Результат записан и при неудаче: так можно разобрать, что именно пошло не так.
if res.Verify.Error != "" || res.Verify.Lost > 0 || res.Verify.DuplicateIDs > 0 || res.Verify.DuplicateTexts > 0 {
return fmt.Errorf("проверка истории не пройдена: %+v", res.Verify)
}
return nil
}
// newWorkerStats создаёт пустую статистику клиента.
func newWorkerStats() *workerStats {
return &workerStats{
errors: map[string]int{},
instances: map[string]int{},
secOK: map[int]int{},
secErr: map[int]int{},
}
}
// work — цикл одного клиента до конца замера (closed-loop): следующий запрос уходит только
// после ответа на предыдущий. Клиенты равномерно распределены по чатам.
func work(client *http.Client, o options, worker int, actors []actor, from, end time.Time, st *workerStats) {
chat := worker % len(actors)
a := actors[chat]
path := "/api/v1/chats/" + a.chatID + "/messages"
// Свой генератор у каждого клиента: общий потребовал бы блокировки.
rng := mathrand.New(mathrand.NewPCG(uint64(worker), uint64(time.Now().UnixNano())))
// observe учитывает результат одного запроса и возвращает true, если он успешен. В замер
// входит только запрос, начатый после прогрева и завершившийся до конца замера. lat — куда
// записать задержку успешного запроса, want — ожидаемый код ответа.
observe := func(began time.Time, status int, instance string, err error, want int, lat *[]time.Duration) bool {
now := time.Now()
measured := !began.Before(from) && now.Before(end)
// Номер секунды замера: из него строится посекундная шкала.
sec := int(now.Sub(from) / time.Second)
if err == nil && status == want {
if measured {
*lat = append(*lat, now.Sub(began))
st.instances[instance]++
st.secOK[sec]++
}
return true
}
if measured {
// net — ответа не было вообще (обрыв, таймаут), иначе вид ошибки — код ответа.
kind := "net"
if err == nil {
kind = strconv.Itoa(status)
}
st.errors[kind]++
st.secErr[sec]++
st.errTimes = append(st.errTimes, now.Sub(from))
}
return false
}
for seq := 0; time.Now().Before(end); seq++ {
// Чтение первой страницы истории. После ошибки короткая пауза, чтобы не долбить сервер в цикле.
if rng.Float64() >= o.writeShare {
began := time.Now()
status, inst, _, err := do(client, o, http.MethodGet, path+"?limit=50", a.token, "", nil)
if !observe(began, status, inst, err, http.StatusOK, &st.reads) {
time.Sleep(50 * time.Millisecond)
}
continue
}
// Запись: новый ключ идемпотентности и уникальный текст, по которому видны дубли.
key := randomHex(16)
text := fmt.Sprintf("w-%d-%d-%s", worker, seq, key[:8])
// Неопределённый результат повторяется с исходным ключом и телом.
// Цикл повторов. При обрыве клиент не знает, записал ли сервер сообщение, поэтому повторяет
// с теми же ключом и текстом: сервер должен вернуть то же сообщение, а не создать новое.
for attempt := 0; time.Now().Before(end); attempt++ {
began := time.Now()
status, inst, body, err := do(client, o, http.MethodPost, path, a.token, key, map[string]string{"text": text})
if observe(began, status, inst, err, http.StatusCreated, &st.writes) {
var m struct {
ID string `json:"id"`
}
if json.Unmarshal(body, &m) == nil {
st.confirmed = append(st.confirmed, confirmed{chat: chat, id: m.ID, text: text})
}
// Запись подтвердилась только с повтора: это видно в результате.
if attempt > 0 {
st.retried++
}
break
}
time.Sleep(100 * time.Millisecond)
}
}
}
// do выполняет один HTTP-запрос с таймаутом и возвращает код, реплику из X-Instance-Id, тело
// и ошибку сети. payload кодируется в JSON; пустые token и key не добавляют заголовки.
func do(client *http.Client, o options, method, path, token, key string, payload any) (int, string, []byte, error) {
var body io.Reader
if payload != nil {
b, err := json.Marshal(payload)
if err != nil {
return 0, "", nil, err
}
body = bytes.NewReader(b)
}
ctx, cancel := context.WithTimeout(context.Background(), o.timeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, method, o.baseURL+path, body)
if err != nil {
return 0, "", nil, err
}
if payload != nil {
req.Header.Set("Content-Type", "application/json")
}
if token != "" {
req.Header.Set("Authorization", "Bearer "+token)
}
if key != "" {
req.Header.Set("Idempotency-Key", key)
}
resp, err := client.Do(req)
if err != nil {
return 0, "", nil, err
}
defer resp.Body.Close()
// Тело читается полностью: иначе соединение нельзя использовать повторно.
data, err := io.ReadAll(resp.Body)
if err != nil {
return 0, "", nil, err
}
return resp.StatusCode, resp.Header.Get("X-Instance-Id"), data, nil
}
// setup параллельно создаёт пользователей и чаты для всех участников нагрузки.
func setup(client *http.Client, o options) ([]actor, error) {
actors := make([]actor, o.chats)
errs := make([]error, o.chats)
var wg sync.WaitGroup
for i := range o.chats {
wg.Add(1)
go func() {
defer wg.Done()
actors[i], errs[i] = setupActor(client, o)
}()
}
wg.Wait()
for _, err := range errs {
if err != nil {
return nil, err
}
}
return actors, nil
}
// setupActor создаёт одного участника: пользователь, вход, чат и начальные сообщения.
// Имена и пароли случайные и нигде не печатаются.
func setupActor(client *http.Client, o options) (actor, error) {
username, password := "lg_"+randomHex(8), "T3st-"+randomHex(16)
status, _, body, err := do(client, o, http.MethodPost, "/api/v1/users", "", "",
map[string]string{"username": username, "display_name": "Load", "password": password})
if err != nil || status != http.StatusCreated {
return actor{}, fmt.Errorf("create user: status %d: %v", status, err)
}
var user struct {
ID string `json:"id"`
}
if err := json.Unmarshal(body, &user); err != nil {
return actor{}, err
}
// Вход выполняется через Basic: пользователь получает токен сессии.
req, err := http.NewRequest(http.MethodPost, o.baseURL+"/api/v1/auth/sessions", nil)
if err != nil {
return actor{}, err
}
req.SetBasicAuth(username, password)
resp, err := client.Do(req)
if err != nil {
return actor{}, fmt.Errorf("login: %w", err)
}
defer resp.Body.Close()
var session struct {
Token string `json:"token"`
}
if resp.StatusCode != http.StatusCreated {
return actor{}, fmt.Errorf("login: status %d", resp.StatusCode)
}
if err := json.NewDecoder(resp.Body).Decode(&session); err != nil {
return actor{}, err
}
status, _, body, err = do(client, o, http.MethodPost, "/api/v1/chats", session.Token, "",
map[string]any{"title": "Load", "member_ids": []string{user.ID}})
if err != nil || status != http.StatusCreated {
return actor{}, fmt.Errorf("create chat: status %d: %v", status, err)
}
var chat struct {
ID string `json:"id"`
}
if err := json.Unmarshal(body, &chat); err != nil {
return actor{}, err
}
// Начальные сообщения, чтобы чтение первой страницы возвращало полноценный ответ.
for i := range o.seed {
status, _, _, err := do(client, o, http.MethodPost, "/api/v1/chats/"+chat.ID+"/messages", session.Token,
randomHex(16), map[string]string{"text": fmt.Sprintf("seed-%d", i)})
if err != nil || status != http.StatusCreated {
return actor{}, fmt.Errorf("seed: status %d: %v", status, err)
}
}
return actor{token: session.Token, chatID: chat.ID}, nil
}
// verifyResult — итог сверки истории с подтверждёнными записями.
type verifyResult struct {
Confirmed int `json:"confirmed"`
Lost int `json:"lost"`
DuplicateIDs int `json:"duplicate_ids"`
DuplicateTexts int `json:"duplicate_texts"`
Error string `json:"error,omitempty"`
}
// verify читает всю историю каждого чата и сверяет её с подтверждёнными записями.
// Потеря — подтверждённого ID нет в истории. Дубль — ID или текст встретился дважды.
func verify(client *http.Client, o options, actors []actor, stats []*workerStats) verifyResult {
var res verifyResult
// Какие ID должны быть в каждом чате.
wanted := make([]map[string]bool, len(actors))
for i := range wanted {
wanted[i] = map[string]bool{}
}
for _, st := range stats {
for _, c := range st.confirmed {
wanted[c.chat][c.id] = true
res.Confirmed++
}
}
// История читается постранично по курсору, с запасом на временные ошибки.
for chat, a := range actors {
ids, texts := map[string]bool{}, map[string]bool{}
cursor := ""
for {
q := "?limit=100"
if cursor != "" {
q += "&cursor=" + url.QueryEscape(cursor)
}
status, _, body, err := getWithRetry(client, o, "/api/v1/chats/"+a.chatID+"/messages"+q, a.token)
if err != nil || status != http.StatusOK {
res.Error = fmt.Sprintf("read history: status %d: %v", status, err)
return res
}
var page struct {
Items []struct {
ID string `json:"id"`
Text string `json:"text"`
} `json:"items"`
NextCursor *string `json:"next_cursor"`
}
if err := json.Unmarshal(body, &page); err != nil {
res.Error = "decode history: " + err.Error()
return res
}
for _, m := range page.Items {
if ids[m.ID] {
res.DuplicateIDs++
}
ids[m.ID] = true
if texts[m.Text] {
res.DuplicateTexts++
}
texts[m.Text] = true
}
if page.NextCursor == nil {
break
}
cursor = *page.NextCursor
}
// Всё, что было подтверждено, должно найтись.
for id := range wanted[chat] {
if !ids[id] {
res.Lost++
}
}
}
return res
}
// getWithRetry повторяет чтение до 5 раз: сразу после отказа реплики сверка не должна падать
// из-за временной ошибки.
func getWithRetry(client *http.Client, o options, path, token string) (int, string, []byte, error) {
var (
status int
inst string
body []byte
err error
)
for range 5 {
status, inst, body, err = do(client, o, http.MethodGet, path, token, "", nil)
if err == nil && status == http.StatusOK {
break
}
time.Sleep(500 * time.Millisecond)
}
return status, inst, body, err
}
// latency — задержки успешных запросов одного вида, в миллисекундах.
type latency struct {
Count int `json:"count"`
P50 float64 `json:"p50_ms"`
P95 float64 `json:"p95_ms"`
P99 float64 `json:"p99_ms"`
}
// incident — эпизод ошибок: начало, длительность и количество.
type incident struct {
StartS float64 `json:"start_s"`
DurationS float64 `json:"duration_s"`
Errors int `json:"errors"`
}
// second — одна секунда шкалы: успехи и ошибки.
type second struct {
T int `json:"t"`
OK int `json:"ok"`
Err int `json:"err"`
}
// result — итог прогона. Он записывается в JSON и разбирается скриптами сводок.
type result struct {
Label string `json:"label"`
Concurrency int `json:"concurrency"`
WriteShare float64 `json:"write_share"`
Chats int `json:"chats"`
Seed int `json:"seed_per_chat"`
DurationS float64 `json:"duration_s"`
WarmupS float64 `json:"warmup_s"`
RPS float64 `json:"successful_rps"`
ReadRPS float64 `json:"read_rps"`
WriteRPS float64 `json:"write_rps"`
ErrorShare float64 `json:"error_share"`
Errors map[string]int `json:"errors"`
RetriedWrites int `json:"writes_confirmed_after_retry"`
Read latency `json:"read"`
Write latency `json:"write"`
Instances map[string]int `json:"requests_per_instance"`
Incidents []incident `json:"error_incidents"`
SecondsNoOK int `json:"seconds_without_success"`
Verify verifyResult `json:"verify"`
Timeline []second `json:"timeline,omitempty"`
}
// summarize объединяет статистику всех клиентов и считает показатели замера.
func summarize(o options, stats []*workerStats) result {
res := result{
Label: o.label, Concurrency: o.concurrency, WriteShare: o.writeShare, Chats: o.chats, Seed: o.seed,
DurationS: o.duration.Seconds(), WarmupS: o.warmup.Seconds(),
Errors: map[string]int{}, Instances: map[string]int{},
}
var reads, writes, errTimes []time.Duration
secOK, secErr := map[int]int{}, map[int]int{}
for _, st := range stats {
reads = append(reads, st.reads...)
writes = append(writes, st.writes...)
errTimes = append(errTimes, st.errTimes...)
res.RetriedWrites += st.retried
for k, v := range st.errors {
res.Errors[k] += v
}
for k, v := range st.instances {
res.Instances[k] += v
}
for k, v := range st.secOK {
secOK[k] += v
}
for k, v := range st.secErr {
secErr[k] += v
}
}
res.Read, res.Write = percentiles(reads), percentiles(writes)
secs := o.duration.Seconds()
// RPS учитывает только успешные запросы.
res.ReadRPS = float64(len(reads)) / secs
res.WriteRPS = float64(len(writes)) / secs
res.RPS = res.ReadRPS + res.WriteRPS
if total := len(reads) + len(writes) + len(errTimes); total > 0 {
res.ErrorShare = float64(len(errTimes)) / float64(total)
}
res.Incidents = incidents(errTimes, time.Second)
// Шкала за все секунды, включая пустые: секунда без успехов — признак полной недоступности.
for t := range int(secs) {
res.Timeline = append(res.Timeline, second{T: t, OK: secOK[t], Err: secErr[t]})
if secOK[t] == 0 {
res.SecondsNoOK++
}
}
return res
}
// percentiles считает p50, p95, p99 по отсортированным задержкам. Метод ближайшего ранга:
// значение берётся из данных, без интерполяции.
func percentiles(d []time.Duration) latency {
if len(d) == 0 {
return latency{}
}
slices.Sort(d)
at := func(p float64) float64 {
i := min(int(float64(len(d))*p), len(d)-1)
return float64(d[i].Microseconds()) / 1000
}
return latency{Count: len(d), P50: at(0.50), P95: at(0.95), P99: at(0.99)}
}
// incidents объединяет ошибки с разрывом меньше gap в один эпизод.
func incidents(times []time.Duration, gap time.Duration) []incident {
times = slices.Clone(times)
slices.Sort(times)
out := []incident{}
for i, t := range times {
if i == 0 || t-times[i-1] >= gap {
out = append(out, incident{StartS: t.Seconds()})
}
last := &out[len(out)-1]
last.Errors++
last.DurationS = t.Seconds() - last.StartS
}
return out
}
// writeResult пишет полный JSON в файл, а краткую версию без шкалы печатает на экран.
func writeResult(o options, res result) error {
full, err := json.MarshalIndent(res, "", " ")
if err != nil {
return err
}
if o.out != "" {
if err := os.WriteFile(o.out, append(full, '\n'), 0o644); err != nil {
return err
}
}
res.Timeline = nil
brief, err := json.Marshal(res)
if err != nil {
return err
}
fmt.Println(string(brief))
return nil
}
// randomHex возвращает n случайных байт в hex. Без случайности нет смысла продолжать, поэтому panic.
func randomHex(n int) string {
b := make([]byte, n)
if _, err := rand.Read(b); err != nil {
panic(err)
}
return hex.EncodeToString(b)
}
+31
View File
@@ -0,0 +1,31 @@
package main
import (
"testing"
"time"
)
func TestIncidentsGroupsByGap(t *testing.T) {
got := incidents([]time.Duration{
5 * time.Second,
1 * time.Second,
1500 * time.Millisecond,
}, time.Second)
if len(got) != 2 {
t.Fatalf("incidents = %+v, want 2", got)
}
if got[0].Errors != 2 || got[0].DurationS != 0.5 || got[1].Errors != 1 || got[1].DurationS != 0 {
t.Errorf("incidents = %+v", got)
}
}
func TestPercentiles(t *testing.T) {
d := make([]time.Duration, 100)
for i := range d {
d[i] = time.Duration(100-i) * time.Millisecond
}
got := percentiles(d)
if got.Count != 100 || got.P50 != 51 || got.P95 != 96 || got.P99 != 100 {
t.Errorf("percentiles = %+v", got)
}
}
+214
View File
@@ -0,0 +1,214 @@
// messenger — сервер API мессенджера, один процесс одной реплики. Своего состояния у реплики нет:
// данные лежат в PostgreSQL, сессии в Valkey, поэтому реплик может быть несколько.
//
// Здесь только сборка: загрузка настроек, подключения, создание сервисов, запуск HTTP-сервера и
// штатное завершение по SIGTERM. Логика находится в internal.
package main
import (
"context"
"fmt"
"log/slog"
"os"
"os/signal"
"runtime"
"syscall"
"time"
httpapi "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/cache"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/logging"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/password"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/session"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store/db"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/telemetry"
)
// main запускает сервер и завершается после сигнала остановки. При ошибке запуска код выхода 1.
// os.Exit не выполняет defer, поэтому перед ним подключение к БД закрывается явно.
func main() {
// Настройки из окружения. Логгера ещё нет, поэтому ошибка идёт прямо в stderr.
cfg, err := config.Load()
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
logger, err := logging.New(cfg.Logger.Level, cfg.Env, cfg.Version)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
slog.SetDefault(logger)
shutdownTelemetry, err := telemetry.Init(context.Background())
if err != nil {
logger.Error("telemetry init failed")
os.Exit(1)
}
defer shutdownTelemetry()
// Пул подключений к PostgreSQL. Без БД реплика работать не может и завершается: Docker её перезапустит.
pool, err := db.Connect(context.Background(), cfg.Database)
if err != nil {
logger.Error("database connect failed", slog.Any("err", err))
os.Exit(1)
}
// Хранилище с таймаутом запросов на все обращения к БД.
storage := db.New(pool, time.Duration(cfg.Database.QueryTimeoutMs)*time.Millisecond)
defer storage.Close()
// Общее хранилище сессий в Valkey: токен, выданный одной репликой, принимают все остальные.
sessClient, err := session.Connect(context.Background(), cfg.Cache)
if err != nil {
logger.Error("session store connect failed", slog.Any("err", err))
storage.Close()
os.Exit(1)
}
defer sessClient.Close()
sessions := session.NewValkey(sessClient)
// Хеширование паролей. Оно тяжёлое, поэтому одновременных вычислений не больше числа ядер и не больше 4.
hasher := password.NewHasher(password.Default, min(runtime.GOMAXPROCS(0), 4))
auth, err := service.NewAuth(storage, sessions, hasher, time.Duration(cfg.Session.TTLSeconds)*time.Second)
if err != nil {
logger.Error("auth init failed", slog.Any("err", err))
storage.Close()
os.Exit(1)
}
// История сообщений по умолчанию читается прямо из БД. Кэш подключается, только если он включён,
// и заменяет собой источник: остальной код разницы не видит.
var messages store.MessageStore = storage
if cfg.HistoryCache.Mode != cache.ModeOff {
hcClient, err := cache.Connect(cfg.HistoryCache)
if err != nil {
logger.Error("history cache config failed", slog.Any("err", err))
storage.Close()
os.Exit(1)
}
defer hcClient.Close()
hc := cache.New(storage.Messages, hcClient, cache.Options{
Mode: cfg.HistoryCache.Mode,
Outbox: storage.Messages,
PageTTL: time.Duration(cfg.HistoryCache.PageTTLSeconds) * time.Second,
FillDelay: time.Duration(cfg.HistoryCache.FillDelayMs) * time.Millisecond,
Logger: logger,
})
defer hc.Close()
messages = hc
}
logger.Info("history cache", slog.String("mode", cfg.HistoryCache.Mode))
// Клиент S3 не обращается к серверу при создании: bucket готовит сервис s3-init.
objects, err := objectstore.NewS3(cfg.S3)
if err != nil {
logger.Error("object store config failed", slog.Any("err", err))
storage.Close()
os.Exit(1)
}
// Сборка HTTP-сервера из готовых зависимостей.
srv := httpapi.NewServer(httpapi.Deps{
Config: cfg,
Logger: logger,
Store: storage,
Auth: auth,
Users: service.NewUsers(storage, hasher),
Chats: service.NewChats(storage),
Messages: service.NewMessages(messages),
Attachments: service.NewAttachments(storage, objects, service.AttachmentLimits{
MaxUploadBytes: cfg.Attachments.MaxUploadBytes,
MaxImagePixels: cfg.Attachments.MaxImagePixels,
MaxConcurrentUploads: cfg.Attachments.MaxConcurrentUploads,
}, logger),
// Readiness: реплика готова, только если доступны и БД, и Valkey. Иначе LB выведет её из
// работы. Схему БД эта проверка не проверяет. S3 сюда намеренно не входит: без него
// недоступны только вложения (503), а пользователи и текстовые сообщения продолжают работать.
// Если бы S3 входил в readiness, его отказ снял бы с балансировки все реплики сразу.
Ready: func(ctx context.Context) error {
if err := storage.Ping(ctx); err != nil {
return err
}
return sessions.Ping(ctx)
},
})
// ctx отменяется при SIGTERM (docker stop) или Ctrl+C: это начало штатного завершения.
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
// Фоновая очистка старых ключей идемпотентности. Останавливается вместе с ctx.
go purgeIdempotencyKeys(ctx, storage, time.Duration(cfg.Idempotency.TTLSeconds)*time.Second, logger)
// Сервер блокирует поток до остановки, поэтому запускается отдельно. Буфер 1 не даёт горутине
// зависнуть на отправке, если её уже никто не ждёт.
startErr := make(chan error, 1)
go func() {
startErr <- srv.Start()
}()
// Ждём первое из двух событий: сервер сам завершился или пришёл сигнал остановки.
select {
case err := <-startErr:
if err != nil {
logger.Error("server failed to start", slog.Any("err", err))
storage.Close()
os.Exit(1)
}
case <-ctx.Done():
logger.Info("shutdown signal received")
// Drain: readiness начинает отвечать 503, но запросы ещё обслуживаются. За это время LB
// выводит реплику, поэтому новые запросы перестают приходить до закрытия порта.
srv.Drain(time.Duration(cfg.HTTP.ShutdownDrainMs) * time.Millisecond)
}
// Предел на завершение открытых запросов. Он должен быть меньше stop_grace_period в compose.yaml,
// иначе Docker пришлёт SIGKILL раньше.
shutdownCtx, cancel := context.WithTimeout(
context.Background(),
time.Duration(cfg.HTTP.ShutdownTimeoutMs)*time.Millisecond,
)
defer cancel()
// Закрыть порт и дождаться открытых запросов. Если не успели за предел, это ошибка завершения.
if err := srv.Shutdown(shutdownCtx); err != nil {
logger.Error("shutdown failed", slog.Any("err", err))
storage.Close()
os.Exit(1)
}
// Эта строка в логе подтверждает штатное завершение: её ищет failure-detection.py.
logger.Info("server stopped cleanly")
}
// Как часто удалять устаревшие ключи идемпотентности.
const idempotencyPurgeInterval = time.Hour
// purgeIdempotencyKeys удаляет ключи старше ttl: сразу при запуске и затем по таймеру. Ошибка не
// опасна: очистка просто повторится позже. Удаление работает на каждой реплике, это безопасно,
// потому что удалять будет нечего после первой из них.
func purgeIdempotencyKeys(ctx context.Context, storage *db.DB, ttl time.Duration, logger *slog.Logger) {
t := time.NewTicker(idempotencyPurgeInterval)
defer t.Stop()
for {
if n, err := storage.PurgeIdempotencyKeys(ctx, ttl); err != nil {
// Ошибка из-за остановки сервера ожидаема: просто выходим.
if ctx.Err() != nil {
return
}
logger.Warn("idempotency keys purge failed", slog.Any("err", err))
} else if n > 0 {
logger.Info("idempotency keys purged", slog.Int64("count", n))
}
select {
case <-ctx.Done():
return
case <-t.C:
}
}
}
+226
View File
@@ -0,0 +1,226 @@
// s3check проверяет права в S3 мимо API: анонимный доступ, ограничения ключей API и очистителя,
// закрытые служебные операции. Создаёт объект и временный bucket, в конце убирает их за собой.
// Запуск: docker compose --env-file .env run --rm s3check
package main
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"net/url"
"os"
"strings"
"time"
"github.com/google/uuid"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
const publicPolicy = `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":"*","Action":["s3:GetObject"],"Resource":["arn:aws:s3:::%s/*"]}]}`
var failures int
func expect(name string, allowed bool, err error) {
// Отказом считается именно ответ сервера о правах: обрыв связи не доказывает, что доступа нет.
code := minio.ToErrorResponse(err).Code
denied := err != nil && (code == "AccessDenied" || code == "InvalidAccessKeyId" || code == "SignatureDoesNotMatch")
observed := "разрешено"
switch {
case denied:
observed = "запрещено (" + code + ")"
case err != nil:
observed = "ошибка: " + err.Error()
}
ok := (allowed && err == nil) || (!allowed && denied)
verdict := "ok "
if !ok {
verdict = "FAIL"
failures++
}
fmt.Printf("%s %-58s %s\n", verdict, name, observed)
}
func secret(name string) string {
b, err := os.ReadFile("/run/secrets/" + name)
if err != nil {
fmt.Fprintln(os.Stderr, "s3check:", err)
os.Exit(2)
}
return strings.TrimSpace(string(b))
}
func client(endpoint *url.URL, region, role string) *minio.Client {
c, err := minio.New(endpoint.Host, &minio.Options{
Creds: credentials.NewStaticV4(secret(role+"access_key_id"), secret(role+"secret_access_key"), ""),
Secure: endpoint.Scheme == "https",
Region: region,
BucketLookup: minio.BucketLookupPath,
})
if err != nil {
fmt.Fprintln(os.Stderr, "s3check:", err)
os.Exit(2)
}
return c
}
func put(ctx context.Context, c *minio.Client, bucket, key string) error {
body := []byte("s3check")
_, err := c.PutObject(ctx, bucket, key, bytes.NewReader(body), int64(len(body)), minio.PutObjectOptions{DisableMultipart: true})
return err
}
func get(ctx context.Context, c *minio.Client, bucket, key string) error {
object, err := c.GetObject(ctx, bucket, key, minio.GetObjectOptions{})
if err != nil {
return err
}
defer object.Close()
_, err = io.ReadAll(object)
return err
}
func list(ctx context.Context, c *minio.Client, bucket string) error {
for object := range c.ListObjects(ctx, bucket, minio.ListObjectsOptions{Recursive: true}) {
return object.Err
}
return nil
}
// anonymous делает запрос без подписи и возвращает код ответа.
func anonymous(ctx context.Context, method, target string) (int, error) {
req, err := http.NewRequestWithContext(ctx, method, target, nil)
if err != nil {
return 0, err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return 0, err
}
defer resp.Body.Close()
return resp.StatusCode, nil
}
func main() {
os.Exit(run())
}
// run возвращает код завершения: os.Exit не выполнил бы отложенную уборку.
func run() int {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
endpoint, err := url.Parse(os.Getenv("S3_ENDPOINT"))
if err != nil || endpoint.Host == "" {
fmt.Fprintln(os.Stderr, "s3check: S3_ENDPOINT is required")
return 2
}
region, bucket := os.Getenv("S3_REGION"), os.Getenv("S3_BUCKET")
admin := client(endpoint, region, "s3_admin_")
api := client(endpoint, region, "s3_")
cleaner := client(endpoint, region, "s3_janitor_")
// Настоящий префикс оригиналов: ключи API и очистителя ограничены им. Объект свежий, поэтому
// работающий очиститель его не тронет, а в конце проверка удаляет его сама.
probe := "originals/" + uuid.NewString()
outside := "s3check/" + uuid.NewString()
other := "s3check-" + uuid.NewString()
fmt.Println("== Ключ подготовки (admin)")
expect("создать временный чужой bucket", true, admin.MakeBucket(ctx, other, minio.MakeBucketOptions{}))
expect("записать объект в чужой bucket", true, put(ctx, admin, other, "probe"))
defer func() {
_ = admin.RemoveObject(context.Background(), other, "probe", minio.RemoveObjectOptions{})
_ = admin.RemoveBucket(context.Background(), other)
}()
fmt.Println("== Ключ API: только объекты своего bucket")
expect("PUT объекта в свой bucket", true, put(ctx, api, bucket, probe))
expect("GET объекта из своего bucket", true, get(ctx, api, bucket, probe))
expect("LIST своего bucket", false, list(ctx, api, bucket))
expect("PUT вне префикса originals/", false, put(ctx, api, bucket, outside))
expect("GET из чужого bucket", false, get(ctx, api, other, "probe"))
expect("PUT в чужой bucket", false, put(ctx, api, other, "api-probe"))
expect("DELETE из чужого bucket", false, api.RemoveObject(ctx, other, "probe", minio.RemoveObjectOptions{}))
expect("создать bucket", false, api.MakeBucket(ctx, "s3check-"+uuid.NewString(), minio.MakeBucketOptions{}))
expect("удалить bucket", false, api.RemoveBucket(ctx, other))
expect("сделать bucket публичным (policy)", false, api.SetBucketPolicy(ctx, bucket, fmt.Sprintf(publicPolicy, bucket)))
expect("прочитать policy bucket", false, func() error { _, err := api.GetBucketPolicy(ctx, bucket); return err }())
fmt.Println("== Ключ очистителя: листинг и удаление, без чтения содержимого")
expect("LIST своего bucket", true, list(ctx, cleaner, bucket))
expect("GET содержимого объекта", false, get(ctx, cleaner, bucket, probe))
expect("LIST чужого bucket", false, list(ctx, cleaner, other))
expect("PUT вне префикса originals/", false, put(ctx, cleaner, bucket, outside))
expect("сделать bucket публичным (policy)", false, cleaner.SetBucketPolicy(ctx, bucket, fmt.Sprintf(publicPolicy, bucket)))
expect("создать bucket", false, cleaner.MakeBucket(ctx, "s3check-"+uuid.NewString(), minio.MakeBucketOptions{}))
expect("удалить чужой bucket", false, cleaner.RemoveBucket(ctx, other))
expect("DELETE объекта в своём bucket", true, cleaner.RemoveObject(ctx, bucket, probe, minio.RemoveObjectOptions{}))
fmt.Println("== Политика bucket: не задана, доступ только по ключам")
policy, err := admin.GetBucketPolicy(ctx, bucket)
if err != nil && minio.ToErrorResponse(err).Code == "NoSuchBucketPolicy" {
err = nil
}
expect("прочитать политику ключом администратора", true, err)
verdict := "ok "
if policy != "" {
verdict = "FAIL"
failures++
}
fmt.Printf("%s %-58s %d байт\n", verdict, "политика пуста", len(policy))
fmt.Println("== Без подписи: приватность вне API")
if err := put(ctx, admin, bucket, probe); err != nil {
expect("подготовить объект", true, err)
}
defer func() { _ = admin.RemoveObject(context.Background(), bucket, probe, minio.RemoveObjectOptions{}) }()
base := strings.TrimRight(endpoint.String(), "/") + "/"
for _, request := range []struct{ name, method, target string }{
{"GET объекта", http.MethodGet, base + bucket + "/" + probe},
{"HEAD объекта", http.MethodHead, base + bucket + "/" + probe},
{"GET списка объектов", http.MethodGet, base + bucket + "/"},
{"GET списка bucket", http.MethodGet, base},
{"PUT объекта", http.MethodPut, base + bucket + "/" + probe + "-anon"},
{"DELETE объекта", http.MethodDelete, base + bucket + "/" + probe},
} {
status, err := anonymous(ctx, request.method, request.target)
verdict = "ok "
if err != nil || status != http.StatusForbidden {
verdict = "FAIL"
failures++
}
fmt.Printf("%s %-58s HTTP %d\n", verdict, request.name, status)
}
fmt.Println("== Служебные порты SeaweedFS из сети стенда (шлюз пропускает только 9000)")
host := endpoint.Hostname()
for _, port := range []string{"19000", "8888", "8080", "9333", "18888", "18080", "19333", "8333", "8111", "23646"} {
_, err := anonymous(ctx, http.MethodGet, "http://"+host+":"+port+"/")
verdict = "ok "
closed := "закрыт"
if err == nil {
verdict, closed = "FAIL", "ОТКРЫТ"
failures++
}
fmt.Printf("%s порт %-53s %s\n", verdict, port, closed)
}
// Имя настоящего сервера существует только во внутренней сети, куда входит лишь шлюз.
_, err = anonymous(ctx, http.MethodGet, "http://s3-storage:9000/")
verdict = "ok "
observed := "недоступен"
if err == nil {
verdict, observed = "FAIL", "ДОСТУПЕН"
failures++
}
fmt.Printf("%s %-58s %s\n", verdict, "SeaweedFS напрямую, минуя шлюз (s3-storage:9000)", observed)
if failures > 0 {
fmt.Printf("\nFAIL: %d проверок не прошли\n", failures)
return 1
}
fmt.Println("\nPASS: права S3 ограничены, bucket приватен, служебные порты закрыты")
return 0
}
+55
View File
@@ -0,0 +1,55 @@
// s3init — одноразовая подготовка хранилища: дожидается S3, создаёт bucket, удаляет постороннюю
// политику и проверяет, что bucket приватный. Повторный запуск безопасен: объекты не затрагиваются. Запускается сервисом s3-init до старта API.
package main
import (
"context"
"fmt"
"os"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
)
const waitLimit = 90 * time.Second
func main() {
if err := run(); err != nil {
fmt.Fprintln(os.Stderr, "s3init:", err)
os.Exit(1)
}
fmt.Println("s3init: bucket is ready and private")
}
func run() error {
cfg, err := config.Load()
if err != nil {
return err
}
s3, err := objectstore.NewS3(cfg.S3)
if err != nil {
return err
}
ctx, cancel := context.WithTimeout(context.Background(), waitLimit)
defer cancel()
// Шлюз S3 может стать здоровым раньше, чем готово хранилище под ним: первые ошибки ожидаемы.
for {
err = s3.EnsureBucket(ctx)
if err == nil {
removed, err := s3.RemovePolicy(ctx)
if err != nil {
return err
}
if removed {
fmt.Println("s3init: foreign bucket policy removed")
}
return s3.CheckPrivate(ctx)
}
select {
case <-ctx.Done():
return err
case <-time.After(time.Second):
}
}
}
+228
View File
@@ -0,0 +1,228 @@
// Package e2e — проверки против запущенного стенда через балансировщик.
//
// Запуск: E2E_BASE_URL=http://localhost:8080 go test -count=1 -v ./e2e/
// Без E2E_BASE_URL тесты пропускаются, поэтому обычный go test ./... стенд не требует.
// Создаёт только синтетические данные, токены и пароли не печатает.
package e2e
import (
"bytes"
"crypto/rand"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"os"
"slices"
"strings"
"sync"
"testing"
"time"
)
const (
rounds = 20
workers = 16
)
type client struct {
t *testing.T
base string
http *http.Client
token string
}
type result struct {
status int
instance string
body []byte
}
func randomHex(n int) string {
b := make([]byte, n)
if _, err := rand.Read(b); err != nil {
panic(err)
}
return hex.EncodeToString(b)
}
// do не вызывает t.Fatal: он работает и из горутин.
func (c *client) do(method, path string, headers map[string]string, payload any) (result, error) {
var body io.Reader
if payload != nil {
b, err := json.Marshal(payload)
if err != nil {
return result{}, err
}
body = bytes.NewReader(b)
}
req, err := http.NewRequest(method, c.base+path, body)
if err != nil {
return result{}, err
}
if payload != nil {
req.Header.Set("Content-Type", "application/json")
}
if c.token != "" {
req.Header.Set("Authorization", "Bearer "+c.token)
}
for k, v := range headers {
req.Header.Set(k, v)
}
resp, err := c.http.Do(req)
if err != nil {
return result{}, fmt.Errorf("%s %s: %w", method, strings.Split(path, "?")[0], err)
}
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
if err != nil {
return result{}, err
}
return result{status: resp.StatusCode, instance: resp.Header.Get("X-Instance-Id"), body: data}, nil
}
func (c *client) mustDo(method, path string, want int, payload any, out any) {
c.t.Helper()
res, err := c.do(method, path, nil, payload)
if err != nil {
c.t.Fatal(err)
}
if res.status != want {
c.t.Fatalf("%s %s: status = %d, want %d", method, strings.Split(path, "?")[0], res.status, want)
}
if out != nil {
if err := json.Unmarshal(res.body, out); err != nil {
c.t.Fatalf("%s %s: decode: %v", method, path, err)
}
}
}
// bootstrap создаёт пользователя с сессией и чат с ним.
func bootstrap(t *testing.T, base string) (*client, string) {
t.Helper()
c := &client{t: t, base: strings.TrimRight(base, "/"), http: &http.Client{Timeout: 10 * time.Second}}
username, password := "lb_"+randomHex(8), "T3st-"+randomHex(16)
var user struct {
ID string `json:"id"`
}
c.mustDo(http.MethodPost, "/api/v1/users", http.StatusCreated, map[string]string{
"username": username, "display_name": "LB test", "password": password,
}, &user)
req, err := http.NewRequest(http.MethodPost, c.base+"/api/v1/auth/sessions", nil)
if err != nil {
t.Fatal(err)
}
req.SetBasicAuth(username, password)
resp, err := c.http.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusCreated {
t.Fatalf("login: status = %d", resp.StatusCode)
}
var session struct {
Token string `json:"token"`
}
if err := json.NewDecoder(resp.Body).Decode(&session); err != nil {
t.Fatal(err)
}
c.token = session.Token
var chat struct {
ID string `json:"id"`
}
c.mustDo(http.MethodPost, "/api/v1/chats", http.StatusCreated, map[string]any{
"title": "LB test", "member_ids": []string{user.ID},
}, &chat)
return c, chat.ID
}
// Одинаковый Idempotency-Key одновременно через разные реплики создаёт ровно одно сообщение.
func TestLBSameKeyConcurrentlyThroughReplicas(t *testing.T) {
base := os.Getenv("E2E_BASE_URL")
if base == "" {
t.Skip("E2E_BASE_URL не задан")
}
c, chatID := bootstrap(t, base)
path := "/api/v1/chats/" + chatID + "/messages"
perInstance := map[string]int{}
var created []string
for round := range rounds {
key, text := randomHex(16), fmt.Sprintf("гонка %d", round)
results := make([]result, workers)
errs := make([]error, workers)
start := make(chan struct{})
var wg sync.WaitGroup
for i := range workers {
wg.Add(1)
go func() {
defer wg.Done()
<-start
results[i], errs[i] = c.do(http.MethodPost, path,
map[string]string{"Idempotency-Key": key}, map[string]string{"text": text})
}()
}
close(start)
wg.Wait()
instances := map[string]bool{}
for i := range workers {
if errs[i] != nil {
t.Fatalf("round %d: %v", round, errs[i])
}
if results[i].status != http.StatusCreated {
t.Fatalf("round %d: status = %d, want 201", round, results[i].status)
}
if !bytes.Equal(results[i].body, results[0].body) {
t.Fatalf("round %d: реплики вернули разные сообщения", round)
}
instances[results[i].instance] = true
perInstance[results[i].instance]++
}
if len(instances) < 2 {
t.Fatalf("round %d обслужила одна реплика: проверьте LB", round)
}
var msg struct {
ID string `json:"id"`
}
if err := json.Unmarshal(results[0].body, &msg); err != nil {
t.Fatal(err)
}
created = append(created, msg.ID)
}
var history []string
for cursor := ""; ; {
q := "?limit=100"
if cursor != "" {
q += "&cursor=" + url.QueryEscape(cursor)
}
var page struct {
Items []struct {
ID string `json:"id"`
} `json:"items"`
NextCursor *string `json:"next_cursor"`
}
c.mustDo(http.MethodGet, path+q, http.StatusOK, nil, &page)
for _, m := range page.Items {
history = append(history, m.ID)
}
if page.NextCursor == nil {
break
}
cursor = *page.NextCursor
}
slices.Sort(created)
slices.Sort(history)
if !slices.Equal(created, history) {
t.Fatalf("история отличается от подтверждённого: %d сообщений, ожидалось %d", len(history), len(created))
}
t.Logf("раундов: %d, запросов в раунде: %d, запросов по репликам: %v, сообщений в истории: %d",
rounds, workers, perInstance, len(history))
}
+60
View File
@@ -0,0 +1,60 @@
module gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl
go 1.26.0
require (
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.7.6
github.com/labstack/echo/v4 v4.16.2
github.com/minio/minio-go/v7 v7.0.95
github.com/redis/go-redis/v9 v9.7.3
go.opentelemetry.io/otel v1.38.0
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.14.0
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.38.0
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0
go.opentelemetry.io/otel/log v0.14.0
go.opentelemetry.io/otel/metric v1.38.0
go.opentelemetry.io/otel/sdk v1.38.0
go.opentelemetry.io/otel/sdk/log v0.14.0
go.opentelemetry.io/otel/sdk/metric v1.38.0
go.opentelemetry.io/otel/trace v1.38.0
golang.org/x/crypto v0.57.0
golang.org/x/sync v0.23.0
)
require (
github.com/cenkalti/backoff/v5 v5.0.3 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/go-ini/ini v1.67.0 // indirect
github.com/go-logr/logr v1.4.3 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/goccy/go-json v0.10.5 // indirect
github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/klauspost/compress v1.18.0 // indirect
github.com/klauspost/cpuid/v2 v2.2.11 // indirect
github.com/labstack/gommon v0.5.0 // indirect
github.com/mattn/go-colorable v0.1.15 // indirect
github.com/mattn/go-isatty v0.0.22 // indirect
github.com/minio/crc64nvme v1.0.2 // 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.3.0 // indirect
github.com/valyala/bytebufferpool v1.0.0 // indirect
github.com/valyala/fasttemplate v1.2.2 // indirect
go.opentelemetry.io/auto/sdk v1.1.0 // indirect
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 // indirect
go.opentelemetry.io/proto/otlp v1.7.1 // indirect
golang.org/x/net v0.60.0 // indirect
golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.42.0 // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 // indirect
google.golang.org/grpc v1.75.0 // indirect
google.golang.org/protobuf v1.36.8 // indirect
)
+132
View File
@@ -0,0 +1,132 @@
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 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
github.com/go-logr/logr v1.4.3/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/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/golang/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.27.2 h1:8Tjv8EJ+pM1xP8mK6egEbD1OgnVTyacbefKhmbLhIhU=
github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2/go.mod h1:pkJQ2tZHJ0aFOVEEot6oZmaVEZcRme73eIFmhiVuRWs=
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.7.6 h1:rWQc5FwZSPX58r1OQmkuaNicxdmExaEz5A2DO2hUuTk=
github.com/jackc/pgx/v5 v5.7.6/go.mod h1:aruU7o91Tc2q2cFp5h4uP3f6ztExVpyVv88Xl/8Vl8M=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.2.11 h1:0OwqZRYI2rFrjS4kvkDnqJkKHdHaRnCm68/DY4OxRzU=
github.com/klauspost/cpuid/v2 v2.2.11/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
github.com/labstack/echo/v4 v4.16.2 h1:WFPVqfogOZGH4dTr1UCIB1sqjFIQ/k7vIk5ByL6oWjY=
github.com/labstack/echo/v4 v4.16.2/go.mod h1:V/EQaTVHYJH92QhbQe7kFQ4mjgcjxLQQUQtAN87zZdw=
github.com/labstack/gommon v0.5.0 h1:6VSQ2NOzsnEJ5W6+84E0RbcaDDmgB6NIAzWCczTEe6c=
github.com/labstack/gommon v0.5.0/go.mod h1:Rzlg7HHy1maLfzBYGg9NZcVuz1sA68HHhLjhcEllYE0=
github.com/mattn/go-colorable v0.1.15 h1:+u9SLTRGnXv73cEsnsmoZBom+dMU88B2M0aDcWy0/jY=
github.com/mattn/go-colorable v0.1.15/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
github.com/mattn/go-isatty v0.0.22 h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
github.com/mattn/go-isatty v0.0.22/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
github.com/minio/crc64nvme v1.0.2 h1:6uO1UxGAD+kwqWWp7mBFsi5gAse66C4NXO8cmcVculg=
github.com/minio/crc64nvme v1.0.2/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.0.95 h1:ywOUPg+PebTMTzn9VDsoFJy32ZuARN9zhB+K3IYEvYU=
github.com/minio/minio-go/v7 v7.0.95/go.mod h1:wOOX3uxS334vImCNRVyIDdXX9OsXDm89ToynKgqUKlo=
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 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.7.3 h1:YpPyAayJV+XErNsatSElgRZZVCwXX9QzkKYNvO7x0wM=
github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA=
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/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.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/tinylib/msgp v1.3.0 h1:ULuf7GPooDaIlbyvgAxBV/FI7ynli6LZ1/nVUNu+0ww=
github.com/tinylib/msgp v1.3.0/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0=
github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.14.0 h1:QQqYw3lkrzwVsoEX0w//EhH/TCnpRdEenKBOOEIMjWc=
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp v0.14.0/go.mod h1:gSVQcr17jk2ig4jqJ2DX30IdWH251JcNAecvrqTxH1s=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.38.0 h1:Oe2z/BCg5q7k4iXC3cqJxKYg0ieRiOqF0cecFYdPTwk=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.38.0/go.mod h1:ZQM5lAJpOsKnYagGg/zV2krVqTtaVdYdDkhMoX6Oalg=
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 h1:GqRJVj7UmLjCVyVJ3ZFLdPRmhDUp2zFmQe3RHIOsw24=
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0/go.mod h1:ri3aaHSmCTVYu2AWv44YMauwAQc0aqI9gHKIcSbI1pU=
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 h1:aTL7F04bJHUlztTsNGJ2l+6he8c+y/b//eR0jjjemT4=
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0/go.mod h1:kldtb7jDTeol0l3ewcmd8SDvx3EmIE7lyvqbasU3QC4=
go.opentelemetry.io/otel/log v0.14.0 h1:2rzJ+pOAZ8qmZ3DDHg73NEKzSZkhkGIua9gXtxNGgrM=
go.opentelemetry.io/otel/log v0.14.0/go.mod h1:5jRG92fEAgx0SU/vFPxmJvhIuDU9E1SUnEQrMlJpOno=
go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
go.opentelemetry.io/otel/sdk/log v0.14.0 h1:JU/U3O7N6fsAXj0+CXz21Czg532dW2V4gG1HE/e8Zrg=
go.opentelemetry.io/otel/sdk/log v0.14.0/go.mod h1:imQvII+0ZylXfKU7/wtOND8Hn4OpT3YUoIgqJVksUkM=
go.opentelemetry.io/otel/sdk/log/logtest v0.14.0 h1:Ijbtz+JKXl8T2MngiwqBlPaHqc4YCaP/i13Qrow6gAM=
go.opentelemetry.io/otel/sdk/log/logtest v0.14.0/go.mod h1:dCU8aEL6q+L9cYTqcVOk8rM9Tp8WdnHOPLiBgp0SGOA=
go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
go.opentelemetry.io/proto/otlp v1.7.1 h1:gTOMpGDb0WTBOP8JaO72iL3auEZhVmAQg4ipjOVAtj4=
go.opentelemetry.io/proto/otlp v1.7.1/go.mod h1:b2rVh6rfI/s2pHWNlB7ILJcRALpcNDzKhACevjI+ZnE=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU=
golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 h1:BIRfGDEjiHRrk0QKZe3Xv2ieMhtgRGeLcZQ0mIVn4EY=
google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5/go.mod h1:j3QtIyytwqGr1JUDtYXwtMXWPKsEa5LtzIFN1Wn5WvE=
google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 h1:eaY8u2EuxbRv7c3NiGK0/NedzVsCcV6hDuU5qPX5EGE=
google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5/go.mod h1:M4/wBTSeyLxupu3W3tJtOgB14jILAS/XWPSSa3TAlJc=
google.golang.org/grpc v1.75.0 h1:+TW+dqTd2Biwe6KKfhE5JpiYIBWq865PhKGSXiivqt4=
google.golang.org/grpc v1.75.0/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+115
View File
@@ -0,0 +1,115 @@
package http
import (
"bytes"
"io"
"net/http"
"strings"
"testing"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
)
func TestAccess_ForeignChat(t *testing.T) {
r := newTestRig(t)
_, _, eve, chat := bootstrap(r)
base := "/api/v1/chats/" + chat.ID
cases := []struct {
method, path string
body any
}{
{http.MethodGet, base, nil},
{http.MethodGet, base + "/messages?limit=10", nil},
{http.MethodPost, base + "/messages", textMessage("вторжение")},
}
for _, tc := range cases {
var resp *http.Response
if tc.body == nil {
resp = r.do(tc.method, tc.path, eve.ID, nil, nil)
} else {
resp = r.doJSON(tc.method, tc.path, eve.ID, tc.body)
}
if resp.StatusCode != http.StatusNotFound {
data, _ := io.ReadAll(resp.Body)
resp.Body.Close()
t.Fatalf("%s %s expected 404, got %d; body=%s", tc.method, tc.path, resp.StatusCode, string(data))
}
e := readError(t, resp)
if e.Error.Code != CodeNotFound {
t.Fatalf("%s %s expected code %q, got %q", tc.method, tc.path, CodeNotFound, e.Error.Code)
}
}
resp := r.do(http.MethodGet, "/api/v1/chats?limit=100", eve.ID, nil, nil)
expectStatus(t, resp, http.StatusOK)
var page dto.ChatsPageResponse
readJSON(t, resp, &page)
for _, item := range page.Items {
if item.ID == chat.ID {
t.Fatalf("чат утёк в список чужого пользователя")
}
}
}
func TestAccess_AuthBeforeContentType(t *testing.T) {
r := newTestRig(t)
resp := r.do(http.MethodPost, "/api/v1/chats", "",
map[string]string{"Content-Type": "text/plain"}, strings.NewReader("x"))
expectStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
resp = r.do(http.MethodPost, "/api/v1/nope", "", nil, strings.NewReader("x"))
expectStatus(t, resp, http.StatusNotFound)
if resp.Header.Get("X-Request-Id") == "" {
t.Fatal("404 without X-Request-Id")
}
resp.Body.Close()
}
func TestAccess_RouterErrors(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
chatPath := "/api/v1/chats/" + chat.ID
cases := []struct {
method, path, actor string
status int
code, message string
}{
{http.MethodGet, "/nope", "", http.StatusNotFound, CodeNotFound, "Object not found"},
{http.MethodGet, "/health/live/", "", http.StatusNotFound, CodeNotFound, "Object not found"},
{http.MethodGet, "/api/v1/nope", alice.ID, http.StatusNotFound, CodeNotFound, "Object not found"},
{http.MethodPost, "/health/live", "", http.StatusMethodNotAllowed, CodeInvalidRequest, "Method not allowed"},
{http.MethodGet, "/api/v1/users", "", http.StatusMethodNotAllowed, CodeInvalidRequest, "Method not allowed"},
{http.MethodPost, "/api/v1/users/me", "", http.StatusMethodNotAllowed, CodeInvalidRequest, "Method not allowed"},
{http.MethodDelete, "/api/v1/users/me", alice.ID, http.StatusMethodNotAllowed, CodeInvalidRequest, "Method not allowed"},
{http.MethodDelete, "/api/v1/chats", alice.ID, http.StatusMethodNotAllowed, CodeInvalidRequest, "Method not allowed"},
{http.MethodPut, chatPath, alice.ID, http.StatusMethodNotAllowed, CodeInvalidRequest, "Method not allowed"},
{http.MethodPatch, chatPath + "/messages", alice.ID, http.StatusMethodNotAllowed, CodeInvalidRequest, "Method not allowed"},
}
for _, tc := range cases {
var body io.Reader
headers := map[string]string{}
if tc.method == http.MethodPost || tc.method == http.MethodPut || tc.method == http.MethodPatch {
body = bytes.NewReader([]byte(`{}`))
headers["Content-Type"] = "application/json"
}
resp := r.do(tc.method, tc.path, tc.actor, headers, body)
if resp.StatusCode != tc.status {
data, _ := io.ReadAll(resp.Body)
resp.Body.Close()
t.Fatalf("%s %s: expected %d, got %d; body=%s", tc.method, tc.path, tc.status, resp.StatusCode, string(data))
}
if tc.status == http.StatusMethodNotAllowed && resp.Header.Get("Allow") == "" {
t.Fatalf("%s %s: 405 без заголовка Allow", tc.method, tc.path)
}
e := readError(t, resp)
if e.Error.Code != tc.code || e.Error.Message != tc.message {
t.Fatalf("%s %s: expected %q/%q, got %q/%q", tc.method, tc.path, tc.code, tc.message, e.Error.Code, e.Error.Message)
}
if e.Error.RequestID == "" || e.Error.RequestID != resp.Header.Get("X-Request-Id") {
t.Fatalf("%s %s: request_id %q не совпадает с заголовком %q", tc.method, tc.path, e.Error.RequestID, resp.Header.Get("X-Request-Id"))
}
}
}
+134
View File
@@ -0,0 +1,134 @@
package http
import (
"context"
"io"
"mime"
"net/http"
"strconv"
"time"
"github.com/labstack/echo/v4"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
)
// routeUploadAttachment освобождён от общего лимита тела: свой лимит применяется в сервисе, после
// аутентификации и проверки доступа.
const routeUploadAttachment = "/api/v1/chats/:chat_id/attachments"
// transferTimeout — предел на передачу одного файла. Общие таймауты сервера (10 с) рассчитаны на
// JSON и оборвали бы загрузку 10 МиБ на медленном канале. Предел обязателен: иначе медленный клиент
// занимал бы слот загрузки неограниченно долго.
const transferTimeout = 60 * time.Second
type attachmentsHandler struct {
attachments service.AttachmentsService
}
// rejectedBodyDrainLimit — сколько байт отклонённой загрузки дочитывается впустую. Клиент обычно
// сначала отправляет всё тело и только потом читает ответ: если перестать читать, он зависнет и
// вместо 413 получит обрыв. Дочитывание идёт в никуда, поэтому память не расходует, а его время
// ограничено transferTimeout. Тело больше этого предела приводит к закрытию соединения.
const rejectedBodyDrainLimit = 64 << 20
func extendDeadlines(c echo.Context) {
rc := http.NewResponseController(c.Response())
deadline := time.Now().Add(transferTimeout)
// Ошибка значит, что соединение не поддерживает дедлайны: тогда действуют общие таймауты.
_ = rc.SetReadDeadline(deadline)
_ = rc.SetWriteDeadline(deadline)
}
// uploadTransfer стоит снаружи аутентификации, поэтому покрывает и отказы 401. Небольшой ответ об
// ошибке остаётся в буфере сервера и уходит клиенту после дочитывания.
func uploadTransfer(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
extendDeadlines(c)
err := next(c)
_, _ = io.CopyN(io.Discard, c.Request().Body, rejectedBodyDrainLimit)
return err
}
}
func (h *attachmentsHandler) upload(c echo.Context) error {
req := c.Request()
// Несколько filename неоднозначны: пустое значение сервис отклонит как неверное имя.
var filename string
if values := c.QueryParams()["filename"]; len(values) == 1 {
filename = values[0]
}
att, err := h.attachments.Upload(req.Context(), service.UploadInput{
CallerID: c.Get(middleware.AuthUserIDKey).(string),
ChatID: c.Param("chat_id"),
Filename: filename,
ContentType: req.Header.Get(echo.HeaderContentType),
ContentLength: req.ContentLength,
Body: req.Body,
})
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusAccepted, toAttachmentResponse(att))
}
func (h *attachmentsHandler) get(c echo.Context) error {
att, err := h.attachments.Get(c.Request().Context(), c.Get(middleware.AuthUserIDKey).(string), c.Param("attachment_id"))
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusOK, toAttachmentResponse(att))
}
func (h *attachmentsHandler) content(c echo.Context) error {
extendDeadlines(c)
variant := service.VariantOriginal
if values, ok := c.QueryParams()["variant"]; ok {
variant = values[0]
}
ctx, cancel := context.WithTimeout(c.Request().Context(), transferTimeout)
defer cancel()
att, body, err := h.attachments.Content(ctx, c.Get(middleware.AuthUserIDKey).(string), c.Param("attachment_id"), variant)
if err != nil {
return WriteError(c, err)
}
defer body.Close()
header := c.Response().Header()
header.Set(echo.HeaderContentLength, strconv.FormatInt(att.SizeBytes, 10))
// Файл загрузил пользователь: браузер не должен угадывать тип или показывать его как страницу.
header.Set("X-Content-Type-Options", "nosniff")
header.Set("Cache-Control", "private, no-store")
if cd := mime.FormatMediaType("attachment", map[string]string{"filename": att.Filename}); cd != "" {
header.Set(echo.HeaderContentDisposition, cd)
} else {
header.Set(echo.HeaderContentDisposition, "attachment")
}
// Обрыв после начала передачи клиент увидит как неполный ответ: длина объявлена заранее.
return c.Stream(http.StatusOK, att.ContentType, body)
}
func toAttachmentResponse(a domain.Attachment) dto.AttachmentResponse {
variants := make([]dto.VariantResponse, 0, len(a.Variants))
for _, v := range a.Variants {
variants = append(variants, dto.VariantResponse{Name: v.Name, ContentType: v.ContentType, SizeBytes: v.SizeBytes, Width: v.Width, Height: v.Height, SHA256: v.SHA256})
}
return dto.AttachmentResponse{
ID: a.ID,
ChatID: a.ChatID,
OwnerID: a.OwnerID,
Filename: a.Filename,
ContentType: a.ContentType,
SizeBytes: a.SizeBytes,
SHA256: a.SHA256,
Status: a.Status,
Variants: variants,
ErrorCode: a.ErrorCode,
CreatedAt: dto.NewTimestamp(a.CreatedAt),
UpdatedAt: dto.NewTimestamp(a.UpdatedAt),
}
}
+546
View File
@@ -0,0 +1,546 @@
package http
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"image"
"image/jpeg"
"image/png"
"io"
"log/slog"
"net/http"
"net/url"
"os"
"strings"
"testing"
"github.com/google/uuid"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
func testPNG(t *testing.T, w, h int) []byte {
t.Helper()
var b bytes.Buffer
if err := png.Encode(&b, image.NewRGBA(image.Rect(0, 0, w, h))); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
func testJPEG(t *testing.T) []byte {
t.Helper()
var b bytes.Buffer
if err := jpeg.Encode(&b, image.NewRGBA(image.Rect(0, 0, 8, 8)), nil); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
func (r *testRig) upload(actor, chatID, filename, contentType string, data []byte) *http.Response {
r.t.Helper()
return r.do(http.MethodPost, "/api/v1/chats/"+chatID+"/attachments?filename="+url.QueryEscape(filename), actor,
map[string]string{"Content-Type": contentType}, bytes.NewReader(data))
}
func (r *testRig) uploadOK(actor, chatID string, data []byte) dto.AttachmentResponse {
r.t.Helper()
resp := r.upload(actor, chatID, "photo.png", "image/png", data)
expectStatus(r.t, resp, http.StatusAccepted)
var att dto.AttachmentResponse
readJSON(r.t, resp, &att)
return att
}
func TestAttachment_QueuedIsDurableAndNotDownloadable(t *testing.T) {
r := newTestRig(t)
alice, bob, eve, chat := bootstrap(r)
data := testPNG(t, 16, 16)
att := r.uploadOK(alice.ID, chat.ID, data)
sum := sha256.Sum256(data)
if att.Status != "queued" || att.SHA256 != hex.EncodeToString(sum[:]) || att.SizeBytes != int64(len(data)) ||
att.OwnerID != alice.ID || att.ChatID != chat.ID || att.ErrorCode != nil || att.Variants == nil {
t.Errorf("metadata = %+v", att)
}
resp := r.do(http.MethodGet, "/api/v1/attachments/"+att.ID+"/content", bob.ID, nil, nil)
expectStatus(t, resp, http.StatusConflict)
resp.Body.Close()
// Queued data is already in durable staging; API has not published final objects.
stored, _, err := r.objects.Get(context.Background(), "staging/"+att.ID)
if err != nil {
t.Fatal(err)
}
defer stored.Close()
got, _ := io.ReadAll(stored)
if !bytes.Equal(got, data) {
t.Fatal("staging bytes differ")
}
for _, suffix := range []string{"", "/content"} {
resp := r.do(http.MethodGet, "/api/v1/attachments/"+att.ID+suffix, eve.ID, nil, nil)
expectStatus(t, resp, http.StatusNotFound)
resp.Body.Close()
}
}
func TestAttachment_ObjectKeyIsServerAssignedAndHidden(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
resp := r.upload(alice.ID, chat.ID, "evil..name.png", "image/png", testPNG(t, 2, 2))
expectStatus(t, resp, http.StatusAccepted)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
keys := r.objects.Keys()
if len(keys) != 1 || strings.Contains(keys[0], "evil") {
t.Fatalf("object keys = %v", keys)
}
if bytes.Contains(body, []byte(keys[0])) || bytes.Contains(body, []byte("object_key")) {
t.Errorf("response exposes object key: %s", body)
}
}
func TestAttachment_Rejections(t *testing.T) {
r := newTestRig(t)
alice, _, eve, chat := bootstrap(r)
valid := testPNG(t, 4, 4)
oversized := append(bytes.Clone(valid), make([]byte, testMaxUploadBytes)...)
cases := []struct {
name string
actor string
chat string
filename string
contentType string
data []byte
want int
}{
{"outsider", eve.ID, chat.ID, "a.png", "image/png", valid, 404},
{"outsider sees 404 before size check", eve.ID, chat.ID, "a.png", "image/png", oversized, 404},
{"unknown chat", alice.ID, uuid.NewString(), "a.png", "image/png", valid, 404},
{"bad chat id", alice.ID, "nope", "a.png", "image/png", valid, 400},
{"path in filename", alice.ID, chat.ID, "../a.png", "image/png", valid, 400},
{"backslash in filename", alice.ID, chat.ID, `a\b.png`, "image/png", valid, 400},
{"NUL in filename", alice.ID, chat.ID, "a\x00.png", "image/png", valid, 400},
{"empty filename", alice.ID, chat.ID, "", "image/png", valid, 400},
{"too many bytes", alice.ID, chat.ID, "a.png", "image/png", oversized, 413},
{"too many pixels", alice.ID, chat.ID, "a.png", "image/png", testPNG(t, 101, 100), 413},
{"wrong declared type", alice.ID, chat.ID, "a.png", "application/json", valid, 415},
{"no declared type", alice.ID, chat.ID, "a.png", "", valid, 415},
{"declared jpeg, actual png", alice.ID, chat.ID, "a.jpg", "image/jpeg", valid, 415},
{"declared png, actual jpeg", alice.ID, chat.ID, "a.png", "image/png", testJPEG(t), 415},
{"not an image", alice.ID, chat.ID, "a.png", "image/png", []byte("<html>"), 415},
{"truncated", alice.ID, chat.ID, "a.png", "image/png", valid[:len(valid)/2], 415},
{"empty body", alice.ID, chat.ID, "a.png", "image/png", nil, 415},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
resp := r.upload(tc.actor, tc.chat, tc.filename, tc.contentType, tc.data)
defer resp.Body.Close()
if resp.StatusCode != tc.want {
body, _ := io.ReadAll(resp.Body)
t.Fatalf("status = %d, want %d, body = %s", resp.StatusCode, tc.want, body)
}
})
}
if keys := r.objects.Keys(); len(keys) != 0 {
t.Errorf("rejected uploads left objects: %v", keys)
}
}
func TestAttachment_RequiresAuthentication(t *testing.T) {
r := newTestRig(t)
_, _, _, chat := bootstrap(r)
resp := r.upload("", chat.ID, "a.png", "image/png", testPNG(t, 2, 2))
expectStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
}
func TestAttachment_S3UnavailableGives503AndKeepsMessagesWorking(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
data := testPNG(t, 2, 2)
att := r.uploadOK(alice.ID, chat.ID, data)
r.objects.Down.Store(true)
resp := r.upload(alice.ID, chat.ID, "b.png", "image/png", data)
expectStatus(t, resp, http.StatusServiceUnavailable)
if code := readError(t, resp).Error.Code; code != "unavailable" {
t.Errorf("code = %q", code)
}
resp = r.do(http.MethodGet, "/api/v1/attachments/"+att.ID+"/content", alice.ID, nil, nil)
expectStatus(t, resp, http.StatusConflict)
resp.Body.Close()
// Метаданные лежат в БД и остаются доступными.
resp = r.do(http.MethodGet, "/api/v1/attachments/"+att.ID, alice.ID, nil, nil)
expectStatus(t, resp, http.StatusOK)
resp.Body.Close()
if code, _ := r.send(alice, chat.ID, "текст без S3"); code != http.StatusCreated {
t.Errorf("message status = %d", code)
}
r.objects.Down.Store(false)
resp = r.do(http.MethodGet, "/api/v1/attachments/"+att.ID+"/content", alice.ID, nil, nil)
expectStatus(t, resp, http.StatusConflict)
resp.Body.Close()
}
func TestAttachment_UnknownVariant(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
att := r.uploadOK(alice.ID, chat.ID, testPNG(t, 2, 2))
for query, want := range map[string]int{"?variant=original": 409, "?variant=thumbnail": 409, "?variant=../x": 400, "?variant=": 400} {
resp := r.do(http.MethodGet, "/api/v1/attachments/"+att.ID+"/content"+query, alice.ID, nil, nil)
if resp.StatusCode != want {
t.Errorf("%s: status = %d, want %d", query, resp.StatusCode, want)
}
resp.Body.Close()
}
}
func TestMessage_AttachmentRules(t *testing.T) {
r := newTestRig(t)
alice, bob, _, chat := bootstrap(r)
other := r.createChat(alice, "другой", alice.ID)
data := testPNG(t, 2, 2)
att := r.uploadOK(alice.ID, chat.ID, data)
foreign := r.uploadOK(alice.ID, other.ID, data)
path := "/api/v1/chats/" + chat.ID + "/messages"
post := func(body string) *http.Response {
return r.do(http.MethodPost, path, bob.ID, map[string]string{"Content-Type": "application/json"}, strings.NewReader(body))
}
cases := []struct {
name string
body string
want int
}{
{"empty text with attachment", `{"text":"","attachment_ids":["` + att.ID + `"]}`, 201},
{"spaces with attachment", `{"text":" ","attachment_ids":["` + att.ID + `"]}`, 201},
{"empty attachment list is the old form", `{"text":"x","attachment_ids":[]}`, 201},
{"empty text without attachments", `{"text":"","attachment_ids":[]}`, 400},
{"text is still required", `{"attachment_ids":["` + att.ID + `"]}`, 400},
{"null list", `{"text":"x","attachment_ids":null}`, 400},
{"wrong type", `{"text":"x","attachment_ids":"` + att.ID + `"}`, 400},
{"invalid id", `{"text":"x","attachment_ids":["nope"]}`, 400},
{"duplicate", `{"text":"x","attachment_ids":["` + att.ID + `","` + strings.ToUpper(att.ID) + `"]}`, 400},
{"unknown attachment", `{"text":"x","attachment_ids":["` + uuid.NewString() + `"]}`, 404},
{"attachment of another chat", `{"text":"x","attachment_ids":["` + foreign.ID + `"]}`, 404},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
resp := post(tc.body)
defer resp.Body.Close()
if resp.StatusCode != tc.want {
body, _ := io.ReadAll(resp.Body)
t.Fatalf("status = %d, want %d, body = %s", resp.StatusCode, tc.want, body)
}
})
}
items, _ := r.listMessages(alice, chat.ID, 100)
if len(items) != 3 || len(items[0].AttachmentIDs) != 1 || items[0].AttachmentIDs[0] != att.ID {
t.Errorf("history = %+v", items)
}
if items[2].AttachmentIDs == nil {
t.Error("message without attachments must have [] rather than null")
}
}
func TestMessage_IdempotencyCoversAttachments(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
a := r.uploadOK(alice.ID, chat.ID, testPNG(t, 2, 2)).ID
b := r.uploadOK(alice.ID, chat.ID, testPNG(t, 3, 3)).ID
key := uuid.NewString()
code, first := r.postKeyed(alice.ID, chat.ID, key, `{"text":"x","attachment_ids":["`+a+`","`+b+`"]}`)
if code != http.StatusCreated {
t.Fatalf("first: %d %s", code, first)
}
code, replay := r.postKeyed(alice.ID, chat.ID, key, `{"attachment_ids":["`+a+`","`+b+`"],"text":"x"}`)
if code != http.StatusCreated || !bytes.Equal(first, replay) {
t.Errorf("replay: %d %s", code, replay)
}
if code, body := r.postKeyed(alice.ID, chat.ID, key, `{"text":"x","attachment_ids":["`+b+`"]}`); code != http.StatusConflict {
t.Errorf("other attachments: %d %s", code, body)
}
// Отсутствующий attachment_ids равен пустому списку.
plain := uuid.NewString()
if code, _ := r.postKeyed(alice.ID, chat.ID, plain, `{"text":"y"}`); code != http.StatusCreated {
t.Fatalf("plain: %d", code)
}
if code, body := r.postKeyed(alice.ID, chat.ID, plain, `{"text":"y","attachment_ids":[]}`); code != http.StatusCreated {
t.Errorf("plain replay: %d %s", code, body)
}
}
// failingMetadata имитирует отказ БД между записью в S3 и записью метаданных.
type failingMetadata struct{ *store.Memory }
func (f failingMetadata) CreateAttachment(context.Context, domain.Attachment) (domain.Attachment, error) {
return domain.Attachment{}, domain.ErrUnavailable
}
func TestAttachment_MetadataFailureRemovesObject(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
objects := objectstore.NewMemory()
svc := service.NewAttachments(failingMetadata{r.memory}, objects, service.AttachmentLimits{
MaxUploadBytes: testMaxUploadBytes, MaxImagePixels: testMaxImagePixels, MaxConcurrentUploads: 1,
}, slog.New(slog.NewTextHandler(io.Discard, nil)))
data := testPNG(t, 2, 2)
_, err := svc.Upload(context.Background(), service.UploadInput{
CallerID: alice.ID, ChatID: chat.ID, Filename: "a.png", ContentType: "image/png",
ContentLength: int64(len(data)), Body: bytes.NewReader(data),
})
if !errors.Is(err, domain.ErrUnavailable) {
t.Fatalf("err = %v", err)
}
if keys := objects.Keys(); len(keys) != 0 {
t.Errorf("object left without metadata: %v", keys)
}
}
// lostCommit имитирует потерю ответа: строка сохранилась, а INSERT вернул ошибку.
type lostCommit struct{ *store.Memory }
func (l lostCommit) CreateAttachment(ctx context.Context, att domain.Attachment) (domain.Attachment, error) {
if _, err := l.Memory.CreateAttachment(ctx, att); err != nil {
return domain.Attachment{}, err
}
return domain.Attachment{}, domain.ErrUnavailable
}
// metadataDown имитирует БД, недоступную и для записи, и для проверки перед компенсацией.
type metadataDown struct{ failingMetadata }
func (metadataDown) AttachmentExists(context.Context, string) (bool, error) {
return false, domain.ErrUnavailable
}
func uploadVia(t *testing.T, svc *service.Attachments, caller, chatID string, body io.Reader, size int64) error {
t.Helper()
_, err := svc.Upload(context.Background(), service.UploadInput{
CallerID: caller, ChatID: chatID, Filename: "a.png", ContentType: "image/png", ContentLength: size, Body: body,
})
return err
}
// Строка в БД не должна остаться без файла: при потерянном ответе объект удалять нельзя.
func TestAttachment_LostCommitKeepsObject(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
objects := objectstore.NewMemory()
svc := service.NewAttachments(lostCommit{r.memory}, objects, service.AttachmentLimits{
MaxUploadBytes: testMaxUploadBytes, MaxImagePixels: testMaxImagePixels, MaxConcurrentUploads: 1,
}, slog.New(slog.NewTextHandler(io.Discard, nil)))
data := testPNG(t, 2, 2)
if err := uploadVia(t, svc, alice.ID, chat.ID, bytes.NewReader(data), int64(len(data))); !errors.Is(err, domain.ErrUnavailable) {
t.Fatalf("err = %v", err)
}
if keys := objects.Keys(); len(keys) != 1 {
t.Errorf("object of a committed row was deleted: %v", keys)
}
}
// Если проверить нельзя, объект остаётся очистителю, а не удаляется вслепую.
func TestAttachment_UncheckableMetadataLeavesObjectToJanitor(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
objects := objectstore.NewMemory()
svc := service.NewAttachments(metadataDown{failingMetadata{r.memory}}, objects, service.AttachmentLimits{
MaxUploadBytes: testMaxUploadBytes, MaxImagePixels: testMaxImagePixels, MaxConcurrentUploads: 1,
}, slog.New(slog.NewTextHandler(io.Discard, nil)))
data := testPNG(t, 2, 2)
if err := uploadVia(t, svc, alice.ID, chat.ID, bytes.NewReader(data), int64(len(data))); !errors.Is(err, domain.ErrUnavailable) {
t.Fatalf("err = %v", err)
}
if keys := objects.Keys(); len(keys) != 1 {
t.Errorf("object deleted without a metadata check: %v", keys)
}
}
// brokenBody отдаёт начало файла и обрывается: так выглядит отключившийся клиент.
type brokenBody struct{ data []byte }
func (b *brokenBody) Read(p []byte) (int, error) {
if len(b.data) == 0 {
return 0, io.ErrUnexpectedEOF
}
n := copy(p, b.data)
b.data = b.data[n:]
return n, nil
}
func spoolFiles(t *testing.T, dir string) []string {
t.Helper()
entries, err := os.ReadDir(dir)
if err != nil {
t.Fatal(err)
}
names := make([]string, 0, len(entries))
for _, entry := range entries {
names = append(names, entry.Name())
}
return names
}
func TestAttachment_InterruptedUploadLeavesNothing(t *testing.T) {
dir := t.TempDir()
t.Setenv("TMPDIR", dir)
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
svc := service.NewAttachments(r.memory, r.objects, service.AttachmentLimits{
MaxUploadBytes: testMaxUploadBytes, MaxImagePixels: testMaxImagePixels, MaxConcurrentUploads: 1,
}, slog.New(slog.NewTextHandler(io.Discard, nil)))
data := testPNG(t, 8, 8)
err := uploadVia(t, svc, alice.ID, chat.ID, &brokenBody{data: bytes.Clone(data[:len(data)/2])}, int64(len(data)))
var invalid *validate.Error
if !errors.As(err, &invalid) {
t.Fatalf("err = %v, want a client error rather than 500", err)
}
if keys := r.objects.Keys(); len(keys) != 0 {
t.Errorf("interrupted upload reached S3: %v", keys)
}
if files := spoolFiles(t, dir); len(files) != 0 {
t.Errorf("temporary files left: %v", files)
}
// Слот освобождён: следующая загрузка проходит при лимите в один файл.
if err := uploadVia(t, svc, alice.ID, chat.ID, bytes.NewReader(data), int64(len(data))); err != nil {
t.Errorf("slot was not released: %v", err)
}
}
func TestAttachment_TemporaryFileIsRemovedWhileUploadIsRunning(t *testing.T) {
dir := t.TempDir()
t.Setenv("TMPDIR", dir)
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
svc := service.NewAttachments(r.memory, r.objects, service.AttachmentLimits{
MaxUploadBytes: testMaxUploadBytes, MaxImagePixels: testMaxImagePixels, MaxConcurrentUploads: 1,
}, slog.New(slog.NewTextHandler(io.Discard, nil)))
blocked := &blockingReader{release: make(chan struct{}), started: make(chan struct{})}
done := make(chan error, 1)
go func() { done <- uploadVia(t, svc, alice.ID, chat.ID, blocked, -1) }()
<-blocked.started
// Файл уже открыт и убран из каталога: падение процесса в этот момент ничего не оставит.
if files := spoolFiles(t, dir); len(files) != 0 {
t.Errorf("temporary file is visible during upload: %v", files)
}
close(blocked.release)
<-done
}
// Тело без Content-Length не должно обойти лимит размера.
func TestAttachment_ChunkedOverLimitGives413(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
big := append(testPNG(t, 2, 2), make([]byte, testMaxUploadBytes)...)
req, err := http.NewRequest(http.MethodPost, r.server.URL+"/api/v1/chats/"+chat.ID+"/attachments?filename=a.png", io.MultiReader(bytes.NewReader(big)))
if err != nil {
t.Fatal(err)
}
req.ContentLength = -1
req.Header.Set("Content-Type", "image/png")
r.setAuth(req, alice.ID)
resp, err := r.client.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
expectStatus(t, resp, http.StatusRequestEntityTooLarge)
if keys := r.objects.Keys(); len(keys) != 0 {
t.Errorf("oversized upload reached S3: %v", keys)
}
}
// blockingReader держит загрузку открытой, пока тест не разрешит продолжить.
type blockingReader struct {
release chan struct{}
started chan struct{}
}
func (b *blockingReader) Read([]byte) (int, error) {
close(b.started)
<-b.release
return 0, io.EOF
}
func TestAttachment_ConcurrentUploadLimitGives429(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
objects := objectstore.NewMemory()
svc := service.NewAttachments(r.memory, objects, service.AttachmentLimits{
MaxUploadBytes: testMaxUploadBytes, MaxImagePixels: testMaxImagePixels, MaxConcurrentUploads: 1,
}, slog.New(slog.NewTextHandler(io.Discard, nil)))
blocked := &blockingReader{release: make(chan struct{}), started: make(chan struct{})}
done := make(chan error, 1)
go func() {
_, err := svc.Upload(context.Background(), service.UploadInput{
CallerID: alice.ID, ChatID: chat.ID, Filename: "a.png", ContentType: "image/png", Body: blocked,
})
done <- err
}()
<-blocked.started
data := testPNG(t, 2, 2)
_, err := svc.Upload(context.Background(), service.UploadInput{
CallerID: alice.ID, ChatID: chat.ID, Filename: "b.png", ContentType: "image/png", Body: bytes.NewReader(data),
})
if !errors.Is(err, domain.ErrRateLimited) {
t.Errorf("second upload: %v", err)
}
close(blocked.release)
<-done
}
// Клиент, который читает ответ только после отправки всего тела, должен получить код, а не обрыв.
func TestAttachment_RejectedBodyIsDrainedSoClientGetsStatus(t *testing.T) {
r := newTestRig(t)
alice, _, eve, chat := bootstrap(r)
big := make([]byte, 8*testMaxUploadBytes)
path := "/api/v1/chats/" + chat.ID + "/attachments?filename=a.png"
cases := []struct {
name string
actor string
want int
}{
{"too large", alice.ID, http.StatusRequestEntityTooLarge},
{"outsider", eve.ID, http.StatusNotFound},
{"no session", "", http.StatusUnauthorized},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
for _, length := range []int64{int64(len(big)), -1} { // с Content-Length и chunked
req, err := http.NewRequest(http.MethodPost, r.server.URL+path, io.MultiReader(bytes.NewReader(big)))
if err != nil {
t.Fatal(err)
}
req.ContentLength = length
req.Header.Set("Content-Type", "image/png")
r.setAuth(req, tc.actor)
resp, err := r.client.Do(req)
if err != nil {
t.Fatalf("length %d: %v", length, err)
}
resp.Body.Close()
if resp.StatusCode != tc.want {
t.Errorf("length %d: status = %d, want %d", length, resp.StatusCode, tc.want)
}
}
})
}
}
+73
View File
@@ -0,0 +1,73 @@
package http
import (
"encoding/base64"
"errors"
"io"
"net/http"
"strings"
"unicode/utf8"
"github.com/labstack/echo/v4"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
type authHandler struct {
auth service.AuthService
}
func (h *authHandler) createSession(c echo.Context) error {
// Read at most one byte: chunked requests have no known Content-Length.
var first [1]byte
n, err := io.ReadFull(c.Request().Body, first[:])
if n != 0 || (err != nil && !errors.Is(err, io.EOF)) {
return WriteError(c, &validate.Error{Field: "body", Reason: "must be empty, credentials go in Authorization: Basic"})
}
username, password, ok := parseBasic(c.Request().Header.Get(echo.HeaderAuthorization))
if !ok {
return middleware.Unauthorized(c, middleware.BasicChallenge, "Invalid credentials")
}
s, err := h.auth.Login(c.Request().Context(), username, password)
if err != nil {
if errors.Is(err, domain.ErrUnauthorized) {
return middleware.Unauthorized(c, middleware.BasicChallenge, "Invalid credentials")
}
return WriteError(c, err)
}
return c.JSON(http.StatusCreated, dto.SessionResponse{
Token: s.Token,
TokenType: "Bearer",
ExpiresAt: dto.NewTimestamp(s.ExpiresAt),
User: toUserResponse(s.User),
})
}
func (h *authHandler) revokeSession(c echo.Context) error {
tok := c.Get(middleware.AuthTokenKey).(string)
if err := h.auth.Logout(c.Request().Context(), tok); err != nil {
return WriteError(c, err)
}
return c.NoContent(http.StatusNoContent)
}
func parseBasic(header string) (username, password string, ok bool) {
scheme, encoded, found := strings.Cut(header, " ")
if !found || !strings.EqualFold(scheme, "Basic") {
return "", "", false
}
raw, err := base64.StdEncoding.DecodeString(strings.TrimSpace(encoded))
if err != nil || !utf8.Valid(raw) {
return "", "", false
}
username, password, found = strings.Cut(string(raw), ":")
if !found || username == "" || password == "" {
return "", "", false
}
return username, password, true
}
+242
View File
@@ -0,0 +1,242 @@
package http
import (
"context"
"encoding/base64"
"io"
"net/http"
"strings"
"testing"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/session"
)
const (
basicChallenge = `Basic realm="messenger", charset="UTF-8"`
bearerChallenge = `Bearer realm="messenger"`
)
func expectUnauthorized(t *testing.T, resp *http.Response, challenge string) {
t.Helper()
defer resp.Body.Close()
if resp.StatusCode != http.StatusUnauthorized {
data, _ := io.ReadAll(resp.Body)
t.Fatalf("expected 401, got %d; body=%s", resp.StatusCode, string(data))
}
if got := resp.Header.Get("WWW-Authenticate"); got != challenge {
t.Fatalf("WWW-Authenticate = %q, want %q", got, challenge)
}
e := readError(t, resp)
if e.Error.Code != CodeUnauthorized || e.Error.RequestID == "" {
t.Fatalf("unexpected error body: %+v", e)
}
}
func (r *testRig) withHeaders(method, path string, headers map[string]string) *http.Response {
r.t.Helper()
return r.do(method, path, "", headers, nil)
}
func TestAuth_LoginReturnsSession(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("login_"+randomSuffix(), "Алиса")
before := time.Now()
s := r.login(alice.Username, testPassword)
if s.TokenType != "Bearer" || len(s.Token) < 32 {
t.Fatalf("bad session: type=%q len(token)=%d", s.TokenType, len(s.Token))
}
if s.User.ID != alice.ID || s.User.Username != alice.Username {
t.Fatalf("session user = %+v, want %s", s.User, alice.ID)
}
if strings.Contains(s.Token, alice.ID) || strings.Contains(s.Token, alice.Username) {
t.Fatal("token is derived from user identity")
}
if !s.ExpiresAt.After(before.Add(59*time.Minute)) || s.ExpiresAt.After(before.Add(61*time.Minute)) {
t.Fatalf("expires_at = %s, want ~now+1h", s.ExpiresAt)
}
if again := r.login(alice.Username, testPassword); again.Token == s.Token {
t.Fatal("second login returned the same token")
}
}
func TestAuth_LoginRejectsBadCredentialsUniformly(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("bad_"+randomSuffix(), "Алиса")
expectUnauthorized(t, r.basicLogin(alice.Username, "wrong-password-123"), basicChallenge)
expectUnauthorized(t, r.basicLogin("nobody_"+randomSuffix(), testPassword), basicChallenge)
b64 := func(s string) string { return base64.StdEncoding.EncodeToString([]byte(s)) }
for _, h := range []string{
"",
"Bearer " + b64(alice.Username+":"+testPassword),
"Basic not-base64!!!",
"Basic " + b64(alice.Username),
"Basic " + b64(alice.Username+":"),
"Basic " + b64(":"+testPassword),
"Basic " + b64(alice.Username+":\xff\xfe"),
} {
headers := map[string]string{}
if h != "" {
headers["Authorization"] = h
}
expectUnauthorized(t, r.withHeaders(http.MethodPost, "/api/v1/auth/sessions", headers), basicChallenge)
}
}
func TestAuth_PasswordWithColonAndUnicode(t *testing.T) {
r := newTestRig(t)
username := "colon_" + randomSuffix()
pw := "пароль:с:двоеточиями🙂"
resp := r.doJSON(http.MethodPost, "/api/v1/users", "", dto.CreateUserRequest{
Username: username, DisplayName: "Двоеточие", Password: pw,
})
expectStatus(t, resp, http.StatusCreated)
resp.Body.Close()
r.login(username, pw)
expectUnauthorized(t, r.basicLogin(username, "пароль"), basicChallenge)
}
func TestAuth_LoginRejectsBody(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("body_"+randomSuffix(), "Алиса")
req, _ := http.NewRequest(http.MethodPost, r.server.URL+"/api/v1/auth/sessions",
strings.NewReader(`{"username":"`+alice.Username+`"}`))
req.Header.Set("Content-Type", "application/json")
req.SetBasicAuth(alice.Username, testPassword)
resp, err := r.client.Do(req)
if err != nil {
t.Fatal(err)
}
expectStatus(t, resp, http.StatusBadRequest)
resp.Body.Close()
}
func TestAuth_LoginChunkedBody(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("chunked_"+randomSuffix(), "Алиса")
for _, body := range []string{"", " ", `{"extra":1}`} {
t.Run(body, func(t *testing.T) {
req, err := http.NewRequest(http.MethodPost, r.server.URL+"/api/v1/auth/sessions", io.NopCloser(strings.NewReader(body)))
if err != nil {
t.Fatal(err)
}
req.TransferEncoding = []string{"chunked"}
req.SetBasicAuth(alice.Username, testPassword)
resp, err := r.client.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
want := http.StatusBadRequest
if body == "" {
want = http.StatusCreated
}
expectStatus(t, resp, want)
})
}
}
func TestAuth_BearerRequired(t *testing.T) {
r := newTestRig(t)
alice, _, eve, _ := bootstrap(r)
expectUnauthorized(t, r.withHeaders(http.MethodGet, "/api/v1/users/me", nil), bearerChallenge)
expectUnauthorized(t, r.withHeaders(http.MethodGet, "/api/v1/users/me",
map[string]string{"X-User-Id": alice.ID}), bearerChallenge)
basic := base64.StdEncoding.EncodeToString([]byte(alice.Username + ":" + testPassword))
expectUnauthorized(t, r.withHeaders(http.MethodGet, "/api/v1/users/me",
map[string]string{"Authorization": "Basic " + basic}), bearerChallenge)
expectUnauthorized(t, r.withHeaders(http.MethodGet, "/api/v1/users/me",
map[string]string{"Authorization": "Bearer " + strings.Repeat("A", 43)}), bearerChallenge)
expectUnauthorized(t, r.withHeaders(http.MethodGet, "/api/v1/users/me",
map[string]string{"Authorization": "Bearer " + alice.ID}), bearerChallenge)
resp := r.do(http.MethodGet, "/api/v1/users/me", alice.ID, map[string]string{"X-User-Id": eve.ID}, nil)
expectStatus(t, resp, http.StatusOK)
var me dto.UserResponse
readJSON(t, resp, &me)
if me.ID != alice.ID {
t.Fatalf("X-User-Id overrode bearer identity: got %s", me.ID)
}
tok := r.tokens[alice.ID]
resp = r.withHeaders(http.MethodGet, "/api/v1/users/me", map[string]string{"Authorization": "bearer " + tok})
expectStatus(t, resp, http.StatusOK)
resp.Body.Close()
}
func TestAuth_Logout(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("logout_"+randomSuffix(), "Алиса")
other := r.login(alice.Username, testPassword)
resp := r.do(http.MethodDelete, "/api/v1/auth/sessions/current", alice.ID, nil, nil)
expectStatus(t, resp, http.StatusNoContent)
body, _ := io.ReadAll(resp.Body)
resp.Body.Close()
if len(body) != 0 {
t.Fatalf("204 with body %q", body)
}
expectUnauthorized(t, r.do(http.MethodGet, "/api/v1/users/me", alice.ID, nil, nil), bearerChallenge)
expectUnauthorized(t, r.do(http.MethodDelete, "/api/v1/auth/sessions/current", alice.ID, nil, nil), bearerChallenge)
resp = r.withHeaders(http.MethodGet, "/api/v1/users/me", map[string]string{"Authorization": "Bearer " + other.Token})
expectStatus(t, resp, http.StatusOK)
resp.Body.Close()
}
func TestAuth_SessionExpires(t *testing.T) {
r := newRig(t, defaultTestLimits, session.NewMemory(), 2*time.Second)
alice := r.createUser("ttl_"+randomSuffix(), "Алиса")
resp := r.do(http.MethodGet, "/api/v1/users/me", alice.ID, nil, nil)
expectStatus(t, resp, http.StatusOK)
resp.Body.Close()
time.Sleep(2100 * time.Millisecond)
expectUnauthorized(t, r.do(http.MethodGet, "/api/v1/users/me", alice.ID, nil, nil), bearerChallenge)
}
type brokenSessions struct {
*session.Memory
down bool
}
func (b *brokenSessions) Get(ctx context.Context, h []byte) (session.Session, error) {
if b.down {
return session.Session{}, domain.ErrUnavailable
}
return b.Memory.Get(ctx, h)
}
func (b *brokenSessions) Save(ctx context.Context, h []byte, s session.Session) error {
if b.down {
return domain.ErrUnavailable
}
return b.Memory.Save(ctx, h, s)
}
func TestAuth_SessionStoreDownIs503NotAnonymous(t *testing.T) {
store := &brokenSessions{Memory: session.NewMemory()}
r := newRig(t, defaultTestLimits, store, time.Hour)
alice := r.createUser("down_"+randomSuffix(), "Алиса")
store.down = true
resp := r.do(http.MethodGet, "/api/v1/users/me", alice.ID, nil, nil)
expectStatus(t, resp, http.StatusServiceUnavailable)
if e := readError(t, resp); e.Error.Code != CodeUnavailable {
t.Fatalf("code = %q, want %q", e.Error.Code, CodeUnavailable)
}
resp = r.basicLogin(alice.Username, testPassword)
expectStatus(t, resp, http.StatusServiceUnavailable)
resp.Body.Close()
}
+103
View File
@@ -0,0 +1,103 @@
package http
import (
"net/http"
"strconv"
"github.com/labstack/echo/v4"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
type chatsHandler struct {
chats service.ChatsService
}
func (h *chatsHandler) create(c echo.Context) error {
callerID := c.Get(middleware.AuthUserIDKey).(string)
var req dto.CreateChatRequest
if err := decodeJSON(c.Request().Body, &req); err != nil {
return WriteError(c, err)
}
chat, err := h.chats.Create(c.Request().Context(), callerID, req.Title, req.MemberIDs)
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusCreated, toChatResponse(chat))
}
func (h *chatsHandler) get(c echo.Context) error {
callerID := c.Get(middleware.AuthUserIDKey).(string)
chatID := c.Param("chat_id")
chat, err := h.chats.Get(c.Request().Context(), callerID, chatID)
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusOK, toChatResponse(chat))
}
func (h *chatsHandler) list(c echo.Context) error {
callerID := c.Get(middleware.AuthUserIDKey).(string)
limit, cursor, err := parsePageParams(c)
if err != nil {
return WriteError(c, err)
}
page, err := h.chats.List(c.Request().Context(), callerID, cursor, limit)
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusOK, toChatsPage(page))
}
func toChatResponse(ch domain.Chat) dto.ChatResponse {
members := make([]string, len(ch.MemberIDs))
copy(members, ch.MemberIDs)
return dto.ChatResponse{
ID: ch.ID,
Title: ch.Title,
MemberIDs: members,
CreatedAt: dto.NewTimestamp(ch.CreatedAt),
}
}
func toChatsPage(p domain.Page[domain.Chat]) dto.ChatsPageResponse {
items := make([]dto.ChatResponse, 0, len(p.Items))
for _, ch := range p.Items {
items = append(items, toChatResponse(ch))
}
var next *string
if p.NextCursor != "" {
s := p.NextCursor
next = &s
}
return dto.ChatsPageResponse{Items: items, NextCursor: next}
}
func parsePageParams(c echo.Context) (int, string, error) {
q := c.QueryParams()
limit := validate.LimitDefault
if vals, ok := q["limit"]; ok {
n, err := strconv.Atoi(vals[0])
if err != nil {
return 0, "", &validate.Error{Field: "limit", Reason: "must be an integer"}
}
limit = n
}
cursor := ""
if vals, ok := q["cursor"]; ok {
if vals[0] == "" {
return 0, "", &validate.Error{Field: "cursor", Reason: "must not be empty"}
}
cursor = vals[0]
}
return limit, cursor, nil
}
+84
View File
@@ -0,0 +1,84 @@
package http
import (
"fmt"
"net/http"
"sync"
"testing"
)
func TestConcurrency_100MessagesFrom10Clients(t *testing.T) {
const clients = 10
const perClient = 10
const total = clients * perClient
r := newTestRig(t)
users := make([]testUser, clients)
memberIDs := make([]string, clients)
for i := range users {
users[i] = r.createUser(fmt.Sprintf("race_%02d_%s", i, randomSuffix()), fmt.Sprintf("Клиент %d", i))
memberIDs[i] = users[i].ID
}
chat := r.createChat(users[0], "Гонка", memberIDs...)
type result struct {
id, text string
err error
}
results := make(chan result, total)
start := make(chan struct{})
var wg sync.WaitGroup
for i, actor := range users {
wg.Add(1)
go func() {
defer wg.Done()
<-start
for j := 0; j < perClient; j++ {
text := fmt.Sprintf("race-c%02d-m%02d", i, j)
status, msg, body := r.sendRaw(actor, chat.ID, mustJSON(map[string]string{"text": text}))
if status != http.StatusCreated {
results <- result{err: fmt.Errorf("%s: status %d: %s", text, status, body)}
continue
}
results <- result{id: msg.ID, text: msg.Text}
}
}()
}
close(start)
wg.Wait()
close(results)
sentIDs := make(map[string]string, total)
for res := range results {
if res.err != nil {
t.Fatal(res.err)
}
if _, dup := sentIDs[res.id]; dup {
t.Fatalf("сервер выдал один id %s двум сообщениям", res.id)
}
sentIDs[res.id] = res.text
}
if len(sentIDs) != total {
t.Fatalf("подтверждено %d сообщений, ожидалось %d", len(sentIDs), total)
}
history, _ := r.listMessages(users[0], chat.ID, 100)
if len(history) != total {
t.Fatalf("в истории %d сообщений, ожидалось ровно %d", len(history), total)
}
seen := make(map[string]struct{}, total)
for i, m := range history {
if _, dup := seen[m.ID]; dup {
t.Fatalf("id %s встречается в истории дважды", m.ID)
}
seen[m.ID] = struct{}{}
if text, ok := sentIDs[m.ID]; !ok || text != m.Text {
t.Fatalf("сообщение %s (%q) в истории не совпадает с подтверждённым", m.ID, m.Text)
}
if i > 0 && !history[i-1].CreatedAt.Before(m.CreatedAt.Time) {
t.Fatalf("порядок (created_at) нарушен на индексе %d", i)
}
}
t.Logf("%d клиентов × %d сообщений = %d уникальных сообщений в истории, 0 дубликатов",
clients, perClient, total)
}
+54
View File
@@ -0,0 +1,54 @@
package http
import (
"context"
"net/http"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"github.com/labstack/echo/v4"
)
// Optional extension keeps the mandatory proxy contract unchanged.
type directAttachments interface {
InitDirect(context.Context, string, string, service.DirectInput) (service.DirectUpload, error)
CompleteDirect(context.Context, string, string, string) (domain.Attachment, error)
}
func (h *attachmentsHandler) directInit(c echo.Context) error {
svc, ok := h.attachments.(directAttachments)
if !ok {
return WriteError(c, domain.ErrUnavailable)
}
var in service.DirectInput
if err := decodeJSON(c.Request().Body, &in); err != nil {
return WriteError(c, domain.ErrInvalidArgument)
}
out, err := svc.InitDirect(c.Request().Context(), c.Get(middleware.AuthUserIDKey).(string), c.Param("chat_id"), in)
if err != nil {
return WriteError(c, err)
}
c.Response().Header().Set("Cache-Control", "no-store")
return c.JSON(http.StatusCreated, out)
}
func (h *attachmentsHandler) directComplete(c echo.Context) error {
svc, ok := h.attachments.(directAttachments)
if !ok {
return WriteError(c, domain.ErrUnavailable)
}
var in struct {
Token string `json:"token"`
}
if err := decodeJSON(c.Request().Body, &in); err != nil {
return WriteError(c, domain.ErrInvalidArgument)
}
ctx, cancel := context.WithTimeout(c.Request().Context(), transferTimeout)
defer cancel()
att, err := svc.CompleteDirect(ctx, c.Get(middleware.AuthUserIDKey).(string), c.Param("chat_id"), in.Token)
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusCreated, toAttachmentResponse(att))
}
+27
View File
@@ -0,0 +1,27 @@
package dto
// VariantResponse — преобразованная копия. В lab4 вариантов нет, список всегда пуст.
type VariantResponse struct {
Name string `json:"name"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
Width int `json:"width"`
Height int `json:"height"`
SHA256 string `json:"sha256"`
}
// AttachmentResponse намеренно не содержит object key: он внутренний.
type AttachmentResponse struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
OwnerID string `json:"owner_id"`
Filename string `json:"filename"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
SHA256 string `json:"sha256"`
Status string `json:"status"`
Variants []VariantResponse `json:"variants"`
ErrorCode *string `json:"error_code"`
CreatedAt Timestamp `json:"created_at"`
UpdatedAt Timestamp `json:"updated_at"`
}
+18
View File
@@ -0,0 +1,18 @@
package dto
type CreateChatRequest struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
type ChatResponse struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt Timestamp `json:"created_at"`
}
type ChatsPageResponse struct {
Items []ChatResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
+37
View File
@@ -0,0 +1,37 @@
package dto
import (
"encoding/json"
"errors"
)
// AttachmentIDList — необязательное поле: отсутствие равно [], но явный null по контракту неверен.
// Обычный срез принял бы null молча, поэтому разбор свой.
type AttachmentIDList []string
func (l *AttachmentIDList) UnmarshalJSON(data []byte) error {
if string(data) == "null" {
return errors.New("attachment_ids must be an array")
}
return json.Unmarshal(data, (*[]string)(l))
}
type CreateMessageRequest struct {
// Text — указатель: поле обязательно и при наличии вложений, а "" допустим только с ними.
Text *string `json:"text"`
AttachmentIDs AttachmentIDList `json:"attachment_ids"`
}
type MessageResponse struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt Timestamp `json:"created_at"`
AttachmentIDs []string `json:"attachment_ids"`
}
type MessagesPageResponse struct {
Items []MessageResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
+20
View File
@@ -0,0 +1,20 @@
package dto
import "time"
const timestampLayout = "2006-01-02T15:04:05.000000Z"
// Timestamp сериализуется в UTC всегда с 6 цифрами дробной части. Стандартный формат
// time.Time отбрасывает нули в конце (…17.95188Z): это корректный RFC 3339, но такое значение
// не разбирает datetime.fromisoformat в Python 3.9–3.10, на которых идут публичные тесты.
type Timestamp struct {
time.Time
}
func NewTimestamp(t time.Time) Timestamp {
return Timestamp{Time: t}
}
func (t Timestamp) MarshalJSON() ([]byte, error) {
return []byte(`"` + t.UTC().Format(timestampLayout) + `"`), nil
}
@@ -0,0 +1,48 @@
package dto
import (
"encoding/json"
"testing"
"time"
)
func TestTimestampAlwaysHasSixFractionalDigits(t *testing.T) {
moscow := time.FixedZone("MSK", 3*60*60)
cases := []struct {
name string
in time.Time
want string
}{
{"нули в конце", time.Date(2026, 11, 4, 9, 47, 17, 951880000, time.UTC), `"2026-11-04T09:47:17.951880Z"`},
{"без дробной части", time.Date(2026, 11, 4, 9, 47, 17, 0, time.UTC), `"2026-11-04T09:47:17.000000Z"`},
{"шесть цифр", time.Date(2026, 11, 4, 9, 47, 17, 123456000, time.UTC), `"2026-11-04T09:47:17.123456Z"`},
{"наносекунды отбрасываются", time.Date(2026, 11, 4, 9, 47, 17, 123456789, time.UTC), `"2026-11-04T09:47:17.123456Z"`},
{"приводится к UTC", time.Date(2026, 11, 4, 12, 47, 17, 500000000, moscow), `"2026-11-04T09:47:17.500000Z"`},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got, err := json.Marshal(NewTimestamp(c.in))
if err != nil {
t.Fatal(err)
}
if string(got) != c.want {
t.Fatalf("got %s, want %s", got, c.want)
}
})
}
}
func TestTimestampRoundTrip(t *testing.T) {
want := time.Date(2026, 11, 4, 9, 47, 17, 951880000, time.UTC)
data, err := json.Marshal(MessageResponse{CreatedAt: NewTimestamp(want)})
if err != nil {
t.Fatal(err)
}
var got MessageResponse
if err := json.Unmarshal(data, &got); err != nil {
t.Fatal(err)
}
if !got.CreatedAt.Equal(want) {
t.Fatalf("got %s, want %s", got.CreatedAt, want)
}
}
+21
View File
@@ -0,0 +1,21 @@
package dto
type CreateUserRequest struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
type UserResponse struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt Timestamp `json:"created_at"`
}
type SessionResponse struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt Timestamp `json:"expires_at"`
User UserResponse `json:"user"`
}
+83
View File
@@ -0,0 +1,83 @@
package http
import (
"errors"
"net/http"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
"github.com/labstack/echo/v4"
)
const (
CodeInvalidRequest = "invalid_request"
CodeUnauthorized = "unauthorized"
CodeNotFound = "not_found"
CodeConflict = "conflict"
CodePayloadTooLarge = "payload_too_large"
CodeUnsupportedMedia = "unsupported_media_type"
CodeRateLimited = "rate_limited"
CodeUnavailable = "unavailable"
CodeInternalError = "internal_error"
)
type errorBody struct {
Error errorPayload `json:"error"`
}
type errorPayload struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
var (
ErrUnauthorized = errors.New("unauthorized")
ErrUnsupportedMedia = errors.New("unsupported media type")
)
func Classify(err error) (status int, code, message string) {
switch {
case errors.Is(err, domain.ErrIdempotencyConflict):
return http.StatusConflict, CodeConflict, "Idempotency-Key was already used with a different request"
case errors.Is(err, domain.ErrNotFound):
return http.StatusNotFound, CodeNotFound, "Object not found"
case errors.Is(err, domain.ErrConflict):
return http.StatusConflict, CodeConflict, "Resource already exists"
case errors.Is(err, domain.ErrInvalidArgument):
return http.StatusBadRequest, CodeInvalidRequest, "Invalid request arguments"
case errors.Is(err, domain.ErrUnavailable):
return http.StatusServiceUnavailable, CodeUnavailable, "Service temporarily unavailable"
case errors.Is(err, domain.ErrPayloadTooLarge):
return http.StatusRequestEntityTooLarge, CodePayloadTooLarge, "Request body too large"
case errors.Is(err, domain.ErrRateLimited):
return http.StatusTooManyRequests, CodeRateLimited, "Too many concurrent requests"
case errors.Is(err, ErrUnauthorized), errors.Is(err, domain.ErrUnauthorized):
return http.StatusUnauthorized, CodeUnauthorized, "Identification required"
case errors.Is(err, domain.ErrUnsupportedMedia):
return http.StatusUnsupportedMediaType, CodeUnsupportedMedia, "Expected a valid PNG or JPEG image"
case errors.Is(err, ErrUnsupportedMedia):
return http.StatusUnsupportedMediaType, CodeUnsupportedMedia, "Expected Content-Type: application/json"
}
var vErr *validate.Error
if errors.As(err, &vErr) {
return http.StatusBadRequest, CodeInvalidRequest, vErr.Error()
}
return http.StatusInternalServerError, CodeInternalError, "Internal server error"
}
func WriteError(c echo.Context, err error) error {
status, code, msg := Classify(err)
if status == http.StatusTooManyRequests {
c.Response().Header().Set("Retry-After", "1")
}
return c.JSON(status, errorBody{
Error: errorPayload{
Code: code,
Message: msg,
RequestID: c.Response().Header().Get(echo.HeaderXRequestID),
},
})
}
+24
View File
@@ -0,0 +1,24 @@
package http
import (
"net/http"
"github.com/labstack/echo/v4"
)
type healthResponse struct {
Status string `json:"status"`
}
func healthLive(c echo.Context) error {
return c.JSON(http.StatusOK, healthResponse{Status: "ok"})
}
func healthReady(isReady func() bool) echo.HandlerFunc {
return func(c echo.Context) error {
if !isReady() {
return echo.NewHTTPError(http.StatusServiceUnavailable, "Service unavailable")
}
return c.JSON(http.StatusOK, healthResponse{Status: "ok"})
}
}
+358
View File
@@ -0,0 +1,358 @@
package http
import (
"bytes"
"encoding/json"
"fmt"
"io"
"log/slog"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync"
"testing"
"time"
"github.com/google/uuid"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/password"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/session"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
)
type testRig struct {
t *testing.T
server *httptest.Server
srv *Server
memory *store.Memory
objects *objectstore.Memory
sessions session.Store
client *http.Client
mu sync.Mutex
tokens map[string]string
}
func newTestRig(t *testing.T) *testRig {
return newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: 1 << 20,
MaxInFlight: 256,
MaxMessagesGlobal: 100000,
MaxHeapBytes: 1 << 40,
})
}
func newTestRigWithLimits(t *testing.T, limits config.Limits) *testRig {
t.Helper()
return newRig(t, limits, session.NewMemory(), time.Hour)
}
const testInstanceID = "test-instance"
var defaultTestLimits = config.Limits{
MaxBodyBytes: 1 << 20,
MaxInFlight: 256,
MaxMessagesGlobal: 100000,
MaxHeapBytes: 1 << 40,
}
func newRig(t *testing.T, limits config.Limits, sessions session.Store, ttl time.Duration) *testRig {
t.Helper()
cfg := &config.Config{
Env: "test",
Version: "test",
InstanceID: testInstanceID,
HTTP: config.HTTP{
Addr: "127.0.0.1:0",
ReadTimeoutMs: 10000,
WriteTimeoutMs: 10000,
IdleTimeoutMs: 60000,
ShutdownTimeoutMs: 1000,
},
Limits: limits,
}
logger := slog.New(slog.NewTextHandler(io.Discard, nil))
memory := store.NewWithLimit(limits.MaxMessagesGlobal)
hasher := password.NewHasher(testHashParams, 8)
auth, err := service.NewAuth(memory, sessions, hasher, ttl)
if err != nil {
t.Fatal(err)
}
objects := objectstore.NewMemory()
srv := NewServer(Deps{
Config: cfg,
Logger: logger,
Store: memory,
Auth: auth,
Users: service.NewUsers(memory, hasher),
Chats: service.NewChats(memory),
Messages: service.NewMessages(memory),
Attachments: service.NewAttachments(memory, objects, service.AttachmentLimits{
MaxUploadBytes: testMaxUploadBytes,
MaxImagePixels: testMaxImagePixels,
MaxConcurrentUploads: testMaxConcurrentUploads,
}, logger),
})
ts := httptest.NewServer(srv.e)
t.Cleanup(ts.Close)
return &testRig{
t: t,
server: ts,
srv: srv,
memory: memory,
objects: objects,
sessions: sessions,
client: &http.Client{Timeout: 10 * time.Second},
tokens: make(map[string]string),
}
}
type testUser struct {
ID string
Username string
DisplayName string
}
type errorResp struct {
Error struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
} `json:"error"`
}
func (r *testRig) do(method, path string, actorID string, headers map[string]string, body io.Reader) *http.Response {
r.t.Helper()
req, err := http.NewRequest(method, r.server.URL+path, body)
if err != nil {
r.t.Fatalf("new request %s %s: %v", method, path, err)
}
req.Header.Set("Accept", "application/json")
r.setAuth(req, actorID)
if method == http.MethodPost && strings.HasSuffix(path, "/messages") {
req.Header.Set("Idempotency-Key", uuid.NewString())
}
for k, v := range headers {
req.Header.Set(k, v)
}
resp, err := r.client.Do(req)
if err != nil {
r.t.Fatalf("do %s %s: %v", method, path, err)
}
return resp
}
func (r *testRig) doJSON(method, path string, actorID string, payload any) *http.Response {
r.t.Helper()
var body io.Reader
if payload != nil {
body = bytes.NewReader(mustJSON(payload))
}
return r.do(method, path, actorID, map[string]string{"Content-Type": "application/json"}, body)
}
func readJSON(t *testing.T, resp *http.Response, dst any) {
t.Helper()
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatalf("read body: %v", err)
}
if len(data) == 0 {
return
}
if err := json.Unmarshal(data, dst); err != nil {
t.Fatalf("decode body (%s): %v", string(data), err)
}
}
func readError(t *testing.T, resp *http.Response) errorResp {
t.Helper()
var e errorResp
readJSON(t, resp, &e)
return e
}
func expectStatus(t *testing.T, resp *http.Response, want int) {
t.Helper()
if resp.StatusCode != want {
data, _ := io.ReadAll(resp.Body)
resp.Body.Close()
t.Fatalf("expected status %d, got %d; body=%s", want, resp.StatusCode, string(data))
}
}
const testPassword = "test-password-123"
var testHashParams = password.Params{MemoryKiB: 64, Iterations: 1, Parallelism: 1, SaltLen: 16, KeyLen: 32}
func (r *testRig) createUser(username, displayName string) testUser {
r.t.Helper()
resp := r.doJSON(http.MethodPost, "/api/v1/users", "", dto.CreateUserRequest{
Username: username,
DisplayName: displayName,
Password: testPassword,
})
expectStatus(r.t, resp, http.StatusCreated)
var u dto.UserResponse
readJSON(r.t, resp, &u)
s := r.login(username, testPassword)
r.mu.Lock()
r.tokens[u.ID] = s.Token
r.mu.Unlock()
return testUser{ID: u.ID, Username: u.Username, DisplayName: u.DisplayName}
}
// login входит по Basic и возвращает сессию; ожидает 201.
func (r *testRig) login(username, pw string) dto.SessionResponse {
r.t.Helper()
resp := r.basicLogin(username, pw)
expectStatus(r.t, resp, http.StatusCreated)
var s dto.SessionResponse
readJSON(r.t, resp, &s)
return s
}
func (r *testRig) basicLogin(username, pw string) *http.Response {
r.t.Helper()
req, _ := http.NewRequest(http.MethodPost, r.server.URL+"/api/v1/auth/sessions", nil)
req.SetBasicAuth(username, pw)
resp, err := r.client.Do(req)
if err != nil {
r.t.Fatalf("login: %v", err)
}
return resp
}
func (r *testRig) setAuth(req *http.Request, actorID string) {
if actorID == "" {
return
}
r.mu.Lock()
tok, ok := r.tokens[strings.ToLower(actorID)]
r.mu.Unlock()
if !ok {
tok = "unknown-" + actorID
}
req.Header.Set("Authorization", "Bearer "+tok)
}
func (r *testRig) createChat(owner testUser, title string, members ...string) dto.ChatResponse {
r.t.Helper()
resp := r.doJSON(http.MethodPost, "/api/v1/chats", owner.ID, dto.CreateChatRequest{
Title: title,
MemberIDs: members,
})
expectStatus(r.t, resp, http.StatusCreated)
var ch dto.ChatResponse
readJSON(r.t, resp, &ch)
return ch
}
func (r *testRig) sendMessage(actor testUser, chatID, text string) (*http.Response, dto.MessageResponse) {
r.t.Helper()
resp := r.doJSON(http.MethodPost, "/api/v1/chats/"+chatID+"/messages", actor.ID, textMessage(text))
if resp.StatusCode != http.StatusCreated {
return resp, dto.MessageResponse{}
}
var m dto.MessageResponse
readJSON(r.t, resp, &m)
return resp, m
}
func (r *testRig) sendRaw(actor testUser, chatID string, body []byte) (int, dto.MessageResponse, []byte) {
r.t.Helper()
resp := r.do(http.MethodPost, "/api/v1/chats/"+chatID+"/messages", actor.ID,
map[string]string{"Content-Type": "application/json"}, bytes.NewReader(body))
defer resp.Body.Close()
data, _ := io.ReadAll(resp.Body)
if resp.StatusCode != http.StatusCreated {
return resp.StatusCode, dto.MessageResponse{}, data
}
var m dto.MessageResponse
if err := json.Unmarshal(data, &m); err != nil {
r.t.Fatalf("decode message: %v", err)
}
return resp.StatusCode, m, data
}
func (r *testRig) send(actor testUser, chatID, text string) (int, dto.MessageResponse) {
r.t.Helper()
status, msg, _ := r.sendRaw(actor, chatID, mustJSON(textMessage(text)))
return status, msg
}
func (r *testRig) listMessages(actor testUser, chatID string, pageSize int) ([]dto.MessageResponse, int) {
r.t.Helper()
collected := []dto.MessageResponse{}
cursor := ""
for pages := 1; ; pages++ {
q := fmt.Sprintf("/api/v1/chats/%s/messages?limit=%d", chatID, pageSize)
if cursor != "" {
q += "&cursor=" + url.QueryEscape(cursor)
}
resp := r.do(http.MethodGet, q, actor.ID, nil, nil)
expectStatus(r.t, resp, http.StatusOK)
var page dto.MessagesPageResponse
readJSON(r.t, resp, &page)
collected = append(collected, page.Items...)
if page.NextCursor == nil {
return collected, pages
}
cursor = *page.NextCursor
if pages > 100_000 {
r.t.Fatalf("пагинация не сходится: next_cursor не исчезает")
}
}
}
func bootstrap(r *testRig) (alice, bob, eve testUser, chat dto.ChatResponse) {
alice = r.createUser("own_alice_"+randomSuffix(), "Алиса")
bob = r.createUser("own_bob_"+randomSuffix(), "Боб")
eve = r.createUser("own_eve_"+randomSuffix(), "Ева")
chat = r.createChat(alice, "Контрактный тест", alice.ID, bob.ID)
return
}
var suffixMu sync.Mutex
var suffixSeq int
func randomSuffix() string {
suffixMu.Lock()
defer suffixMu.Unlock()
suffixSeq++
return fmt.Sprintf("%09d_%d", time.Now().UnixNano()%1_000_000_000, suffixSeq)
}
func mustJSON(v any) []byte {
data, err := json.Marshal(v)
if err != nil {
panic(err)
}
return data
}
func extractErrorCode(t *testing.T, data []byte) string {
t.Helper()
var e errorResp
if err := json.Unmarshal(data, &e); err != nil {
t.Fatalf("decode error body: %v; raw=%s", err, string(data))
}
return e.Error.Code
}
const (
testMaxUploadBytes = 2 << 20
testMaxImagePixels = 10_000
testMaxConcurrentUploads = 4
)
// textMessage — тело POST сообщения без вложений.
func textMessage(text string) map[string]string {
return map[string]string{"text": text}
}
+119
View File
@@ -0,0 +1,119 @@
package http
import (
"bytes"
"io"
"net/http"
"sync"
"testing"
"github.com/google/uuid"
)
func (r *testRig) postKeyed(actorID, chatID, key, body string) (int, []byte) {
r.t.Helper()
resp := r.do(http.MethodPost, "/api/v1/chats/"+chatID+"/messages", actorID,
map[string]string{"Content-Type": "application/json", "Idempotency-Key": key},
bytes.NewReader([]byte(body)))
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
if err != nil {
r.t.Fatal(err)
}
return resp.StatusCode, data
}
func TestIdempotency_ReplayReturnsSameBody(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("alice_"+randomSuffix(), "Alice")
chat := r.createChat(alice, "replay", alice.ID)
key := uuid.NewString()
code, first := r.postKeyed(alice.ID, chat.ID, key, `{"text":"привет"}`)
if code != http.StatusCreated {
t.Fatalf("first: status = %d, body = %s", code, first)
}
// Иное форматирование JSON — тот же запрос.
code, replay := r.postKeyed(alice.ID, chat.ID, key, "{ \"text\" : \"привет\" }")
if code != http.StatusCreated {
t.Fatalf("replay: status = %d, body = %s", code, replay)
}
if !bytes.Equal(first, replay) {
t.Errorf("replay differs:\n%s\n%s", first, replay)
}
if items, _ := r.listMessages(alice, chat.ID, 100); len(items) != 1 {
t.Errorf("messages = %d, want 1", len(items))
}
}
func TestIdempotency_DifferentBodyConflicts(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("alice_"+randomSuffix(), "Alice")
chat := r.createChat(alice, "conflict", alice.ID)
key := uuid.NewString()
if code, body := r.postKeyed(alice.ID, chat.ID, key, `{"text":"раз"}`); code != http.StatusCreated {
t.Fatalf("first: status = %d, body = %s", code, body)
}
if code, body := r.postKeyed(alice.ID, chat.ID, key, `{"text":"два"}`); code != http.StatusConflict {
t.Fatalf("conflict: status = %d, body = %s", code, body)
}
if items, _ := r.listMessages(alice, chat.ID, 100); len(items) != 1 {
t.Errorf("messages = %d, want 1", len(items))
}
}
func TestIdempotency_ScopeAndAccess(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("alice_"+randomSuffix(), "Alice")
bob := r.createUser("bob_"+randomSuffix(), "Bob")
eve := r.createUser("eve_"+randomSuffix(), "Eve")
chat := r.createChat(alice, "shared", alice.ID, bob.ID)
other := r.createChat(alice, "other", alice.ID)
key := uuid.NewString()
if code, body := r.postKeyed(alice.ID, chat.ID, key, `{"text":"от alice"}`); code != http.StatusCreated {
t.Fatalf("alice: status = %d, body = %s", code, body)
}
if code, body := r.postKeyed(bob.ID, chat.ID, key, `{"text":"от bob"}`); code != http.StatusCreated {
t.Fatalf("bob: status = %d, body = %s", code, body)
}
if code, body := r.postKeyed(alice.ID, other.ID, key, `{"text":"другой чат"}`); code != http.StatusCreated {
t.Fatalf("other chat: status = %d, body = %s", code, body)
}
if code, body := r.postKeyed(eve.ID, chat.ID, key, `{"text":"от alice"}`); code != http.StatusNotFound {
t.Fatalf("stranger: status = %d, body = %s", code, body)
}
}
func TestIdempotency_ConcurrentCreatesOne(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("alice_"+randomSuffix(), "Alice")
chat := r.createChat(alice, "race", alice.ID)
key := uuid.NewString()
const workers = 20
bodies := make([][]byte, workers)
codes := make([]int, workers)
var wg sync.WaitGroup
for i := range workers {
wg.Add(1)
go func() {
defer wg.Done()
codes[i], bodies[i] = r.postKeyed(alice.ID, chat.ID, key, `{"text":"гонка"}`)
}()
}
wg.Wait()
for i := range workers {
if codes[i] != http.StatusCreated {
t.Fatalf("worker %d: status = %d, body = %s", i, codes[i], bodies[i])
}
if !bytes.Equal(bodies[i], bodies[0]) {
t.Errorf("worker %d: body differs", i)
}
}
if items, _ := r.listMessages(alice, chat.ID, 100); len(items) != 1 {
t.Errorf("messages = %d, want 1", len(items))
}
}
+121
View File
@@ -0,0 +1,121 @@
package http
import (
"bytes"
"net/http"
"strings"
"testing"
"time"
"github.com/google/uuid"
)
func TestInstanceID_OnEveryResponse(t *testing.T) {
r := newTestRig(t)
cases := []struct {
name, method, path string
want int
}{
{"live", http.MethodGet, "/health/live", http.StatusOK},
{"ready", http.MethodGet, "/health/ready", http.StatusOK},
{"unauthorized", http.MethodGet, "/api/v1/users/me", http.StatusUnauthorized},
{"unknown route", http.MethodGet, "/api/v1/nope", http.StatusNotFound},
{"wrong method", http.MethodPatch, "/api/v1/users", http.StatusMethodNotAllowed},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
resp := r.do(tc.method, tc.path, "", nil, nil)
defer resp.Body.Close()
if resp.StatusCode != tc.want {
t.Fatalf("status = %d, want %d", resp.StatusCode, tc.want)
}
if got := resp.Header.Get("X-Instance-Id"); got != testInstanceID {
t.Errorf("X-Instance-Id = %q, want %q", got, testInstanceID)
}
})
}
}
func TestIdempotencyKey_Validation(t *testing.T) {
r := newTestRig(t)
alice := r.createUser("alice_key", "Alice")
chat := r.createChat(alice, "keys", alice.ID)
url := r.server.URL + "/api/v1/chats/" + chat.ID + "/messages"
post := func(setKey func(http.Header)) int {
t.Helper()
req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader([]byte(`{"text":"hi"}`)))
if err != nil {
t.Fatal(err)
}
req.Header.Set("Content-Type", "application/json")
r.setAuth(req, alice.ID)
setKey(req.Header)
resp, err := r.client.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
return resp.StatusCode
}
withKey := func(key string) func(http.Header) {
return func(h http.Header) { h.Set("Idempotency-Key", key) }
}
if got := post(func(http.Header) {}); got != http.StatusBadRequest {
t.Errorf("missing key: status = %d, want 400", got)
}
for name, key := range map[string]string{
"empty": "",
"too long": strings.Repeat("a", 129),
"space": "a b",
"unicode": "ключ",
"slash": "a/b",
} {
if got := post(withKey(key)); got != http.StatusBadRequest {
t.Errorf("%s: status = %d, want 400", name, got)
}
}
for name, key := range map[string]string{
"all allowed chars": "aZ09._:-",
"max length": strings.Repeat("a", 128),
"uuid": uuid.NewString(),
} {
if got := post(withKey(key)); got != http.StatusCreated {
t.Errorf("%s: status = %d, want 201", name, got)
}
}
}
func TestDrain_NotReadyButStillServing(t *testing.T) {
r := newTestRig(t)
status := func(path string) int {
t.Helper()
resp := r.do(http.MethodGet, path, "", nil, nil)
defer resp.Body.Close()
return resp.StatusCode
}
if got := status("/health/ready"); got != http.StatusOK {
t.Fatalf("ready before drain = %d", got)
}
done := make(chan struct{})
go func() {
defer close(done)
r.srv.Drain(500 * time.Millisecond)
}()
deadline := time.Now().Add(400 * time.Millisecond)
for status("/health/ready") != http.StatusServiceUnavailable {
if time.Now().After(deadline) {
t.Fatal("readiness did not become 503 during drain")
}
time.Sleep(5 * time.Millisecond)
}
if got := status("/health/live"); got != http.StatusOK {
t.Errorf("live during drain = %d, want 200", got)
}
if got := status("/api/v1/users/me"); got != http.StatusUnauthorized {
t.Errorf("API during drain = %d, want 401: запросы должны обслуживаться", got)
}
<-done
}
+318
View File
@@ -0,0 +1,318 @@
package http
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/google/uuid"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/session"
)
func TestLimits_PayloadTooLarge(t *testing.T) {
r := newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: 256,
MaxInFlight: 16,
MaxMessagesGlobal: 100,
MaxHeapBytes: 1 << 40,
})
alice := r.createUser("a_"+randomSuffix(), "Алиса")
bob := r.createUser("b_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
ok, _, _ := r.sendRaw(alice, chat.ID, mustJSON(textMessage("ok")))
if ok != http.StatusCreated {
t.Fatalf("baseline send expected 201, got %d", ok)
}
stored := r.memory.MessagesTotal()
if stored != 1 {
t.Fatalf("baseline total expected 1, got %d", stored)
}
big := strings.Repeat("x", 512)
status, _, body := r.sendRaw(alice, chat.ID, mustJSON(textMessage(big)))
if status != http.StatusRequestEntityTooLarge {
t.Fatalf("expected 413 by content-length, got %d body=%s", status, string(body))
}
code := extractErrorCode(t, body)
if code != CodePayloadTooLarge {
t.Fatalf("expected code %q, got %q", CodePayloadTooLarge, code)
}
if got := r.memory.MessagesTotal(); got != stored {
t.Fatalf("после 413 store изменился: было %d, стало %d", stored, got)
}
}
func TestLimits_PayloadBoundaries(t *testing.T) {
const limit = 256
r := newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: limit,
MaxInFlight: 16,
MaxMessagesGlobal: 100,
MaxHeapBytes: 1 << 40,
})
alice := r.createUser("a_"+randomSuffix(), "Алиса")
bob := r.createUser("b_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
exact := []byte(`{"text":"` + strings.Repeat("x", limit-len(`{"text":""}`)) + `"}`)
if len(exact) != limit {
t.Fatalf("test bug: body is %d bytes, want %d", len(exact), limit)
}
post := func(body io.Reader) (int, []byte) {
req, _ := http.NewRequest(http.MethodPost,
r.server.URL+"/api/v1/chats/"+chat.ID+"/messages", body)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", uuid.NewString())
r.setAuth(req, alice.ID)
resp, err := r.client.Do(req)
if err != nil {
t.Fatalf("send: %v", err)
}
defer resp.Body.Close()
data, _ := io.ReadAll(resp.Body)
return resp.StatusCode, data
}
chunked := func(b []byte) io.Reader { return io.MultiReader(bytes.NewReader(b)) }
if status, body := post(bytes.NewReader(exact)); status != http.StatusCreated {
t.Fatalf("body ровно %d байт с Content-Length: expected 201, got %d body=%s", limit, status, body)
}
if status, body := post(chunked(exact)); status != http.StatusCreated {
t.Fatalf("body ровно %d байт без Content-Length: expected 201, got %d body=%s", limit, status, body)
}
stored := r.memory.MessagesTotal()
over := []byte(`{"text":"` + strings.Repeat("x", limit) + `"}`)
status, body := post(chunked(over))
if status != http.StatusRequestEntityTooLarge {
t.Fatalf("body %d байт без Content-Length: expected 413, got %d body=%s", len(over), status, body)
}
if code := extractErrorCode(t, body); code != CodePayloadTooLarge {
t.Fatalf("expected code %q, got %q", CodePayloadTooLarge, code)
}
if got := r.memory.MessagesTotal(); got != stored {
t.Fatalf("после 413 store изменился: было %d, стало %d", stored, got)
}
}
type slowSessions struct {
*session.Memory
delay atomic.Int64
}
func (s *slowSessions) Get(ctx context.Context, h []byte) (session.Session, error) {
time.Sleep(time.Duration(s.delay.Load()))
return s.Memory.Get(ctx, h)
}
func TestLimits_RateLimited(t *testing.T) {
sessions := &slowSessions{Memory: session.NewMemory()}
r := newRig(t, config.Limits{
MaxBodyBytes: 1 << 16,
MaxInFlight: 2,
MaxMessagesGlobal: 10000,
MaxHeapBytes: 1 << 40,
}, sessions, time.Hour)
alice := r.createUser("c_"+randomSuffix(), "Алиса")
bob := r.createUser("d_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
sessions.delay.Store(int64(20 * time.Millisecond))
const total = 50
var (
ok atomic.Int32
throttled atomic.Int32
errs atomic.Int32
wg sync.WaitGroup
)
wg.Add(total)
start := make(chan struct{})
for i := 0; i < total; i++ {
i := i
go func() {
defer wg.Done()
<-start
client := &http.Client{Timeout: 10 * time.Second}
body, _ := json.Marshal(textMessage(fmt.Sprintf("flood-%d", i)))
req, _ := http.NewRequest(http.MethodPost,
r.server.URL+"/api/v1/chats/"+chat.ID+"/messages",
bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", uuid.NewString())
r.setAuth(req, alice.ID)
resp, err := client.Do(req)
if err != nil {
errs.Add(1)
return
}
switch resp.StatusCode {
case http.StatusCreated:
ok.Add(1)
case http.StatusTooManyRequests:
throttled.Add(1)
if resp.Header.Get("Retry-After") != "1" {
errs.Add(1)
}
default:
errs.Add(1)
}
resp.Body.Close()
}()
}
close(start)
wg.Wait()
sessions.delay.Store(0)
if errs.Load() != 0 {
t.Fatalf("неожиданные ошибки/статусы под нагрузкой: %d", errs.Load())
}
if throttled.Load() == 0 {
t.Fatalf("ожидался хотя бы один 429 при maxInFlight=2 и %d параллельных запросах", total)
}
if ok.Load() == 0 {
t.Fatalf("ни одного 201 — лимит не пропускает валидный трафик")
}
if int(ok.Load()+throttled.Load()) != total {
t.Fatalf("ok=%d throttled=%d не покрывают total=%d", ok.Load(), throttled.Load(), total)
}
deadline := time.Now().Add(3 * time.Second)
for time.Now().Before(deadline) {
status, _ := r.send(alice, chat.ID, "после-пика "+randomSuffix())
if status == http.StatusCreated {
break
}
time.Sleep(20 * time.Millisecond)
}
status, _ := r.send(alice, chat.ID, "после-пика-2 "+randomSuffix())
if status != http.StatusCreated {
t.Fatalf("после отступления нагрузки сервис не восстановился: %d", status)
}
collected, _ := r.listMessages(alice, chat.ID, 100)
if int32(len(collected)) < ok.Load() {
t.Fatalf("часть подтверждённых сообщений потеряна: подтверждено %d, в истории %d",
ok.Load(), len(collected))
}
t.Logf("ok=%d throttled=%d errors=%d; history=%d", ok.Load(), throttled.Load(), errs.Load(), len(collected))
}
func TestLimits_MessageQuota(t *testing.T) {
const quota = 10
r := newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: 1 << 16,
MaxInFlight: 16,
MaxMessagesGlobal: quota,
MaxHeapBytes: 1 << 40,
})
alice := r.createUser("e_"+randomSuffix(), "Алиса")
bob := r.createUser("f_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
var saved []string
for i := 0; i < quota; i++ {
status, msg := r.send(alice, chat.ID, fmt.Sprintf("saved-%02d", i))
if status != http.StatusCreated {
t.Fatalf("send %d: expected 201, got %d", i, status)
}
saved = append(saved, msg.ID)
}
status, _, body := r.sendRaw(alice, chat.ID, mustJSON(textMessage("overflow")))
if status != http.StatusServiceUnavailable {
t.Fatalf("expected 503 after quota exhausted, got %d body=%s", status, string(body))
}
if code := extractErrorCode(t, body); code != CodeUnavailable {
t.Fatalf("expected code %q, got %q", CodeUnavailable, code)
}
collected, _ := r.listMessages(alice, chat.ID, 100)
if len(collected) != quota {
t.Fatalf("после 503 история чата %d, ожидалось %d", len(collected), quota)
}
gotIDs := make(map[string]struct{}, len(collected))
for _, m := range collected {
gotIDs[m.ID] = struct{}{}
}
for _, id := range saved {
if _, ok := gotIDs[id]; !ok {
t.Fatalf("подтверждённое сообщение %s исчезло из истории", id)
}
}
for i := 0; i < 5; i++ {
s, _, _ := r.sendRaw(alice, chat.ID, mustJSON(textMessage("still-over")))
if s != http.StatusServiceUnavailable {
t.Fatalf("повторный 503 ожидался, получен %d", s)
}
}
req, _ := http.NewRequest(http.MethodGet, r.server.URL+"/health/live", nil)
resp, err := r.client.Do(req)
if err != nil {
t.Fatalf("health/live: %v", err)
}
resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("health/live под перегрузкой: ожидали 200, получили %d", resp.StatusCode)
}
}
func TestLimits_NoSilentLoss(t *testing.T) {
const quota = 20
r := newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: 1 << 16,
MaxInFlight: 8,
MaxMessagesGlobal: quota,
MaxHeapBytes: 1 << 40,
})
alice := r.createUser("g_"+randomSuffix(), "Алиса")
bob := r.createUser("h_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
const attempts = quota * 3
acked := make([]string, 0, quota)
codes := make(map[int]int)
for i := 0; i < attempts; i++ {
status, msg, _ := r.sendRaw(alice, chat.ID, mustJSON(textMessage(fmt.Sprintf("loss-%03d", i))))
codes[status]++
if status == http.StatusCreated {
acked = append(acked, msg.ID)
}
}
if len(acked) != quota {
t.Fatalf("ожидалось ровно %d подтверждённых записей, получено %d; codes=%v", quota, len(acked), codes)
}
if codes[http.StatusServiceUnavailable] == 0 {
t.Fatalf("ни одного 503 — лимит не сработал")
}
collected, _ := r.listMessages(alice, chat.ID, 100)
gotIDs := make(map[string]struct{}, len(collected))
for _, m := range collected {
gotIDs[m.ID] = struct{}{}
}
for _, id := range acked {
if _, ok := gotIDs[id]; !ok {
t.Fatalf("подтверждённое сообщение %s исчезло из истории — незаметная потеря данных", id)
}
}
if len(collected) != len(acked) {
t.Fatalf("история чата содержит %d сообщений, подтверждено %d — скрытое отличие",
len(collected), len(acked))
}
t.Logf("codes=%v acked=%d history=%d", codes, len(acked), len(collected))
}
+80
View File
@@ -0,0 +1,80 @@
package http
import (
"net/http"
"github.com/labstack/echo/v4"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
const headerIdempotencyKey = "Idempotency-Key"
type messagesHandler struct {
messages service.MessagesService
}
func (h *messagesHandler) send(c echo.Context) error {
callerID := c.Get(middleware.AuthUserIDKey).(string)
chatID := c.Param("chat_id")
var req dto.CreateMessageRequest
if err := decodeJSON(c.Request().Body, &req); err != nil {
return WriteError(c, err)
}
if req.Text == nil {
return WriteError(c, &validate.Error{Field: "text", Reason: "is required"})
}
msg, err := h.messages.Send(c.Request().Context(), callerID, chatID, c.Request().Header.Get(headerIdempotencyKey), *req.Text, req.AttachmentIDs)
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusCreated, toMessageResponse(msg))
}
func (h *messagesHandler) list(c echo.Context) error {
callerID := c.Get(middleware.AuthUserIDKey).(string)
chatID := c.Param("chat_id")
limit, cursor, err := parsePageParams(c)
if err != nil {
return WriteError(c, err)
}
page, err := h.messages.List(c.Request().Context(), callerID, chatID, cursor, limit)
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusOK, toMessagesPage(page))
}
func toMessageResponse(m domain.Message) dto.MessageResponse {
return dto.MessageResponse{
ID: m.ID,
ChatID: m.ChatID,
SenderID: m.AuthorID,
Text: m.Text,
CreatedAt: dto.NewTimestamp(m.CreatedAt),
// Без вложений в JSON должен быть [], а не null.
AttachmentIDs: append([]string{}, m.AttachmentIDs...),
}
}
func toMessagesPage(p domain.Page[domain.Message]) dto.MessagesPageResponse {
items := make([]dto.MessageResponse, 0, len(p.Items))
for _, m := range p.Items {
items = append(items, toMessageResponse(m))
}
var next *string
if p.NextCursor != "" {
s := p.NextCursor
next = &s
}
return dto.MessagesPageResponse{Items: items, NextCursor: next}
}
+61
View File
@@ -0,0 +1,61 @@
package middleware
import (
"context"
"errors"
"net/http"
"strings"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"github.com/labstack/echo/v4"
)
const AuthTokenKey = "auth_token"
const (
BearerChallenge = `Bearer realm="messenger"`
BasicChallenge = `Basic realm="messenger", charset="UTF-8"`
)
type Authenticator interface {
Authenticate(ctx context.Context, token string) (userID string, err error)
}
func Bearer(auth Authenticator) echo.MiddlewareFunc {
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
tok, ok := BearerToken(c.Request().Header.Get(echo.HeaderAuthorization))
if !ok {
return unauthorized(c, BearerChallenge, "Bearer token required")
}
userID, err := auth.Authenticate(c.Request().Context(), tok)
if err != nil {
if errors.Is(err, domain.ErrUnauthorized) {
return unauthorized(c, BearerChallenge, "Invalid or expired session")
}
return err
}
c.Set(AuthUserIDKey, userID)
c.Set(AuthTokenKey, tok)
return next(c)
}
}
}
func BearerToken(header string) (string, bool) {
scheme, tok, found := strings.Cut(header, " ")
if !found || !strings.EqualFold(scheme, "Bearer") {
return "", false
}
tok = strings.TrimSpace(tok)
return tok, tok != ""
}
func unauthorized(c echo.Context, challenge, msg string) error {
c.Response().Header().Set(echo.HeaderWWWAuthenticate, challenge)
return echo.NewHTTPError(http.StatusUnauthorized, msg)
}
func Unauthorized(c echo.Context, challenge, msg string) error {
return unauthorized(c, challenge, msg)
}
@@ -0,0 +1,42 @@
package middleware
import (
"mime"
"net/http"
"strings"
"github.com/labstack/echo/v4"
)
func ContentType() echo.MiddlewareFunc {
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
if !methodHasBody(c.Request().Method) {
return next(c)
}
if !isApplicationJSON(c.Request().Header.Get(echo.HeaderContentType)) {
return echo.NewHTTPError(http.StatusUnsupportedMediaType, "Expected Content-Type: application/json")
}
return next(c)
}
}
}
func methodHasBody(method string) bool {
switch method {
case http.MethodPost, http.MethodPut, http.MethodPatch:
return true
}
return false
}
func isApplicationJSON(ct string) bool {
if ct == "" {
return false
}
mediatype, _, err := mime.ParseMediaType(ct)
if err != nil {
return false
}
return strings.EqualFold(mediatype, "application/json")
}
@@ -0,0 +1,14 @@
package middleware
import "github.com/labstack/echo/v4"
const HeaderInstanceID = "X-Instance-Id"
func InstanceID(id string) echo.MiddlewareFunc {
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
c.Response().Header().Set(HeaderInstanceID, id)
return next(c)
}
}
}
+112
View File
@@ -0,0 +1,112 @@
package middleware
import (
"io"
"runtime"
"slices"
"sync/atomic"
"time"
"github.com/labstack/echo/v4"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
// BodyLimit ограничивает тело запроса. Маршруты из exemptRoutes применяют собственный лимит.
func BodyLimit(maxBytes int64, exemptRoutes ...string) echo.MiddlewareFunc {
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
if !methodHasBody(c.Request().Method) || slices.Contains(exemptRoutes, c.Path()) {
return next(c)
}
if cl := c.Request().ContentLength; cl > maxBytes {
return domain.ErrPayloadTooLarge
}
c.Request().Body = &limitedBody{
raw: c.Request().Body,
maxLeft: maxBytes,
}
return next(c)
}
}
}
type limitedBody struct {
raw io.ReadCloser
maxLeft int64
}
func (b *limitedBody) Read(p []byte) (int, error) {
if int64(len(p)) > b.maxLeft+1 {
p = p[:b.maxLeft+1]
}
n, err := b.raw.Read(p)
b.maxLeft -= int64(n)
if b.maxLeft < 0 {
return n, domain.ErrPayloadTooLarge
}
return n, err
}
func (b *limitedBody) Close() error {
return b.raw.Close()
}
func InFlight(maxInFlight int) echo.MiddlewareFunc {
sem := make(chan struct{}, maxInFlight)
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
if isHealthPath(c.Request().URL.Path) {
return next(c)
}
select {
case sem <- struct{}{}:
defer func() { <-sem }()
return next(c)
default:
return domain.ErrRateLimited
}
}
}
}
func MemoryGuard(maxHeapBytes uint64, poll time.Duration) echo.MiddlewareFunc {
var sample atomic.Uint64
readOnce := func() {
var m runtime.MemStats
runtime.ReadMemStats(&m)
if m.HeapInuse > maxHeapBytes {
runtime.GC()
runtime.ReadMemStats(&m)
}
sample.Store(m.HeapInuse)
}
readOnce()
if poll > 0 {
go func() {
t := time.NewTicker(poll)
defer t.Stop()
for range t.C {
readOnce()
}
}()
}
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
if !methodHasBody(c.Request().Method) || isHealthPath(c.Request().URL.Path) {
return next(c)
}
if sample.Load() > maxHeapBytes {
return domain.ErrUnavailable
}
return next(c)
}
}
}
func isHealthPath(path string) bool {
return path == "/health/live" || path == "/health/ready"
}
@@ -0,0 +1,48 @@
package middleware
import (
"log/slog"
"time"
"github.com/labstack/echo/v4"
"go.opentelemetry.io/otel/trace"
)
const AuthUserIDKey = "caller_id"
func Logger(logger *slog.Logger) echo.MiddlewareFunc {
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
start := time.Now()
if err := next(c); err != nil {
c.Error(err)
}
status := c.Response().Status
rid, _ := c.Get(RequestIDKey).(string)
sc := trace.SpanContextFromContext(c.Request().Context())
attrs := []slog.Attr{
slog.String("request_id", rid),
slog.String("method", c.Request().Method),
slog.String("route", c.Path()),
slog.Int("status", status),
slog.Int64("duration_ms", time.Since(start).Milliseconds()),
slog.String("event", "http.request"),
slog.String("trace_id", sc.TraceID().String()),
slog.String("span_id", sc.SpanID().String()),
}
level := slog.LevelInfo
switch {
case status >= 500:
level = slog.LevelError
case status >= 400:
level = slog.LevelWarn
}
logger.LogAttrs(c.Request().Context(), level, "http request", attrs...)
return nil
}
}
}
@@ -0,0 +1,32 @@
package middleware
import (
"log/slog"
"net/http"
"runtime/debug"
"github.com/labstack/echo/v4"
)
func Recover(logger *slog.Logger) echo.MiddlewareFunc {
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) (err error) {
defer func() {
r := recover()
if r == nil {
return
}
rid, _ := c.Get(RequestIDKey).(string)
logger.Error("panic recovered",
slog.String("request_id", rid),
slog.String("method", c.Request().Method),
slog.String("path", c.Request().URL.Path),
slog.Any("panic", r),
slog.String("stack", string(debug.Stack())),
)
err = echo.NewHTTPError(http.StatusInternalServerError, "Internal server error")
}()
return next(c)
}
}
}
@@ -0,0 +1,22 @@
package middleware
import (
"github.com/google/uuid"
"github.com/labstack/echo/v4"
)
const RequestIDKey = "request_id"
func RequestID() echo.MiddlewareFunc {
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
rid := c.Request().Header.Get(echo.HeaderXRequestID)
if rid == "" {
rid = uuid.NewString()
}
c.Response().Header().Set(echo.HeaderXRequestID, rid)
c.Set(RequestIDKey, rid)
return next(c)
}
}
}
+126
View File
@@ -0,0 +1,126 @@
package http
import (
"encoding/base64"
"fmt"
"net/http"
"net/url"
"testing"
)
func TestPagination_MultiPageWalk(t *testing.T) {
r := newTestRig(t)
alice, bob, _, chat := bootstrap(r)
const total = 7
var sentIDs []string
for i := 0; i < total; i++ {
actor := alice
if i%2 == 1 {
actor = bob
}
_, msg := r.sendMessage(actor, chat.ID, fmt.Sprintf("page-%02d", i))
if msg.ID == "" {
t.Fatalf("send message %d failed", i)
}
sentIDs = append(sentIDs, msg.ID)
}
history, pages := r.listMessages(alice, chat.ID, 3)
if pages != 3 {
t.Fatalf("ожидалось 3 страницы (3+3+1), получено %d", pages)
}
if len(history) != total {
t.Fatalf("собрано %d сообщений, ожидалось %d", len(history), total)
}
for i, m := range history {
if m.ID != sentIDs[i] {
t.Fatalf("позиция %d: ожидался %s, получен %s (повтор, пропуск или нарушен порядок)", i, sentIDs[i], m.ID)
}
}
}
func TestPagination_ExactPageAndEmptyChat(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
history, pages := r.listMessages(alice, chat.ID, 5)
if len(history) != 0 || pages != 1 {
t.Fatalf("пустой чат: items=%d pages=%d", len(history), pages)
}
for i := 0; i < 4; i++ {
r.send(alice, chat.ID, fmt.Sprintf("m%d", i))
}
if _, pages := r.listMessages(alice, chat.ID, 4); pages != 1 {
t.Fatalf("4 сообщения при limit=4: ожидалась 1 страница, получено %d", pages)
}
if _, pages := r.listMessages(alice, chat.ID, 2); pages != 2 {
t.Fatalf("4 сообщения при limit=2: ожидалось 2 страницы, получено %d", pages)
}
}
func TestPagination_CursorBoundToChat(t *testing.T) {
r := newTestRig(t)
alice, bob, _, chat := bootstrap(r)
other := r.createChat(alice, "Другой", alice.ID, bob.ID)
for i := 0; i < 3; i++ {
r.send(alice, chat.ID, fmt.Sprintf("m%d", i))
}
resp := r.do(http.MethodGet, "/api/v1/chats/"+chat.ID+"/messages?limit=1", alice.ID, nil, nil)
expectStatus(t, resp, http.StatusOK)
var page struct {
NextCursor *string `json:"next_cursor"`
}
readJSON(t, resp, &page)
if page.NextCursor == nil {
t.Fatal("ожидался next_cursor")
}
for _, path := range []string{
"/api/v1/chats/" + other.ID + "/messages?cursor=" + url.QueryEscape(*page.NextCursor),
"/api/v1/chats?cursor=" + url.QueryEscape(*page.NextCursor),
"/api/v1/chats/" + chat.ID + "/messages?cursor=not-a-cursor",
} {
resp := r.do(http.MethodGet, path, alice.ID, nil, nil)
expectStatus(t, resp, http.StatusBadRequest)
resp.Body.Close()
}
}
func TestPagination_IncompleteCursor(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
r.send(alice, chat.ID, "m0")
enc := func(s string) string { return base64.RawURLEncoding.EncodeToString([]byte(s)) }
msgScope := `"s":"chat:` + chat.ID + `"`
chatsScope := `"s":"chats:` + alice.ID + `"`
ts := `"t":"2026-01-01T00:00:00Z"`
id := `"i":"` + chat.ID + `"`
cases := map[string]string{
"только scope": enc(`{` + msgScope + `}`),
"без i": enc(`{` + ts + `,` + msgScope + `}`),
"без t": enc(`{` + id + `,` + msgScope + `}`),
"i не UUID": enc(`{` + ts + `,"i":"zzz",` + msgScope + `}`),
"нулевое t": enc(`{"t":"0001-01-01T00:00:00Z",` + id + `,` + msgScope + `}`),
"лишнее поле": enc(`{` + ts + `,` + id + `,` + msgScope + `,"x":1}`),
"данные после объекта": enc(`{` + ts + `,` + id + `,` + msgScope + `}}`),
"base64 с паддингом": base64.URLEncoding.EncodeToString([]byte(`{` + ts + `,` + id + `,` + msgScope + `}`)),
"пустой объект": enc(`{}`),
"null": enc(`null`),
}
for name, cur := range cases {
resp := r.do(http.MethodGet, "/api/v1/chats/"+chat.ID+"/messages?cursor="+url.QueryEscape(cur), alice.ID, nil, nil)
if resp.StatusCode != http.StatusBadRequest {
t.Errorf("messages, %s: ожидался 400, получен %d", name, resp.StatusCode)
}
resp.Body.Close()
}
resp := r.do(http.MethodGet, "/api/v1/chats?cursor="+url.QueryEscape(enc(`{`+chatsScope+`}`)), alice.ID, nil, nil)
expectStatus(t, resp, http.StatusBadRequest)
resp.Body.Close()
}
+37
View File
@@ -0,0 +1,37 @@
package http
import (
"github.com/labstack/echo/v4"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware"
)
func registerRoutes(e *echo.Echo, d Deps, isReady func() bool) {
e.GET("/health/live", healthLive)
e.GET("/health/ready", healthReady(isReady))
usersH := &usersHandler{users: d.Users}
chatsH := &chatsHandler{chats: d.Chats}
messagesH := &messagesHandler{messages: d.Messages}
authH := &authHandler{auth: d.Auth}
attachmentsH := &attachmentsHandler{attachments: d.Attachments}
auth := middleware.Bearer(d.Auth)
jsonBody := middleware.ContentType()
v1 := e.Group("/api/v1")
v1.POST("/users", usersH.create, jsonBody)
v1.POST("/auth/sessions", authH.createSession)
v1.DELETE("/auth/sessions/current", authH.revokeSession, auth)
v1.GET("/users/me", usersH.me, auth)
v1.POST("/chats", chatsH.create, auth, jsonBody)
v1.GET("/chats", chatsH.list, auth)
v1.GET("/chats/:chat_id", chatsH.get, auth)
v1.POST("/chats/:chat_id/messages", messagesH.send, auth, jsonBody)
v1.GET("/chats/:chat_id/messages", messagesH.list, auth)
// Тело здесь не JSON: Content-Type и размер проверяет сервис, после проверки доступа.
v1.POST("/chats/:chat_id/attachments", attachmentsH.upload, uploadTransfer, auth)
v1.GET("/attachments/:attachment_id", attachmentsH.get, auth)
v1.GET("/attachments/:attachment_id/content", attachmentsH.content, auth)
}
+176
View File
@@ -0,0 +1,176 @@
package http
import (
"context"
"errors"
"log/slog"
nethttp "net/http"
"sync/atomic"
"time"
"github.com/labstack/echo/v4"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/telemetry"
)
type Deps struct {
Config *config.Config
Logger *slog.Logger
Store store.Store
Auth service.AuthService
Users service.UsersService
Chats service.ChatsService
Messages service.MessagesService
Attachments service.AttachmentsService
Ready func(ctx context.Context) error
}
type Server struct {
e *echo.Echo
cfg config.HTTP
logger *slog.Logger
shutting atomic.Bool
ready func(ctx context.Context) error
}
func NewServer(d Deps) *Server {
s := &Server{
e: echo.New(),
cfg: d.Config.HTTP,
logger: d.Logger,
ready: d.Ready,
}
s.e.HideBanner = true
s.e.HidePort = true
s.e.HTTPErrorHandler = s.httpErrorHandler
s.e.Server.ReadTimeout = time.Duration(s.cfg.ReadTimeoutMs) * time.Millisecond
s.e.Server.WriteTimeout = time.Duration(s.cfg.WriteTimeoutMs) * time.Millisecond
s.e.Server.IdleTimeout = time.Duration(s.cfg.IdleTimeoutMs) * time.Millisecond
s.e.Use(middleware.InstanceID(d.Config.InstanceID))
s.e.Use(middleware.Recover(d.Logger))
s.e.Use(middleware.RequestID())
s.e.Use(telemetry.Middleware)
s.e.Use(middleware.Logger(d.Logger))
s.e.Use(middleware.InFlight(d.Config.Limits.MaxInFlight))
s.e.Use(middleware.BodyLimit(d.Config.Limits.MaxBodyBytes, routeUploadAttachment))
s.e.Use(middleware.MemoryGuard(d.Config.Limits.MaxHeapBytes, 100*time.Millisecond))
registerRoutes(s.e, d, s.IsReady)
return s
}
func (s *Server) Start() error {
s.logger.Info("http server starting", slog.String("addr", s.cfg.Addr))
err := s.e.Start(s.cfg.Addr)
if errors.Is(err, nethttp.ErrServerClosed) {
return nil
}
return err
}
// Drain переводит readiness в 503 и ждёт d, продолжая обслуживать запросы: за это время
// балансировщик выводит реплику, и новые запросы не попадают на закрытый listener.
func (s *Server) Drain(d time.Duration) {
s.shutting.Store(true)
s.logger.Info("http server draining", slog.Duration("for", d))
time.Sleep(d)
}
func (s *Server) Shutdown(ctx context.Context) error {
s.shutting.Store(true)
s.logger.Info("http server shutting down")
return s.e.Shutdown(ctx)
}
func (s *Server) IsReady() bool {
if s.shutting.Load() {
return false
}
if s.ready == nil {
return true
}
ctx, cancel := context.WithTimeout(context.Background(), readyTimeout)
defer cancel()
return s.ready(ctx) == nil
}
const readyTimeout = time.Second
func (s *Server) Handler() nethttp.Handler {
return s.e
}
func (s *Server) httpErrorHandler(err error, c echo.Context) {
if c.Response().Committed {
return
}
var httpErr *echo.HTTPError
if errors.As(err, &httpErr) {
code := codeFromStatus(httpErr.Code)
msg, _ := httpErr.Message.(string)
if msg == "" || msg == nethttp.StatusText(httpErr.Code) {
msg = messageFor(httpErr.Code, code)
}
_ = c.JSON(httpErr.Code, errorBody{
Error: errorPayload{
Code: code,
Message: msg,
RequestID: c.Response().Header().Get(echo.HeaderXRequestID),
},
})
return
}
_ = WriteError(c, err)
}
var codesByStatus = map[int]string{
nethttp.StatusBadRequest: CodeInvalidRequest,
nethttp.StatusUnauthorized: CodeUnauthorized,
nethttp.StatusNotFound: CodeNotFound,
nethttp.StatusMethodNotAllowed: CodeInvalidRequest,
nethttp.StatusConflict: CodeConflict,
nethttp.StatusRequestEntityTooLarge: CodePayloadTooLarge,
nethttp.StatusUnsupportedMediaType: CodeUnsupportedMedia,
nethttp.StatusTooManyRequests: CodeRateLimited,
nethttp.StatusServiceUnavailable: CodeUnavailable,
}
func codeFromStatus(status int) string {
if c, ok := codesByStatus[status]; ok {
return c
}
return CodeInternalError
}
var messagesByStatus = map[int]string{
nethttp.StatusMethodNotAllowed: "Method not allowed",
}
func messageFor(status int, code string) string {
if m, ok := messagesByStatus[status]; ok {
return m
}
return defaultMessages[code]
}
var defaultMessages = map[string]string{
CodeInvalidRequest: "Invalid request",
CodeUnauthorized: "Identification required",
CodeNotFound: "Object not found",
CodeConflict: "Conflict",
CodePayloadTooLarge: "Request body too large",
CodeUnsupportedMedia: "Unsupported Content-Type",
CodeRateLimited: "Too many requests",
CodeUnavailable: "Service unavailable",
CodeInternalError: "Internal server error",
}
+114
View File
@@ -0,0 +1,114 @@
package http
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"reflect"
"strings"
"unicode/utf8"
"github.com/labstack/echo/v4"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
type usersHandler struct {
users service.UsersService
}
func (h *usersHandler) create(c echo.Context) error {
var req dto.CreateUserRequest
if err := decodeJSON(c.Request().Body, &req); err != nil {
return WriteError(c, err)
}
user, err := h.users.Register(c.Request().Context(), req.Username, req.DisplayName, req.Password)
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusCreated, toUserResponse(user))
}
func (h *usersHandler) me(c echo.Context) error {
callerID := c.Get(middleware.AuthUserIDKey).(string)
user, err := h.users.Me(c.Request().Context(), callerID)
if err != nil {
return WriteError(c, err)
}
return c.JSON(http.StatusOK, toUserResponse(user))
}
func toUserResponse(u domain.User) dto.UserResponse {
return dto.UserResponse{
ID: u.ID,
Username: u.Username,
DisplayName: u.DisplayName,
CreatedAt: dto.NewTimestamp(u.CreatedAt),
}
}
func decodeJSON(body io.Reader, dst any) error {
data, err := io.ReadAll(body)
if err != nil {
if errors.Is(err, domain.ErrPayloadTooLarge) {
return err
}
return &validate.Error{Field: "body", Reason: "cannot read body"}
}
if !utf8.Valid(data) {
return &validate.Error{Field: "body", Reason: "invalid UTF-8"}
}
dec := json.NewDecoder(bytes.NewReader(data))
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
return &validate.Error{Field: "body", Reason: jsonErrorReason(err)}
}
if _, err := dec.Token(); !errors.Is(err, io.EOF) {
return &validate.Error{Field: "body", Reason: "unexpected data after JSON object"}
}
return checkExactKeys(data, dst)
}
func checkExactKeys(data []byte, dst any) error {
var obj map[string]json.RawMessage
if err := json.Unmarshal(data, &obj); err != nil {
return nil
}
allowed := make(map[string]struct{})
t := reflect.TypeOf(dst).Elem()
for i := 0; i < t.NumField(); i++ {
name, _, _ := strings.Cut(t.Field(i).Tag.Get("json"), ",")
allowed[name] = struct{}{}
}
for key := range obj {
if _, ok := allowed[key]; !ok {
return &validate.Error{Field: "body", Reason: fmt.Sprintf("unknown field %q", key)}
}
}
return nil
}
func jsonErrorReason(err error) string {
if errors.Is(err, io.EOF) {
return "empty body"
}
var typeErr *json.UnmarshalTypeError
if errors.As(err, &typeErr) {
if typeErr.Field == "" {
return "expected a JSON object"
}
return fmt.Sprintf("field %q: invalid type", typeErr.Field)
}
if name, ok := strings.CutPrefix(err.Error(), "json: unknown field "); ok {
return "unknown field " + name
}
return "invalid JSON"
}
+230
View File
@@ -0,0 +1,230 @@
package http
import (
"bytes"
"io"
"net/http"
"strings"
"testing"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
)
func TestValidation_InvalidJSON(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
path := "/api/v1/chats/" + chat.ID + "/messages"
bad := [][]byte{
[]byte(`{"text":`),
[]byte(`not json at all`),
[]byte(`{"text": 123,}`),
[]byte(``),
[]byte(`{"text": "ok"}{"text":"bonus"}`),
[]byte(`{"text": "ok"}}`),
[]byte(`{"text": "ok"}]`),
[]byte(`{"text": "ok"} }`),
[]byte(`{"text": "ok"} x`),
[]byte("{\"text\":\"\xff\xfe bad utf8\"}"),
}
for _, payload := range bad {
resp := r.do(http.MethodPost, path, alice.ID,
map[string]string{"Content-Type": "application/json"},
bytes.NewReader(payload))
if resp.StatusCode != http.StatusBadRequest {
data, _ := io.ReadAll(resp.Body)
resp.Body.Close()
t.Fatalf("payload %q: expected 400, got %d; body=%s", payload, resp.StatusCode, string(data))
}
e := readError(t, resp)
if e.Error.Code != CodeInvalidRequest {
t.Fatalf("payload %q: expected code %q, got %q", payload, CodeInvalidRequest, e.Error.Code)
}
if e.Error.RequestID == "" {
t.Fatalf("payload %q: missing request_id in body", payload)
}
}
}
func TestValidation_InvalidUTF8(t *testing.T) {
r := newTestRig(t)
alice, bob, _, _ := bootstrap(r)
cases := []struct {
path, actor string
payload []byte
}{
{"/api/v1/users", "", []byte("{\"username\":\"u_" + randomSuffix()[:8] + "\",\"display_name\":\"\xc3\x28\"}")},
{"/api/v1/chats", alice.ID, []byte("{\"title\":\"\xe2\x82\",\"member_ids\":[\"" + alice.ID + "\",\"" + bob.ID + "\"]}")},
}
for _, tc := range cases {
resp := r.do(http.MethodPost, tc.path, tc.actor,
map[string]string{"Content-Type": "application/json"},
bytes.NewReader(tc.payload))
if resp.StatusCode != http.StatusBadRequest {
data, _ := io.ReadAll(resp.Body)
resp.Body.Close()
t.Fatalf("%s %q: expected 400, got %d; body=%s", tc.path, tc.payload, resp.StatusCode, string(data))
}
e := readError(t, resp)
if e.Error.Code != CodeInvalidRequest {
t.Fatalf("%s: expected code %q, got %q", tc.path, CodeInvalidRequest, e.Error.Code)
}
}
}
func TestValidation_JSONKeysAreCaseSensitive(t *testing.T) {
r := newTestRig(t)
resp := r.do(http.MethodPost, "/api/v1/users", "",
map[string]string{"Content-Type": "application/json"},
strings.NewReader(`{"USERNAME":"case_bob","Display_Name":"B"}`))
expectStatus(t, resp, http.StatusBadRequest)
resp.Body.Close()
}
func TestValidation_ErrorMessages(t *testing.T) {
r := newTestRig(t)
alice, bob, _, chat := bootstrap(r)
msgs := "/api/v1/chats/" + chat.ID + "/messages"
cases := []struct {
method, path, actor, body, message string
}{
{http.MethodPost, "/api/v1/users", "", `{"username":"ab","display_name":"x"}`,
"username: must match [a-z0-9_]{3,32}"},
{http.MethodPost, "/api/v1/users", "", `{"username":"abc_` + randomSuffix()[:6] + `","display_name":" "}`,
"display_name: must not be empty or whitespace only"},
{http.MethodPost, "/api/v1/users", "", `{"username":123,"display_name":"x"}`,
`body: field "username": invalid type`},
{http.MethodPost, "/api/v1/users", "", `{"username":"abc","display_name":"x","password":"p"}`,
"password: length must be in [12, 128] code points"},
{http.MethodPost, "/api/v1/users", "", `{"username":"abc","display_name":"x"}`,
"password: must not be empty or whitespace only"},
{http.MethodPost, "/api/v1/users", "", `{"username":"abc","display_name":"x","password":"` + strings.Repeat("я", 129) + `"}`,
"password: length must be in [12, 128] code points"},
{http.MethodPost, "/api/v1/users", "", `{"username":"abc","display_name":"x","password":"long-enough-pw","password_hash":"h"}`,
`body: unknown field "password_hash"`},
{http.MethodPost, "/api/v1/users", "", `{"username":`, "body: invalid JSON"},
{http.MethodPost, "/api/v1/users", "", ``, "body: empty body"},
{http.MethodPost, "/api/v1/users", "", `[]`, "body: expected a JSON object"},
{http.MethodPost, "/api/v1/users", "", `{"username":"abc","display_name":"x"} {}`, "body: unexpected data after JSON object"},
{http.MethodPost, "/api/v1/users", "", `{"username":"abc","display_name":"x"}}`, "body: unexpected data after JSON object"},
{http.MethodPost, "/api/v1/users", "", "{\"username\":\"abc\",\"display_name\":\"\xff\"}",
"body: invalid UTF-8"},
{http.MethodPost, "/api/v1/chats", alice.ID, `{"title":"t","member_ids":["` + bob.ID + `"]}`,
"member_ids: must contain caller"},
{http.MethodPost, "/api/v1/chats", alice.ID, `{"title":"t","member_ids":["` + alice.ID + `","x"]}`,
"member_ids[1]: must be a valid UUID"},
{http.MethodPost, msgs, alice.ID, `{"text":" "}`, "text: must not be empty or whitespace only"},
{http.MethodGet, msgs + "?limit=abc", alice.ID, "", "limit: must be an integer"},
{http.MethodGet, msgs + "?limit=0", alice.ID, "", "limit: must be in [1, 100]"},
{http.MethodGet, msgs + "?limit=", alice.ID, "", "limit: must be an integer"},
{http.MethodGet, msgs + "?cursor=", alice.ID, "", "cursor: must not be empty"},
{http.MethodGet, msgs + "?limit=10&cursor=", alice.ID, "", "cursor: must not be empty"},
{http.MethodGet, "/api/v1/chats?limit=", alice.ID, "", "limit: must be an integer"},
{http.MethodGet, "/api/v1/chats?cursor=", alice.ID, "", "cursor: must not be empty"},
}
for _, tc := range cases {
headers := map[string]string{}
var body io.Reader
if tc.method == http.MethodPost {
headers["Content-Type"] = "application/json"
body = bytes.NewReader([]byte(tc.body))
}
resp := r.do(tc.method, tc.path, tc.actor, headers, body)
if resp.StatusCode != http.StatusBadRequest {
data, _ := io.ReadAll(resp.Body)
resp.Body.Close()
t.Fatalf("%s %s %q: expected 400, got %d; body=%s", tc.method, tc.path, tc.body, resp.StatusCode, string(data))
}
e := readError(t, resp)
if e.Error.Message != tc.message {
t.Fatalf("%s %s %q:\n want %q\n got %q", tc.method, tc.path, tc.body, tc.message, e.Error.Message)
}
}
}
func TestValidation_EmptyMessage(t *testing.T) {
r := newTestRig(t)
alice, _, _, chat := bootstrap(r)
path := "/api/v1/chats/" + chat.ID + "/messages"
for _, text := range []string{"", " ", "\n\t "} {
resp := r.doJSON(http.MethodPost, path, alice.ID, textMessage(text))
if resp.StatusCode != http.StatusBadRequest {
data, _ := io.ReadAll(resp.Body)
resp.Body.Close()
t.Fatalf("text %q: expected 400, got %d; body=%s", text, resp.StatusCode, string(data))
}
e := readError(t, resp)
if e.Error.Code != CodeInvalidRequest {
t.Fatalf("text %q: expected code %q, got %q", text, CodeInvalidRequest, e.Error.Code)
}
}
}
func TestValidation_DuplicateUsername(t *testing.T) {
r := newTestRig(t)
username := "own_dup_" + randomSuffix()
first := r.doJSON(http.MethodPost, "/api/v1/users", "", dto.CreateUserRequest{
Username: username,
DisplayName: "Первый",
Password: testPassword,
})
expectStatus(t, first, http.StatusCreated)
first.Body.Close()
second := r.doJSON(http.MethodPost, "/api/v1/users", "", dto.CreateUserRequest{
Username: username,
DisplayName: "Второй",
Password: testPassword,
})
if second.StatusCode != http.StatusConflict {
data, _ := io.ReadAll(second.Body)
second.Body.Close()
t.Fatalf("second POST same username: expected 409, got %d; body=%s", second.StatusCode, string(data))
}
e := readError(t, second)
if e.Error.Code != CodeConflict {
t.Fatalf("expected code %q, got %q", CodeConflict, e.Error.Code)
}
third := r.doJSON(http.MethodPost, "/api/v1/users", "", dto.CreateUserRequest{
Username: username,
DisplayName: "Первый",
Password: testPassword,
})
if third.StatusCode != http.StatusConflict {
data, _ := io.ReadAll(third.Body)
third.Body.Close()
t.Fatalf("third POST same username/display_name: expected 409, got %d; body=%s", third.StatusCode, string(data))
}
third.Body.Close()
}
func TestValidation_UUIDForms(t *testing.T) {
r := newTestRig(t)
alice, bob, _, chat := bootstrap(r)
upper := strings.ToUpper(alice.ID)
resp := r.do(http.MethodGet, "/api/v1/users/me", upper, nil, nil)
expectStatus(t, resp, http.StatusOK)
resp.Body.Close()
resp = r.do(http.MethodGet, "/api/v1/chats/"+strings.ToUpper(chat.ID), alice.ID, nil, nil)
expectStatus(t, resp, http.StatusOK)
resp.Body.Close()
resp = r.do(http.MethodGet, "/api/v1/users/me", "{"+alice.ID+"}", nil, nil)
expectStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
resp = r.do(http.MethodGet, "/api/v1/chats/"+strings.ReplaceAll(chat.ID, "-", ""), alice.ID, nil, nil)
expectStatus(t, resp, http.StatusBadRequest)
resp.Body.Close()
resp = r.doJSON(http.MethodPost, "/api/v1/chats", alice.ID, map[string]any{
"title": "dup", "member_ids": []string{alice.ID, upper, bob.ID},
})
expectStatus(t, resp, http.StatusBadRequest)
resp.Body.Close()
}
+478
View File
@@ -0,0 +1,478 @@
package cache
import (
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"log/slog"
"os"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/redis/go-redis/v9"
"golang.org/x/sync/singleflight"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
)
const (
ModeOff = "off"
ModeNaive = "naive"
ModeSafe = "safe"
)
type Source interface {
store.MessageStore
IsMember(ctx context.Context, chatID, userID string) (bool, error)
HistoryPage(ctx context.Context, chatID, cursor string, limit int) (domain.Page[domain.Message], error)
}
// Outbox хранит долг инвалидации в источнике истины, чтобы он пережил
// рестарт API. Без него отложенная инвалидация живёт только в памяти.
type Outbox interface {
AddPendingInvalidation(ctx context.Context, chatID string) (int64, error)
PendingInvalidations(ctx context.Context) (map[string]int64, error)
ResolvePendingInvalidation(ctx context.Context, chatID string, gen int64) error
}
type Options struct {
Mode string
Outbox Outbox
PageTTL time.Duration
LockTTL time.Duration
FillDelay time.Duration
Logger *slog.Logger
}
var _ store.MessageStore = (*Messages)(nil)
// pendingEntry — несброшенная версия чата. seq меняется при каждом новом
// сбое: повтор снимает запись, только если seq не изменился с его снимка.
// gen — поколение строки в Outbox (0 — не записана).
type pendingEntry struct {
seq uint64
gen int64
}
type Messages struct {
src Source
rdb *redis.Client
opt Options
group singleflight.Group
log *slog.Logger
downUntil atomic.Int64
// loaded: долг инвалидации из Outbox прочитан. До этого любой чат может
// иметь устаревшую версию, поэтому все чтения идут мимо кэша.
loaded atomic.Bool
mu sync.Mutex
pending map[string]pendingEntry
seq uint64
stop chan struct{}
done chan struct{}
}
const (
memberTTL = 24 * time.Hour
versionTTL = 24 * time.Hour
breakerPause = time.Second
retryInterval = 200 * time.Millisecond
pollInterval = 5 * time.Millisecond
defaultPageTTL = 30 * time.Second
defaultLockTTL = 500 * time.Millisecond
)
func New(src Source, rdb *redis.Client, opt Options) *Messages {
if opt.PageTTL <= 0 {
opt.PageTTL = defaultPageTTL
}
if opt.LockTTL <= 0 {
opt.LockTTL = defaultLockTTL
}
if opt.Logger == nil {
opt.Logger = slog.Default()
}
m := &Messages{
src: src,
rdb: rdb,
opt: opt,
log: opt.Logger,
pending: make(map[string]pendingEntry),
stop: make(chan struct{}),
done: make(chan struct{}),
}
m.loaded.Store(opt.Outbox == nil || opt.Mode != ModeSafe)
go m.retryLoop()
return m
}
func Connect(cfg config.HistoryCache) (*redis.Client, error) {
url := cfg.URL
if cfg.URLFile != "" {
b, err := os.ReadFile(cfg.URLFile)
if err != nil {
return nil, fmt.Errorf("cache: read HISTORY_CACHE_URL_FILE: %w", err)
}
url = strings.TrimSpace(string(b))
}
if url == "" {
return nil, errors.New("cache: HISTORY_CACHE_URL_FILE or HISTORY_CACHE_URL is required unless HISTORY_CACHE=off")
}
opts, err := redis.ParseURL(url)
if err != nil {
return nil, errors.New("cache: invalid HISTORY_CACHE_URL")
}
timeout := time.Duration(cfg.TimeoutMs) * time.Millisecond
opts.PoolSize = cfg.PoolSize
opts.DialTimeout = timeout
opts.ReadTimeout = timeout
opts.WriteTimeout = timeout
opts.PoolTimeout = timeout
opts.MaxRetries = -1 // без повторов: промах кэша дешевле ожидания
return redis.NewClient(opts), nil
}
func (m *Messages) Close() {
close(m.stop)
<-m.done
}
func (m *Messages) AddMessage(ctx context.Context, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error) {
msg, err := m.src.AddMessage(ctx, callerID, chatID, idempotencyKey, text, attachmentIDs)
if err != nil {
return msg, err
}
// Инвалидация нужна и при повторе: реплика, выполнившая COMMIT, могла упасть до
// сброса кэша, и тогда ответ 201 на повтор — первое подтверждение этого сообщения.
ictx := context.WithoutCancel(ctx)
switch m.opt.Mode {
case ModeNaive:
m.naiveInvalidate(ictx, chatID)
case ModeSafe:
if err := m.rdb.Del(ictx, verKey(chatID)).Err(); err != nil {
m.markDown(err)
m.addPending(ictx, chatID)
}
}
return msg, nil
}
func (m *Messages) ListMessages(ctx context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
if m.opt.Mode == ModeOff || m.bypass(chatID) {
return m.src.ListMessages(ctx, callerID, chatID, cursor, limit)
}
if err := m.checkMember(ctx, chatID, callerID); err != nil {
return domain.Page[domain.Message]{}, err
}
if m.opt.Mode == ModeNaive {
return m.naiveList(ctx, chatID, cursor, limit)
}
return m.safeList(ctx, chatID, cursor, limit)
}
func (m *Messages) checkMember(ctx context.Context, chatID, userID string) error {
key := "hc:member:" + chatID + ":" + userID
if !m.isDown() {
v, err := m.rdb.Get(ctx, key).Result()
if err == nil && v == "1" {
return nil
}
m.markDown(err)
}
ok, err := m.src.IsMember(ctx, chatID, userID)
if err != nil {
return err
}
if !ok {
// Отрицательный ответ не кэшируем.
return domain.ErrNotFound
}
if !m.isDown() {
m.markDown(m.rdb.Set(ctx, key, "1", memberTTL).Err())
}
return nil
}
func (m *Messages) naiveList(ctx context.Context, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
key := pageKey("hc:naive:"+chatID, cursor, limit)
if page, ok := m.getPage(ctx, key); ok {
return page, nil
}
page, err := m.src.HistoryPage(ctx, chatID, cursor, limit)
if err != nil {
return page, err
}
m.sleepFill(ctx)
if b, err := encodePage(page); err == nil {
setKey := "hc:naive:keys:" + chatID
_, err := m.rdb.TxPipelined(ctx, func(p redis.Pipeliner) error {
p.Set(ctx, key, b, m.opt.PageTTL)
p.SAdd(ctx, setKey, key)
p.Expire(ctx, setKey, m.opt.PageTTL)
return nil
})
m.markDown(err)
}
return page, nil
}
func (m *Messages) naiveInvalidate(ctx context.Context, chatID string) {
setKey := "hc:naive:keys:" + chatID
keys, err := m.rdb.SMembers(ctx, setKey).Result()
if err != nil {
m.markDown(err)
return
}
m.markDown(m.rdb.Del(ctx, append(keys, setKey)...).Err())
}
func (m *Messages) safeList(ctx context.Context, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
ver, err := m.version(ctx, chatID)
if err != nil {
m.markDown(err)
return m.src.HistoryPage(ctx, chatID, cursor, limit)
}
key := pageKey("hc:page:"+chatID+":"+ver, cursor, limit)
if page, ok := m.getPage(ctx, key); ok {
return page, nil
}
v, err, _ := m.group.Do(key, func() (any, error) {
return m.fill(context.WithoutCancel(ctx), key, chatID, cursor, limit)
})
if err != nil {
return domain.Page[domain.Message]{}, err
}
return v.(domain.Page[domain.Message]), nil
}
func (m *Messages) version(ctx context.Context, chatID string) (string, error) {
key := verKey(chatID)
v, err := m.rdb.Get(ctx, key).Result()
if err == nil {
return v, nil
}
if !errors.Is(err, redis.Nil) {
return "", err
}
fresh := randomVersion()
old, err := m.rdb.SetArgs(ctx, key, fresh, redis.SetArgs{Mode: "NX", Get: true, TTL: versionTTL}).Result()
if errors.Is(err, redis.Nil) {
return fresh, nil
}
if err != nil {
return "", err
}
return old, nil
}
var unlockScript = redis.NewScript(`
if redis.call("GET", KEYS[1]) == ARGV[1] then return redis.call("DEL", KEYS[1]) end
return 0`)
func (m *Messages) fill(ctx context.Context, key, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
lockKey := "hc:lock:" + key
token := randomVersion()
locked, err := m.rdb.SetNX(ctx, lockKey, token, m.opt.LockTTL).Result()
if err != nil {
m.markDown(err)
return m.src.HistoryPage(ctx, chatID, cursor, limit)
}
if !locked {
deadline := time.Now().Add(m.opt.LockTTL)
for time.Now().Before(deadline) {
time.Sleep(pollInterval)
if page, ok := m.getPage(ctx, key); ok {
return page, nil
}
}
return m.src.HistoryPage(ctx, chatID, cursor, limit)
}
defer unlockScript.Run(ctx, m.rdb, []string{lockKey}, token)
page, err := m.src.HistoryPage(ctx, chatID, cursor, limit)
if err != nil {
return page, err
}
m.sleepFill(ctx)
if b, err := encodePage(page); err == nil {
m.markDown(m.rdb.Set(ctx, key, b, m.opt.PageTTL).Err())
}
return page, nil
}
// addPending вызывается до ответа 201: после него чат читается мимо кэша,
// пока версия не будет сброшена, в том числе после рестарта API.
func (m *Messages) addPending(ctx context.Context, chatID string) {
m.markPending(chatID, 0)
if m.opt.Outbox == nil {
m.log.Warn("history cache invalidation deferred", slog.String("chat_id", chatID))
return
}
gen, err := m.opt.Outbox.AddPendingInvalidation(ctx, chatID)
if err != nil {
m.log.Error("history cache invalidation deferred in memory only, lost on restart",
slog.String("chat_id", chatID), slog.Any("err", err))
return
}
m.markPending(chatID, gen)
m.log.Warn("history cache invalidation deferred",
slog.String("chat_id", chatID), slog.Int64("gen", gen))
}
// markPending всегда выдаёт новый seq, чтобы повтор, начатый раньше, не снял
// запись. gen не уменьшается.
func (m *Messages) markPending(chatID string, gen int64) {
m.mu.Lock()
m.seq++
e := m.pending[chatID]
e.seq = m.seq
e.gen = max(e.gen, gen)
m.pending[chatID] = e
m.mu.Unlock()
}
func (m *Messages) bypass(chatID string) bool {
if m.isDown() || !m.loaded.Load() {
return true
}
m.mu.Lock()
_, ok := m.pending[chatID]
m.mu.Unlock()
return ok
}
func (m *Messages) loadPending() {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
rows, err := m.opt.Outbox.PendingInvalidations(ctx)
if err != nil {
m.log.Warn("history cache: pending invalidations not loaded, bypassing", slog.Any("err", err))
return
}
for id, gen := range rows {
m.markPending(id, gen)
}
m.loaded.Store(true)
if len(rows) > 0 {
m.log.Info("history cache: pending invalidations loaded", slog.Int("chats", len(rows)))
}
}
func (m *Messages) retryLoop() {
defer close(m.done)
t := time.NewTicker(retryInterval)
defer t.Stop()
for {
if !m.loaded.Load() {
m.loadPending()
}
m.retryPending()
select {
case <-m.stop:
return
case <-t.C:
}
}
}
func (m *Messages) retryPending() {
m.mu.Lock()
chats := make(map[string]pendingEntry, len(m.pending))
for id, e := range m.pending {
chats[id] = e
}
m.mu.Unlock()
for id, e := range chats {
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
err := m.rdb.Del(ctx, verKey(id)).Err()
if err == nil && e.gen > 0 {
err = m.opt.Outbox.ResolvePendingInvalidation(ctx, id, e.gen)
}
cancel()
if err != nil {
return
}
m.resolved(id, e)
}
}
// resolved снимает запись, если после снимка e не было нового сбоя.
func (m *Messages) resolved(chatID string, e pendingEntry) {
m.mu.Lock()
if m.pending[chatID].seq == e.seq {
delete(m.pending, chatID)
}
m.mu.Unlock()
}
func (m *Messages) isDown() bool {
return time.Now().UnixNano() < m.downUntil.Load()
}
func (m *Messages) markDown(err error) {
if err == nil || errors.Is(err, redis.Nil) {
return
}
if !m.isDown() {
m.log.Warn("history cache unavailable, bypassing", slog.Any("err", err))
}
m.downUntil.Store(time.Now().Add(breakerPause).UnixNano())
}
func (m *Messages) getPage(ctx context.Context, key string) (domain.Page[domain.Message], bool) {
b, err := m.rdb.Get(ctx, key).Bytes()
if err != nil {
m.markDown(err)
return domain.Page[domain.Message]{}, false
}
page, err := decodePage(b)
return page, err == nil
}
func (m *Messages) sleepFill(ctx context.Context) {
if m.opt.FillDelay <= 0 {
return
}
select {
case <-time.After(m.opt.FillDelay):
case <-ctx.Done():
}
}
func verKey(chatID string) string { return "hc:ver:" + chatID }
func pageKey(prefix, cursor string, limit int) string {
return prefix + ":" + strconv.Itoa(limit) + ":" + cursor
}
func randomVersion() string {
var b [8]byte
_, _ = rand.Read(b[:])
return hex.EncodeToString(b[:])
}
type cachedPage struct {
Items []domain.Message `json:"items"`
NextCursor string `json:"next_cursor"`
}
func encodePage(p domain.Page[domain.Message]) ([]byte, error) {
return json.Marshal(cachedPage{Items: p.Items, NextCursor: p.NextCursor})
}
func decodePage(b []byte) (domain.Page[domain.Message], error) {
var c cachedPage
if err := json.Unmarshal(b, &c); err != nil {
return domain.Page[domain.Message]{}, err
}
return domain.Page[domain.Message]{Items: c.Items, NextCursor: c.NextCursor}, nil
}
+208
View File
@@ -0,0 +1,208 @@
package cache
import (
"context"
"errors"
"fmt"
"io"
"log/slog"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/redis/go-redis/v9"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
const member = "alice"
type fakeSource struct {
mu sync.Mutex
msgs []domain.Message
queryDelay time.Duration
pageCalls atomic.Int64
}
func (f *fakeSource) AddMessage(_ context.Context, callerID, chatID, _, text string, _ []string) (domain.Message, error) {
f.mu.Lock()
defer f.mu.Unlock()
m := domain.Message{
ID: fmt.Sprintf("m%04d", len(f.msgs)),
ChatID: chatID,
AuthorID: callerID,
Text: text,
CreatedAt: time.Now().UTC(),
}
f.msgs = append(f.msgs, m)
return m, nil
}
func (f *fakeSource) IsMember(_ context.Context, _, userID string) (bool, error) {
return userID == member, nil
}
func (f *fakeSource) HistoryPage(context.Context, string, string, int) (domain.Page[domain.Message], error) {
f.pageCalls.Add(1)
f.mu.Lock()
snapshot := append([]domain.Message(nil), f.msgs...)
f.mu.Unlock()
time.Sleep(f.queryDelay)
return domain.Page[domain.Message]{Items: snapshot}, nil
}
func (f *fakeSource) ListMessages(ctx context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
if ok, _ := f.IsMember(ctx, chatID, callerID); !ok {
return domain.Page[domain.Message]{}, domain.ErrNotFound
}
return f.HistoryPage(ctx, chatID, cursor, limit)
}
func newCache(t *testing.T, c *redis.Client, mode string, src *fakeSource, fillDelay time.Duration) *Messages {
t.Helper()
m := New(src, c, Options{
Mode: mode,
PageTTL: time.Minute,
FillDelay: fillDelay,
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
})
t.Cleanup(m.Close)
return m
}
func contains(p domain.Page[domain.Message], id string) bool {
for _, m := range p.Items {
if m.ID == id {
return true
}
}
return false
}
func TestCacheDown_Bypass(t *testing.T) {
ctx := context.Background()
dead := redis.NewClient(&redis.Options{
Addr: "127.0.0.1:1", DialTimeout: 50 * time.Millisecond, MaxRetries: -1,
})
t.Cleanup(func() { dead.Close() })
src := &fakeSource{}
h := newCache(t, dead, ModeSafe, src, 0)
msg, err := h.AddMessage(ctx, member, "chat-down", randomVersion(), "при упавшем кэше", nil)
if err != nil {
t.Fatalf("запись при упавшем кэше: %v", err)
}
page, err := h.ListMessages(ctx, member, "chat-down", "", 50)
if err != nil || !contains(page, msg.ID) {
t.Fatalf("чтение при упавшем кэше: err=%v", err)
}
if !h.bypass("chat-down") {
t.Fatal("чат с несброшенной версией должен читаться мимо кэша")
}
if _, err := h.ListMessages(ctx, "mallory", "chat-down", "", 50); !errors.Is(err, domain.ErrNotFound) {
t.Fatalf("обход кэша не должен пропускать постороннего: %v", err)
}
}
type fakeOutbox struct {
mu sync.Mutex
rows map[string]int64
seq int64 // как cache_invalidations_gen_seq: gen не повторяется
loadErr error
}
func (f *fakeOutbox) AddPendingInvalidation(_ context.Context, chatID string) (int64, error) {
f.mu.Lock()
defer f.mu.Unlock()
f.seq++
f.rows[chatID] = f.seq
return f.seq, nil
}
func (f *fakeOutbox) PendingInvalidations(context.Context) (map[string]int64, error) {
f.mu.Lock()
defer f.mu.Unlock()
if f.loadErr != nil {
return nil, f.loadErr
}
out := make(map[string]int64, len(f.rows))
for k, v := range f.rows {
out[k] = v
}
return out, nil
}
func (f *fakeOutbox) ResolvePendingInvalidation(_ context.Context, chatID string, gen int64) error {
f.mu.Lock()
defer f.mu.Unlock()
if f.rows[chatID] == gen {
delete(f.rows, chatID)
}
return nil
}
func (f *fakeOutbox) len() int {
f.mu.Lock()
defer f.mu.Unlock()
return len(f.rows)
}
func TestBypassUntilOutboxLoaded(t *testing.T) {
outbox := &fakeOutbox{rows: map[string]int64{}, loadErr: errors.New("db down")}
h := New(&fakeSource{}, redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}), Options{
Mode: ModeSafe,
Outbox: outbox,
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
})
defer h.Close()
time.Sleep(3 * retryInterval)
if !h.bypass("any") {
t.Fatal("пока долг из Outbox не прочитан, кэш не должен отдавать страницы")
}
outbox.mu.Lock()
outbox.loadErr = nil
outbox.mu.Unlock()
deadline := time.Now().Add(2 * time.Second)
for h.bypass("any") {
if time.Now().After(deadline) {
t.Fatal("после загрузки Outbox чтение через кэш не включилось")
}
time.Sleep(20 * time.Millisecond)
}
}
// Повтор сбросил версию и снял строку Outbox, но до того, как он снял запись
// из памяти, новая запись снова не смогла сбросить версию. Запись в памяти и
// строка Outbox должны остаться, иначе ответ 201 придёт при устаревшем кэше.
func TestRetryDoesNotDropNewerFailure(t *testing.T) {
ctx := context.Background()
outbox := &fakeOutbox{rows: map[string]int64{}}
h := New(&fakeSource{}, redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"}), Options{
Mode: ModeSafe,
Outbox: outbox,
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
})
h.Close() // повтор ведём вручную
h.loaded.Store(true)
chat := "chat-retry-race"
h.addPending(ctx, chat)
snap := h.pending[chat] // снимок повтора; DEL версии прошёл
if err := outbox.ResolvePendingInvalidation(ctx, chat, snap.gen); err != nil {
t.Fatal(err)
}
h.addPending(ctx, chat) // новый сбой DEL до ответа 201
h.resolved(chat, snap)
if !h.bypass(chat) {
t.Fatal("повтор снял запись о более новом сбое")
}
if rows, _ := outbox.PendingInvalidations(ctx); rows[chat] <= snap.gen {
t.Fatalf("строка Outbox: gen=%d, ожидался новый gen > %d", rows[chat], snap.gen)
}
h.resolved(chat, h.pending[chat])
if h.bypass(chat) {
t.Fatal("актуальный повтор должен снять запись")
}
}
+40
View File
@@ -0,0 +1,40 @@
package config
// Верхние границы из контракта: конфигурация может их уменьшить, но не превысить.
const (
ContractMaxUploadBytes = 10 * 1024 * 1024
ContractMaxImagePixels = 40_000_000
)
type S3 struct {
Endpoint string
Region string
Bucket string
AccessKeyIDFile string
SecretAccessKeyFile string
// TimeoutMs — предел на одну операцию с S3. Меньше timeout server балансировщика (15 с):
// клиент получает 503 от API, а не 504 от LB.
TimeoutMs int
}
type Attachments struct {
MaxUploadBytes int64
MaxImagePixels int64
// MaxConcurrentUploads ограничивает загрузки на одну реплику и тем самым диск под временные
// файлы (не больше MaxConcurrentUploads × MaxUploadBytes); сверх него — 429.
MaxConcurrentUploads int
}
// MinJanitorGraceSeconds covers the direct ticket lifetime (120s), complete
// timeout (60s), and an additional safety margin before orphan deletion.
const MinJanitorGraceSeconds = 300
// Janitor — очиститель объектов без метаданных (cmd/janitor).
type Janitor struct {
GraceSeconds int
IntervalSeconds int
// MaxDeletes — сколько объектов без строки допустимо удалить за проход. Больше — признак аварии
// (например, БД восстановлена из старой копии), и очиститель ничего не удаляет.
MaxDeletes int
DryRun bool
}
+215
View File
@@ -0,0 +1,215 @@
package config
import (
"errors"
"fmt"
"os"
"regexp"
"strings"
"github.com/google/uuid"
)
var instanceIDPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
type Config struct {
Env string
Version string
InstanceID string
HTTP HTTP
Logger Logger
Limits Limits
Database Database
Cache Cache
Session Session
S3 S3
Attachments Attachments
Janitor Janitor
Idempotency Idempotency
HistoryCache HistoryCache
}
func Load() (*Config, error) {
cfg := defaults()
if err := cfg.applyEnv(os.LookupEnv); err != nil {
return nil, fmt.Errorf("config: env: %w", err)
}
if cfg.InstanceID == "" {
cfg.InstanceID = defaultInstanceID()
}
if err := cfg.validate(); err != nil {
return nil, fmt.Errorf("config: validate: %w", err)
}
return cfg, nil
}
func defaults() *Config {
return &Config{
Env: "lab",
Version: "dev",
HTTP: HTTP{
Addr: "0.0.0.0:8080",
ReadTimeoutMs: 10000,
WriteTimeoutMs: 10000,
IdleTimeoutMs: 60000,
ShutdownTimeoutMs: 10000,
ShutdownDrainMs: 3000,
},
Logger: Logger{Level: "info"},
Limits: Limits{
MaxBodyBytes: 64 * 1024,
MaxInFlight: 64,
MaxMessagesGlobal: 100000,
MaxHeapBytes: 256 * 1024 * 1024,
},
Database: Database{
MaxConns: 10,
ConnectTimeoutMs: 5000,
QueryTimeoutMs: 3000,
},
Cache: Cache{
PoolSize: 20,
TimeoutMs: 1000,
},
Session: Session{Store: "valkey", TTLSeconds: 3600},
S3: S3{
Endpoint: "http://s3:9000",
Region: "us-east-1",
Bucket: "messenger-attachments",
TimeoutMs: 8000,
},
Attachments: Attachments{
MaxUploadBytes: ContractMaxUploadBytes,
MaxImagePixels: ContractMaxImagePixels,
MaxConcurrentUploads: 16,
},
Janitor: Janitor{GraceSeconds: 3600, IntervalSeconds: 600, MaxDeletes: 1000},
Idempotency: Idempotency{TTLSeconds: MinIdempotencyTTLSeconds},
HistoryCache: HistoryCache{
Mode: "off",
PageTTLSeconds: 30,
TimeoutMs: 200,
PoolSize: 20,
},
}
}
// defaultInstanceID — hostname: в Docker это короткий ID контейнера, поэтому ответ
// можно сопоставить с конкретным контейнером. Значение неизменно на всю жизнь процесса.
func defaultInstanceID() string {
if h, err := os.Hostname(); err == nil && instanceIDPattern.MatchString(h) {
return h
}
return uuid.NewString()
}
func (c *Config) validate() error {
if !instanceIDPattern.MatchString(c.InstanceID) {
return fmt.Errorf("APP_INSTANCE_ID must match %s", instanceIDPattern)
}
if strings.TrimSpace(c.Env) == "" {
return errors.New("env is required")
}
if strings.TrimSpace(c.Version) == "" {
return errors.New("version is required")
}
if strings.TrimSpace(c.HTTP.Addr) == "" {
return errors.New("http.addr is required")
}
if c.HTTP.ShutdownTimeoutMs <= 0 || c.HTTP.ShutdownTimeoutMs > 10000 {
return fmt.Errorf("APP_SHUTDOWN_TIMEOUT_MS must be in (0, 10000], got %d", c.HTTP.ShutdownTimeoutMs)
}
if c.HTTP.ShutdownDrainMs < 0 || c.HTTP.ShutdownDrainMs > 10000 {
return fmt.Errorf("APP_SHUTDOWN_DRAIN_MS must be in [0, 10000], got %d", c.HTTP.ShutdownDrainMs)
}
if c.HTTP.ReadTimeoutMs <= 0 {
return fmt.Errorf("APP_READ_TIMEOUT_MS must be > 0, got %d", c.HTTP.ReadTimeoutMs)
}
if c.HTTP.WriteTimeoutMs <= 0 {
return fmt.Errorf("APP_WRITE_TIMEOUT_MS must be > 0, got %d", c.HTTP.WriteTimeoutMs)
}
if c.HTTP.IdleTimeoutMs <= 0 {
return fmt.Errorf("APP_IDLE_TIMEOUT_MS must be > 0, got %d", c.HTTP.IdleTimeoutMs)
}
if c.Limits.MaxBodyBytes <= 0 {
return fmt.Errorf("APP_MAX_BODY_BYTES must be > 0, got %d", c.Limits.MaxBodyBytes)
}
if c.Limits.MaxInFlight <= 0 {
return fmt.Errorf("APP_MAX_INFLIGHT must be > 0, got %d", c.Limits.MaxInFlight)
}
if c.Limits.MaxMessagesGlobal <= 0 {
return fmt.Errorf("APP_MAX_MESSAGES must be > 0, got %d", c.Limits.MaxMessagesGlobal)
}
if c.Limits.MaxHeapBytes == 0 {
return errors.New("APP_MAX_HEAP_BYTES must be > 0")
}
if c.S3.TimeoutMs <= 0 {
return fmt.Errorf("S3_TIMEOUT_MS must be > 0, got %d", c.S3.TimeoutMs)
}
if c.Attachments.MaxUploadBytes <= 0 || c.Attachments.MaxUploadBytes > ContractMaxUploadBytes {
return fmt.Errorf("MAX_UPLOAD_BYTES must be in (0, %d], got %d", ContractMaxUploadBytes, c.Attachments.MaxUploadBytes)
}
if c.Attachments.MaxImagePixels <= 0 || c.Attachments.MaxImagePixels > ContractMaxImagePixels {
return fmt.Errorf("MAX_IMAGE_PIXELS must be in (0, %d], got %d", ContractMaxImagePixels, c.Attachments.MaxImagePixels)
}
if c.Attachments.MaxConcurrentUploads <= 0 {
return fmt.Errorf("MAX_CONCURRENT_UPLOADS must be > 0, got %d", c.Attachments.MaxConcurrentUploads)
}
if c.Janitor.GraceSeconds < MinJanitorGraceSeconds {
return fmt.Errorf("JANITOR_GRACE_SECONDS must be >= %d, got %d", MinJanitorGraceSeconds, c.Janitor.GraceSeconds)
}
if c.Janitor.IntervalSeconds <= 0 {
return fmt.Errorf("JANITOR_INTERVAL_SECONDS must be > 0, got %d", c.Janitor.IntervalSeconds)
}
if c.Janitor.MaxDeletes <= 0 {
return fmt.Errorf("JANITOR_MAX_DELETES must be > 0, got %d", c.Janitor.MaxDeletes)
}
if c.Database.MaxConns <= 0 {
return fmt.Errorf("DB_MAX_CONNS must be > 0, got %d", c.Database.MaxConns)
}
if c.Database.ConnectTimeoutMs <= 0 {
return fmt.Errorf("DB_CONNECT_TIMEOUT_MS must be > 0, got %d", c.Database.ConnectTimeoutMs)
}
if c.Database.QueryTimeoutMs <= 0 {
return fmt.Errorf("DB_QUERY_TIMEOUT_MS must be > 0, got %d", c.Database.QueryTimeoutMs)
}
if c.Cache.PoolSize <= 0 {
return fmt.Errorf("CACHE_POOL_SIZE must be > 0, got %d", c.Cache.PoolSize)
}
if c.Cache.TimeoutMs <= 0 {
return fmt.Errorf("CACHE_TIMEOUT_MS must be > 0, got %d", c.Cache.TimeoutMs)
}
switch c.HistoryCache.Mode {
case "off", "naive", "safe":
default:
return fmt.Errorf("HISTORY_CACHE must be off|naive|safe, got %q", c.HistoryCache.Mode)
}
if c.HistoryCache.PageTTLSeconds <= 0 {
return fmt.Errorf("HISTORY_CACHE_TTL_SECONDS must be > 0, got %d", c.HistoryCache.PageTTLSeconds)
}
if c.HistoryCache.TimeoutMs <= 0 || c.HistoryCache.PoolSize <= 0 {
return errors.New("HISTORY_CACHE_TIMEOUT_MS and HISTORY_CACHE_POOL_SIZE must be > 0")
}
if c.HistoryCache.FillDelayMs < 0 || c.HistoryCache.FillDelayMs > 1000 {
return fmt.Errorf("HISTORY_CACHE_FILL_DELAY_MS must be in [0, 1000], got %d", c.HistoryCache.FillDelayMs)
}
// Реализовано одно хранилище сессий; иное значение — ошибка конфигурации, а не тихий выбор.
if c.Session.Store != "valkey" {
return fmt.Errorf("SESSION_STORE must be valkey (the only implemented session store), got %q", c.Session.Store)
}
if c.Idempotency.TTLSeconds < MinIdempotencyTTLSeconds {
return fmt.Errorf("IDEMPOTENCY_TTL_SECONDS must be >= %d, got %d", MinIdempotencyTTLSeconds, c.Idempotency.TTLSeconds)
}
if c.Session.TTLSeconds <= 0 {
return fmt.Errorf("SESSION_TTL_SECONDS must be > 0, got %d", c.Session.TTLSeconds)
}
return nil
}
+13
View File
@@ -0,0 +1,13 @@
package config
type Database struct {
URLFile string
URL string
MaxConns int32
ConnectTimeoutMs int
QueryTimeoutMs int
// EnableBitmapScan: по умолчанию выключено. Для чата, которого ещё нет в статистике,
// планировщик может ожидать почти пустой результат и выбрать чтение всего чата с сортировкой.
// Это гипотеза: замеров, подтверждающих выигрыш, в evidence нет. Флаг нужен для сравнения.
EnableBitmapScan bool
}
+176
View File
@@ -0,0 +1,176 @@
package config
import (
"fmt"
"net"
"strconv"
"strings"
)
func (c *Config) applyEnv(lookup func(string) (string, bool)) error {
get := func(key string) (string, bool) {
v, ok := lookup(key)
v = strings.TrimSpace(v)
return v, ok && v != ""
}
if v, ok := get("APP_ENV"); ok {
c.Env = v
}
if v, ok := get("APP_VERSION"); ok {
c.Version = v
}
if v, ok := get("APP_INSTANCE_ID"); ok {
c.InstanceID = v
}
if v, ok := get("APP_LOG_LEVEL"); ok {
c.Logger.Level = v
}
if v, ok := get("DATABASE_URL_FILE"); ok {
c.Database.URLFile = v
}
if v, ok := get("DATABASE_URL"); ok {
c.Database.URL = v
}
if v, ok := get("CACHE_URL_FILE"); ok {
c.Cache.URLFile = v
}
if v, ok := get("CACHE_URL"); ok {
c.Cache.URL = v
}
if v, ok := get("SESSION_STORE"); ok {
c.Session.Store = strings.ToLower(v)
}
if v, ok := get("S3_ENDPOINT"); ok {
c.S3.Endpoint = v
}
if v, ok := get("S3_REGION"); ok {
c.S3.Region = v
}
if v, ok := get("S3_BUCKET"); ok {
c.S3.Bucket = v
}
if v, ok := get("S3_ACCESS_KEY_ID_FILE"); ok {
c.S3.AccessKeyIDFile = v
}
if v, ok := get("S3_SECRET_ACCESS_KEY_FILE"); ok {
c.S3.SecretAccessKeyFile = v
}
if v, ok := get("HISTORY_CACHE"); ok {
c.HistoryCache.Mode = strings.ToLower(v)
}
if v, ok := get("HISTORY_CACHE_URL_FILE"); ok {
c.HistoryCache.URLFile = v
}
if v, ok := get("HISTORY_CACHE_URL"); ok {
c.HistoryCache.URL = v
}
if v, ok := get("JANITOR_DRY_RUN"); ok {
dryRun, err := strconv.ParseBool(v)
if err != nil {
return fmt.Errorf("JANITOR_DRY_RUN: not a boolean: %q", v)
}
c.Janitor.DryRun = dryRun
}
host, port, err := net.SplitHostPort(c.HTTP.Addr)
if err != nil {
return fmt.Errorf("default addr %q: %w", c.HTTP.Addr, err)
}
if v, ok := get("APP_HOST"); ok {
host = v
}
if v, ok := get("APP_PORT"); ok {
port = v
}
if n, err := strconv.Atoi(port); err != nil || n < 1 || n > 65535 {
return fmt.Errorf("APP_PORT must be in [1, 65535], got %q", port)
}
c.HTTP.Addr = net.JoinHostPort(host, port)
ints := []struct {
key string
dst *int
}{
{"APP_READ_TIMEOUT_MS", &c.HTTP.ReadTimeoutMs},
{"APP_WRITE_TIMEOUT_MS", &c.HTTP.WriteTimeoutMs},
{"APP_IDLE_TIMEOUT_MS", &c.HTTP.IdleTimeoutMs},
{"APP_SHUTDOWN_TIMEOUT_MS", &c.HTTP.ShutdownTimeoutMs},
{"APP_SHUTDOWN_DRAIN_MS", &c.HTTP.ShutdownDrainMs},
{"APP_MAX_INFLIGHT", &c.Limits.MaxInFlight},
{"APP_MAX_MESSAGES", &c.Limits.MaxMessagesGlobal},
{"DB_CONNECT_TIMEOUT_MS", &c.Database.ConnectTimeoutMs},
{"DB_QUERY_TIMEOUT_MS", &c.Database.QueryTimeoutMs},
{"S3_TIMEOUT_MS", &c.S3.TimeoutMs},
{"MAX_CONCURRENT_UPLOADS", &c.Attachments.MaxConcurrentUploads},
{"JANITOR_GRACE_SECONDS", &c.Janitor.GraceSeconds},
{"JANITOR_INTERVAL_SECONDS", &c.Janitor.IntervalSeconds},
{"JANITOR_MAX_DELETES", &c.Janitor.MaxDeletes},
{"CACHE_POOL_SIZE", &c.Cache.PoolSize},
{"CACHE_TIMEOUT_MS", &c.Cache.TimeoutMs},
{"SESSION_TTL_SECONDS", &c.Session.TTLSeconds},
{"IDEMPOTENCY_TTL_SECONDS", &c.Idempotency.TTLSeconds},
{"HISTORY_CACHE_TTL_SECONDS", &c.HistoryCache.PageTTLSeconds},
{"HISTORY_CACHE_TIMEOUT_MS", &c.HistoryCache.TimeoutMs},
{"HISTORY_CACHE_POOL_SIZE", &c.HistoryCache.PoolSize},
{"HISTORY_CACHE_FILL_DELAY_MS", &c.HistoryCache.FillDelayMs},
}
for _, it := range ints {
v, ok := get(it.key)
if !ok {
continue
}
n, err := strconv.Atoi(v)
if err != nil {
return fmt.Errorf("%s: not an integer: %q", it.key, v)
}
*it.dst = n
}
if v, ok := get("APP_MAX_BODY_BYTES"); ok {
n, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return fmt.Errorf("APP_MAX_BODY_BYTES: not an integer: %q", v)
}
c.Limits.MaxBodyBytes = n
}
for _, it := range []struct {
key string
dst *int64
}{
{"MAX_UPLOAD_BYTES", &c.Attachments.MaxUploadBytes},
{"MAX_IMAGE_PIXELS", &c.Attachments.MaxImagePixels},
} {
if v, ok := get(it.key); ok {
n, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return fmt.Errorf("%s: not an integer: %q", it.key, v)
}
*it.dst = n
}
}
if v, ok := get("DB_MAX_CONNS"); ok {
n, err := strconv.ParseInt(v, 10, 32)
if err != nil {
return fmt.Errorf("DB_MAX_CONNS: not an integer: %q", v)
}
c.Database.MaxConns = int32(n)
}
if v, ok := get("DB_ENABLE_BITMAPSCAN"); ok {
b, err := strconv.ParseBool(v)
if err != nil {
return fmt.Errorf("DB_ENABLE_BITMAPSCAN: not a boolean: %q", v)
}
c.Database.EnableBitmapScan = b
}
if v, ok := get("APP_MAX_HEAP_BYTES"); ok {
n, err := strconv.ParseUint(v, 10, 64)
if err != nil {
return fmt.Errorf("APP_MAX_HEAP_BYTES: not a non-negative integer: %q", v)
}
c.Limits.MaxHeapBytes = n
}
return nil
}
+85
View File
@@ -0,0 +1,85 @@
package config
import "testing"
func TestLoad_Defaults(t *testing.T) {
cfg, err := Load()
if err != nil {
t.Fatal(err)
}
if cfg.HTTP.Addr != "0.0.0.0:8080" || cfg.Env != "lab" || cfg.Limits.MaxInFlight != 64 {
t.Errorf("cfg = %+v", cfg)
}
}
func TestLoad_EnvOverridesDefaults(t *testing.T) {
t.Setenv("APP_HOST", "127.0.0.1")
t.Setenv("APP_PORT", "9090")
t.Setenv("APP_ENV", "docker")
t.Setenv("APP_MAX_INFLIGHT", "8")
t.Setenv("APP_MAX_BODY_BYTES", "2048")
cfg, err := Load()
if err != nil {
t.Fatal(err)
}
if cfg.HTTP.Addr != "127.0.0.1:9090" {
t.Errorf("addr = %q, want 127.0.0.1:9090", cfg.HTTP.Addr)
}
if cfg.Env != "docker" {
t.Errorf("env = %q, want docker", cfg.Env)
}
if cfg.Limits.MaxInFlight != 8 || cfg.Limits.MaxBodyBytes != 2048 {
t.Errorf("limits = %+v", cfg.Limits)
}
}
func TestLoad_PortOnlyKeepsDefaultHost(t *testing.T) {
t.Setenv("APP_PORT", "18080")
cfg, err := Load()
if err != nil {
t.Fatal(err)
}
if cfg.HTTP.Addr != "0.0.0.0:18080" {
t.Errorf("addr = %q, want 0.0.0.0:18080", cfg.HTTP.Addr)
}
}
func TestLoad_InstanceID(t *testing.T) {
cfg, err := Load()
if err != nil {
t.Fatal(err)
}
if cfg.InstanceID == "" {
t.Error("default instance id is empty")
}
t.Setenv("APP_INSTANCE_ID", "api-1")
cfg, err = Load()
if err != nil {
t.Fatal(err)
}
if cfg.InstanceID != "api-1" {
t.Errorf("instance id = %q, want api-1", cfg.InstanceID)
}
}
func TestLoad_InvalidEnvFails(t *testing.T) {
for key, val := range map[string]string{
"APP_PORT": "http",
"APP_MAX_INFLIGHT": "many",
"APP_MAX_MESSAGES": "0",
"APP_SHUTDOWN_TIMEOUT_MS": "30000",
"APP_INSTANCE_ID": "bad id",
"APP_SHUTDOWN_DRAIN_MS": "-1",
"IDEMPOTENCY_TTL_SECONDS": "3600",
} {
t.Run(key, func(t *testing.T) {
t.Setenv(key, val)
if _, err := Load(); err == nil {
t.Errorf("%s=%q: expected error", key, val)
}
})
}
}
+11
View File
@@ -0,0 +1,11 @@
package config
type HistoryCache struct {
Mode string
URLFile string
URL string
PageTTLSeconds int
TimeoutMs int
PoolSize int
FillDelayMs int
}
+12
View File
@@ -0,0 +1,12 @@
package config
type HTTP struct {
Addr string
ReadTimeoutMs int
WriteTimeoutMs int
IdleTimeoutMs int
ShutdownTimeoutMs int
// ShutdownDrainMs — сколько после SIGTERM обслуживать запросы, отвечая на readiness 503,
// чтобы балансировщик успел вывести реплику. Должно быть больше времени его обнаружения.
ShutdownDrainMs int
}
+8
View File
@@ -0,0 +1,8 @@
package config
// MinIdempotencyTTLSeconds — контракт требует хранить результат не менее 24 часов.
const MinIdempotencyTTLSeconds = 86400
type Idempotency struct {
TTLSeconds int
}
+8
View File
@@ -0,0 +1,8 @@
package config
type Limits struct {
MaxBodyBytes int64
MaxInFlight int
MaxMessagesGlobal int
MaxHeapBytes uint64
}
+5
View File
@@ -0,0 +1,5 @@
package config
type Logger struct {
Level string
}
+13
View File
@@ -0,0 +1,13 @@
package config
type Session struct {
Store string
TTLSeconds int
}
type Cache struct {
URLFile string
URL string
PoolSize int
TimeoutMs int
}
+39
View File
@@ -0,0 +1,39 @@
package domain
import "time"
// Attachment states are persisted; ready requires both original and thumbnail.
const StatusReady = "ready"
const StatusQueued = "queued"
const (
ContentTypePNG = "image/png"
ContentTypeJPEG = "image/jpeg"
)
type Attachment struct {
ID string
ChatID string
OwnerID string
Filename string
ContentType string
SizeBytes int64
SHA256 string
// ObjectKey — внутренний ключ в bucket, назначает сервер. В публичный API не попадает.
ObjectKey string
Variants []Variant
ErrorCode *string
Status string
CreatedAt time.Time
UpdatedAt time.Time
}
// Variant describes one durable derivative; storage keys stay private.
type Variant struct {
Name string `json:"name"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
Width int `json:"width"`
Height int `json:"height"`
SHA256 string `json:"sha256"`
}
+10
View File
@@ -0,0 +1,10 @@
package domain
import "time"
type Chat struct {
ID string
Title string
MemberIDs []string
CreatedAt time.Time
}
+27
View File
@@ -0,0 +1,27 @@
package domain
import (
"errors"
"fmt"
)
var (
ErrNotFound = errors.New("not found")
ErrUnauthorized = errors.New("unauthorized")
ErrConflict = errors.New("conflict")
// ErrIdempotencyConflict — ключ уже использован с другим телом запроса.
ErrIdempotencyConflict = fmt.Errorf("idempotency key reused with different request: %w", ErrConflict)
ErrInvalidArgument = errors.New("invalid argument")
ErrUnavailable = errors.New("unavailable")
ErrPayloadTooLarge = errors.New("payload too large")
ErrRateLimited = errors.New("rate limited")
ErrUnsupportedMedia = errors.New("unsupported media")
)
+13
View File
@@ -0,0 +1,13 @@
package domain
import "time"
type Message struct {
ID string
ChatID string
AuthorID string
Text string
CreatedAt time.Time
// AttachmentIDs — вложения этого чата в порядке из запроса; без вложений пусто.
AttachmentIDs []string
}
+67
View File
@@ -0,0 +1,67 @@
package domain
import (
"encoding/base64"
"encoding/json"
"time"
"github.com/google/uuid"
)
type Page[T any] struct {
Items []T
NextCursor string
}
type Cursor struct {
CreatedAt time.Time `json:"t"`
ID string `json:"i"`
Scope string `json:"s,omitempty"`
}
func (c Cursor) IsZero() bool {
return c.ID == "" && c.CreatedAt.IsZero()
}
func (c Cursor) Less(createdAt time.Time, id string) bool {
if c.CreatedAt.Before(createdAt) {
return true
}
if c.CreatedAt.After(createdAt) {
return false
}
return c.ID < id
}
func EncodeCursor(c Cursor) string {
if c.IsZero() {
return ""
}
b, _ := json.Marshal(c)
return base64.RawURLEncoding.EncodeToString(b)
}
func DecodeCursor(s string) (Cursor, error) {
if s == "" {
return Cursor{}, nil
}
raw, err := base64.RawURLEncoding.DecodeString(s)
if err != nil {
return Cursor{}, ErrInvalidArgument
}
var c Cursor
if err := json.Unmarshal(raw, &c); err != nil {
return Cursor{}, ErrInvalidArgument
}
if c.CreatedAt.IsZero() || c.Scope == "" {
return Cursor{}, ErrInvalidArgument
}
if _, err := uuid.Parse(c.ID); err != nil || len(c.ID) != 36 {
return Cursor{}, ErrInvalidArgument
}
if EncodeCursor(c) != s {
return Cursor{}, ErrInvalidArgument
}
return c, nil
}
+9
View File
@@ -0,0 +1,9 @@
package domain
import "time"
type Session struct {
Token string
ExpiresAt time.Time
User User
}
+10
View File
@@ -0,0 +1,10 @@
package domain
import "time"
type User struct {
ID string
Username string
DisplayName string
CreatedAt time.Time
}
+128
View File
@@ -0,0 +1,128 @@
// Package imagecheck определяет тип изображения по содержимому и проверяет, что файл целый.
package imagecheck
import (
"bufio"
"bytes"
"context"
"errors"
"fmt"
"image"
"image/jpeg"
"image/png"
"io"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
var (
// ErrUnsupported — не PNG/JPEG либо файл повреждён.
ErrUnsupported = errors.New("imagecheck: not a valid PNG or JPEG")
// ErrTooManyPixels — размеры из заголовка превышают лимит.
ErrTooManyPixels = errors.New("imagecheck: too many pixels")
// ErrBusy — очередь на декодирование не подошла за decodeWait.
ErrBusy = errors.New("imagecheck: decoder is busy")
)
var (
pngMagic = []byte("\x89PNG\r\n\x1a\n")
jpegMagic = []byte{0xff, 0xd8, 0xff}
)
const (
// decodeWait ограничивает ожидание очереди на декодирование. Вместе с записью в S3 и БД ответ
// должен уложиться в timeout server балансировщика (15 с): лучше честный 429, чем 504.
decodeWait = 5 * time.Second
// Файл читается с диска маленькими порциями; буфер убирает лишние системные вызовы.
readBuffer = 64 << 10
)
type format struct {
contentType string
config func(io.Reader) (image.Config, error)
decode func(io.Reader) (image.Image, error)
}
func detect(head []byte) (format, bool) {
switch {
case bytes.HasPrefix(head, pngMagic):
return format{domain.ContentTypePNG, png.DecodeConfig, png.Decode}, true
case bytes.HasPrefix(head, jpegMagic):
return format{domain.ContentTypeJPEG, jpeg.DecodeConfig, jpeg.Decode}, true
}
return format{}, false
}
func read(r io.ReadSeeker) (format, error) {
if _, err := r.Seek(0, io.SeekStart); err != nil {
return format{}, err
}
head := make([]byte, len(pngMagic))
n, err := io.ReadFull(r, head)
if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, io.ErrUnexpectedEOF) {
return format{}, err
}
f, ok := detect(head[:n])
if !ok {
return format{}, ErrUnsupported
}
if _, err := r.Seek(0, io.SeekStart); err != nil {
return format{}, err
}
return f, nil
}
// Checker ограничивает расход памяти на проверку: размеры читаются из заголовка без распаковки,
// а полное декодирование выполняется только в пределах лимита пикселей и по одному за раз.
// Декодирование 40 Мп занимает сотни мегабайт, поэтому параллелить его нельзя.
type Checker struct {
maxPixels int64
decoding chan struct{}
}
func New(maxPixels int64) *Checker {
return &Checker{maxPixels: maxPixels, decoding: make(chan struct{}, 1)}
}
// Inspect определяет истинный Content-Type по сигнатуре и проверяет размеры из заголовка. Пиксели
// не распаковываются, поэтому «бомба» и подмена типа отклоняются почти без затрат.
func (c *Checker) Inspect(r io.ReadSeeker) (string, error) {
f, err := read(r)
if err != nil {
return "", err
}
cfg, err := f.config(bufio.NewReaderSize(r, readBuffer))
if err != nil {
return "", fmt.Errorf("%w: header", ErrUnsupported)
}
if cfg.Width <= 0 || cfg.Height <= 0 {
return "", fmt.Errorf("%w: empty image", ErrUnsupported)
}
if int64(cfg.Width) > c.maxPixels || int64(cfg.Width)*int64(cfg.Height) > c.maxPixels {
return "", ErrTooManyPixels
}
return f.contentType, nil
}
// Decode полностью декодирует файл, уже прошедший Inspect. Результат не нужен: важно, что файл целый.
func (c *Checker) Decode(ctx context.Context, r io.ReadSeeker) error {
timer := time.NewTimer(decodeWait)
defer timer.Stop()
select {
case c.decoding <- struct{}{}:
defer func() { <-c.decoding }()
case <-timer.C:
return ErrBusy
case <-ctx.Done():
return ctx.Err()
}
f, err := read(r)
if err != nil {
return err
}
if _, err := f.decode(bufio.NewReaderSize(r, readBuffer)); err != nil {
return fmt.Errorf("%w: body", ErrUnsupported)
}
return nil
}
+139
View File
@@ -0,0 +1,139 @@
package imagecheck
import (
"bytes"
"context"
"encoding/binary"
"errors"
"hash/crc32"
"image"
"image/color"
"image/jpeg"
"image/png"
"testing"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
func sampleImage(w, h int) image.Image {
img := image.NewRGBA(image.Rect(0, 0, w, h))
for y := range h {
for x := range w {
img.Set(x, y, color.RGBA{uint8(x), uint8(y), 80, 255})
}
}
return img
}
func encodePNG(t *testing.T, w, h int) []byte {
t.Helper()
var b bytes.Buffer
if err := png.Encode(&b, sampleImage(w, h)); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
func encodeJPEG(t *testing.T, w, h int) []byte {
t.Helper()
var b bytes.Buffer
if err := jpeg.Encode(&b, sampleImage(w, h), nil); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
// pngHeaderOnly — сигнатура и IHDR с заданными размерами, без пикселей: так выглядит «бомба».
func pngHeaderOnly(w, h uint32) []byte {
var ihdr bytes.Buffer
ihdr.WriteString("IHDR")
binary.Write(&ihdr, binary.BigEndian, w)
binary.Write(&ihdr, binary.BigEndian, h)
ihdr.Write([]byte{8, 6, 0, 0, 0})
var out bytes.Buffer
out.Write(pngMagic)
binary.Write(&out, binary.BigEndian, uint32(13))
out.Write(ihdr.Bytes())
binary.Write(&out, binary.BigEndian, crc32.ChecksumIEEE(ihdr.Bytes()))
return out.Bytes()
}
// check — обе стадии проверки в том порядке, в каком их вызывает сервис.
func check(ctx context.Context, c *Checker, data []byte) (string, error) {
r := bytes.NewReader(data)
contentType, err := c.Inspect(r)
if err != nil {
return "", err
}
if err := c.Decode(ctx, r); err != nil {
return "", err
}
return contentType, nil
}
func TestCheck(t *testing.T) {
validPNG := encodePNG(t, 20, 10)
validJPEG := encodeJPEG(t, 20, 10)
flipped := bytes.Clone(validPNG)
flipped[len(flipped)/2] ^= 0xff
cases := []struct {
name string
data []byte
want string
wantErr error
}{
{"png", validPNG, domain.ContentTypePNG, nil},
{"jpeg", validJPEG, domain.ContentTypeJPEG, nil},
{"empty", nil, "", ErrUnsupported},
{"text", []byte("<script>alert(1)</script>"), "", ErrUnsupported},
{"gif", []byte("GIF89a\x01\x00\x01\x00\x00\x00\x00;"), "", ErrUnsupported},
{"png magic only", pngMagic, "", ErrUnsupported},
{"jpeg magic only", jpegMagic, "", ErrUnsupported},
{"png truncated", validPNG[:len(validPNG)/2], "", ErrUnsupported},
{"jpeg truncated", validJPEG[:len(validJPEG)/2], "", ErrUnsupported},
{"png byte flipped", flipped, "", ErrUnsupported},
{"png header without pixels", pngHeaderOnly(20, 10), "", ErrUnsupported},
{"png pixel bomb", pngHeaderOnly(100000, 100000), "", ErrTooManyPixels},
}
c := New(1000)
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
got, err := check(context.Background(), c, tc.data)
if !errors.Is(err, tc.wantErr) {
t.Fatalf("err = %v, want %v", err, tc.wantErr)
}
if got != tc.want {
t.Errorf("type = %q, want %q", got, tc.want)
}
})
}
}
func TestCheck_PixelLimitIsInclusive(t *testing.T) {
c := New(200)
if _, err := check(context.Background(), c, encodePNG(t, 20, 10)); err != nil {
t.Errorf("exactly at limit: %v", err)
}
if _, err := check(context.Background(), c, encodePNG(t, 21, 10)); !errors.Is(err, ErrTooManyPixels) {
t.Errorf("over limit: %v", err)
}
}
func TestCheck_CancelledWhileWaitingForDecodeSlot(t *testing.T) {
c := New(1000)
c.decoding <- struct{}{}
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := check(ctx, c, encodePNG(t, 2, 2)); !errors.Is(err, context.Canceled) {
t.Errorf("err = %v, want context.Canceled", err)
}
}
func TestInspect_DoesNotNeedDecodeSlot(t *testing.T) {
c := New(1000)
c.decoding <- struct{}{} // декодер занят, но отказ по заголовку не должен его ждать
if _, err := c.Inspect(bytes.NewReader(pngHeaderOnly(100000, 100000))); !errors.Is(err, ErrTooManyPixels) {
t.Errorf("err = %v, want ErrTooManyPixels", err)
}
}
+133
View File
@@ -0,0 +1,133 @@
// Package janitor находит и удаляет объекты S3 без строки в attachments. Такие объекты появляются,
// если процесс упал между PUT и INSERT или не удалось компенсирующее удаление.
//
// Почему удаление безопасно:
// - Загрузка сначала пишет объект, потом строку, поэтому свежий объект без строки — обычное
// состояние идущей загрузки. Объекты моложе grace period не рассматриваются вовсе.
// - Порядок проверки: листинг, затем запрос в БД. Строка, появившаяся до запроса, защищает объект.
// После запроса строка появиться не может: объект старше grace, а загрузка живёт секунды.
// - Удаление начинается только после полного обхода. Ошибка БД или листинга прерывает проход без
// удалений: «не удалось проверить» никогда не означает «строки нет».
// - Слишком много кандидатов — признак аварии, а не мусора: проход отказывается что-либо удалять.
package janitor
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"time"
"github.com/google/uuid"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
)
const batchSize = 500
// ErrTooManyOrphans — кандидатов больше MaxDeletes, ничего не удалено, нужен оператор.
var ErrTooManyOrphans = errors.New("janitor: too many orphans, nothing deleted")
// Objects — права очистителя в S3: листинг и удаление, чтения содержимого нет.
type Objects interface {
objectstore.Lister
Delete(ctx context.Context, key string) error
}
// Metadata отвечает, на какие ключи есть строка в БД.
type Metadata interface {
ExistingObjectKeys(ctx context.Context, keys []string) (map[string]struct{}, error)
}
type Options struct {
Prefix string
Grace time.Duration
MaxDeletes int
DryRun bool
Now func() time.Time
Logger *slog.Logger
}
// Report — итог прохода. Значения попадают в лог и в доказательства.
type Report struct {
Scanned int `json:"scanned"`
Fresh int `json:"fresh"`
Referenced int `json:"referenced"`
Skipped int `json:"skipped"`
Orphans int `json:"orphans"`
Deleted int `json:"deleted"`
DeleteFailed int `json:"delete_failed"`
DryRun bool `json:"dry_run"`
Elapsed time.Duration `json:"-"`
}
// Run выполняет один проход. Повторный запуск безопасен: удалённый объект просто исчезает из обхода.
func Run(ctx context.Context, objects Objects, metadata Metadata, opts Options) (Report, error) {
started := opts.Now()
report := Report{DryRun: opts.DryRun}
var orphans, batch []string
flush := func() error {
if len(batch) == 0 {
return nil
}
existing, err := metadata.ExistingObjectKeys(ctx, batch)
if err != nil {
return fmt.Errorf("janitor: check metadata: %w", err)
}
for _, key := range batch {
if _, ok := existing[key]; ok {
report.Referenced++
} else {
orphans = append(orphans, key)
}
}
batch = batch[:0]
return nil
}
err := objects.List(ctx, opts.Prefix, func(object objectstore.ObjectInfo) error {
report.Scanned++
// Чужие ключи очиститель не создавал и не трогает.
if _, err := uuid.Parse(strings.TrimPrefix(object.Key, opts.Prefix)); err != nil {
report.Skipped++
return nil
}
// Неизвестное время считается свежим: отсутствие сведений не повод для удаления.
if object.LastModified.IsZero() || opts.Now().Sub(object.LastModified) < opts.Grace {
report.Fresh++
return nil
}
batch = append(batch, object.Key)
if len(batch) == batchSize {
return flush()
}
return nil
})
if err == nil {
err = flush()
}
report.Orphans = len(orphans)
report.Elapsed = opts.Now().Sub(started)
if err != nil {
return report, err
}
if len(orphans) > opts.MaxDeletes {
return report, fmt.Errorf("%w: %d orphans, limit %d", ErrTooManyOrphans, len(orphans), opts.MaxDeletes)
}
if opts.DryRun {
return report, nil
}
for _, key := range orphans {
if err := objects.Delete(ctx, key); err != nil {
report.DeleteFailed++
opts.Logger.Warn("orphan delete failed, will retry on the next pass", slog.String("object_key", key), slog.Any("err", err))
continue
}
report.Deleted++
opts.Logger.Info("orphan deleted", slog.String("object_key", key))
}
report.Elapsed = opts.Now().Sub(started)
return report, nil
}
+186
View File
@@ -0,0 +1,186 @@
package janitor
import (
"context"
"errors"
"io"
"log/slog"
"testing"
"time"
"github.com/google/uuid"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
)
const prefix = "originals/"
var now = time.Date(2026, 11, 4, 12, 0, 0, 0, time.UTC)
type metadata struct {
keys map[string]struct{}
err error
}
func (m *metadata) ExistingObjectKeys(_ context.Context, keys []string) (map[string]struct{}, error) {
if m.err != nil {
return nil, m.err
}
out := map[string]struct{}{}
for _, key := range keys {
if _, ok := m.keys[key]; ok {
out[key] = struct{}{}
}
}
return out, nil
}
func options() Options {
return Options{
Prefix: prefix, Grace: time.Hour, MaxDeletes: 100,
Now: func() time.Time { return now },
Logger: slog.New(slog.NewTextHandler(io.Discard, nil)),
}
}
func key() string { return prefix + uuid.NewString() }
// rig: старый объект без строки, старый со строкой, свежий без строки, чужой старый.
type rig struct {
objects *objectstore.Memory
meta *metadata
orphan, used, fresh, foreign string
}
func newRig() *rig {
r := &rig{objects: objectstore.NewMemory(), orphan: key(), used: key(), fresh: key(), foreign: prefix + "not-a-uuid"}
old := now.Add(-2 * time.Hour)
r.objects.PutAt(r.orphan, []byte("x"), old)
r.objects.PutAt(r.used, []byte("x"), old)
r.objects.PutAt(r.foreign, []byte("x"), old)
r.objects.PutAt(r.fresh, []byte("x"), now.Add(-time.Minute))
r.meta = &metadata{keys: map[string]struct{}{r.used: {}}}
return r
}
func (r *rig) has(key string) bool {
for _, k := range r.objects.Keys() {
if k == key {
return true
}
}
return false
}
func TestRun_DeletesOnlyExpiredOrphans(t *testing.T) {
r := newRig()
report, err := Run(context.Background(), r.objects, r.meta, options())
if err != nil {
t.Fatal(err)
}
if r.has(r.orphan) {
t.Error("expired orphan was kept")
}
if !r.has(r.used) || !r.has(r.fresh) || !r.has(r.foreign) {
t.Errorf("deleted too much: %v", r.objects.Keys())
}
want := Report{Scanned: 4, Fresh: 1, Referenced: 1, Skipped: 1, Orphans: 1, Deleted: 1}
report.Elapsed = 0
if report != want {
t.Errorf("report = %+v, want %+v", report, want)
}
// Повторный проход ничего не меняет.
report, err = Run(context.Background(), r.objects, r.meta, options())
if err != nil || report.Deleted != 0 || report.Orphans != 0 {
t.Errorf("second pass: %+v, %v", report, err)
}
}
func TestRun_GraceBoundaryIsKept(t *testing.T) {
r := newRig()
almost := key()
r.objects.PutAt(almost, []byte("x"), now.Add(-time.Hour+time.Second))
if _, err := Run(context.Background(), r.objects, r.meta, options()); err != nil {
t.Fatal(err)
}
if !r.has(almost) {
t.Error("object younger than grace was deleted")
}
}
func TestRun_UnknownTimeIsTreatedAsFresh(t *testing.T) {
r := newRig()
unknown := key()
r.objects.PutAt(unknown, []byte("x"), time.Time{})
if _, err := Run(context.Background(), r.objects, r.meta, options()); err != nil {
t.Fatal(err)
}
if !r.has(unknown) {
t.Error("object with unknown time was deleted")
}
}
func TestRun_DryRunDeletesNothing(t *testing.T) {
r := newRig()
opts := options()
opts.DryRun = true
report, err := Run(context.Background(), r.objects, r.meta, opts)
if err != nil {
t.Fatal(err)
}
if report.Orphans != 1 || report.Deleted != 0 || !r.has(r.orphan) {
t.Errorf("report = %+v, keys = %v", report, r.objects.Keys())
}
}
func TestRun_MetadataFailureDeletesNothing(t *testing.T) {
r := newRig()
r.meta.err = errors.New("db down")
if _, err := Run(context.Background(), r.objects, r.meta, options()); err == nil {
t.Fatal("expected an error")
}
if !r.has(r.orphan) || !r.has(r.used) {
t.Error("objects were deleted without a metadata check")
}
}
func TestRun_ListFailureIsReported(t *testing.T) {
r := newRig()
r.objects.Down.Store(true)
if _, err := Run(context.Background(), r.objects, r.meta, options()); err == nil {
t.Fatal("expected an error")
}
}
// Пустая БД при полном bucket выглядит как «всё мусор». Это авария, а не повод всё удалить.
func TestRun_TooManyOrphansDeletesNothing(t *testing.T) {
r := newRig()
r.meta.keys = nil
opts := options()
opts.MaxDeletes = 1
report, err := Run(context.Background(), r.objects, r.meta, opts)
if !errors.Is(err, ErrTooManyOrphans) {
t.Fatalf("err = %v", err)
}
if report.Deleted != 0 || !r.has(r.orphan) || !r.has(r.used) {
t.Errorf("report = %+v, keys = %v", report, r.objects.Keys())
}
}
func TestRun_ChecksMetadataInBatches(t *testing.T) {
objects := objectstore.NewMemory()
meta := &metadata{keys: map[string]struct{}{}}
for range batchSize + 7 {
k := key()
objects.PutAt(k, []byte("x"), now.Add(-2*time.Hour))
meta.keys[k] = struct{}{}
}
report, err := Run(context.Background(), objects, meta, options())
if err != nil {
t.Fatal(err)
}
if report.Referenced != batchSize+7 || report.Deleted != 0 {
t.Errorf("report = %+v", report)
}
}
+51
View File
@@ -0,0 +1,51 @@
package logging
import (
"fmt"
"io"
"log/slog"
"os"
"strings"
)
func New(level, env, version string) (*slog.Logger, error) {
lvl, err := parseLevel(level)
if err != nil {
return nil, err
}
return build(os.Stdout, lvl, env, version), nil
}
func build(w io.Writer, lvl slog.Level, env, version string) *slog.Logger {
handler := slog.NewJSONHandler(w, &slog.HandlerOptions{
Level: lvl,
ReplaceAttr: forceUTCTime,
})
return slog.New(handler).With(
slog.String("service", "messenger"),
slog.String("env", env),
slog.String("version", version),
)
}
func forceUTCTime(_ []string, a slog.Attr) slog.Attr {
if a.Value.Kind() == slog.KindTime {
a.Value = slog.TimeValue(a.Value.Time().UTC())
}
return a
}
func parseLevel(s string) (slog.Level, error) {
switch strings.ToLower(strings.TrimSpace(s)) {
case "", "info":
return slog.LevelInfo, nil
case "debug":
return slog.LevelDebug, nil
case "warn", "warning":
return slog.LevelWarn, nil
case "error":
return slog.LevelError, nil
default:
return 0, fmt.Errorf("logging: unknown level %q (want debug|info|warn|error)", s)
}
}
+117
View File
@@ -0,0 +1,117 @@
package objectstore
import (
"bytes"
"context"
"fmt"
"io"
"strings"
"sync"
"sync/atomic"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
// Memory — хранилище для модульных тестов. В работающем приложении не используется.
type Memory struct {
mu sync.Mutex
objects map[string][]byte
modified map[string]time.Time
// Down имитирует недоступность S3.
Down atomic.Bool
}
var (
_ Store = (*Memory)(nil)
_ Lister = (*Memory)(nil)
)
func NewMemory() *Memory {
return &Memory{objects: make(map[string][]byte), modified: make(map[string]time.Time)}
}
func (m *Memory) check() error {
if m.Down.Load() {
return fmt.Errorf("%w: s3 down", domain.ErrUnavailable)
}
return nil
}
func (m *Memory) Put(_ context.Context, key, _ string, body io.Reader, size int64) error {
if err := m.check(); err != nil {
return err
}
data, err := io.ReadAll(body)
if err != nil {
return fmt.Errorf("%w: s3 put: %v", domain.ErrUnavailable, err)
}
if int64(len(data)) != size {
return fmt.Errorf("%w: s3 put: got %d of %d bytes", domain.ErrUnavailable, len(data), size)
}
m.PutAt(key, data, time.Now())
return nil
}
// PutAt кладёт объект с заданным временем: так тест получает объект нужного возраста.
func (m *Memory) PutAt(key string, data []byte, at time.Time) {
m.mu.Lock()
defer m.mu.Unlock()
m.objects[key] = bytes.Clone(data)
m.modified[key] = at
}
func (m *Memory) List(_ context.Context, prefix string, visit func(ObjectInfo) error) error {
if err := m.check(); err != nil {
return err
}
m.mu.Lock()
infos := make([]ObjectInfo, 0, len(m.objects))
for key := range m.objects {
if strings.HasPrefix(key, prefix) {
infos = append(infos, ObjectInfo{Key: key, LastModified: m.modified[key]})
}
}
m.mu.Unlock()
for _, info := range infos {
if err := visit(info); err != nil {
return err
}
}
return nil
}
func (m *Memory) Get(_ context.Context, key string) (io.ReadCloser, int64, error) {
if err := m.check(); err != nil {
return nil, 0, err
}
m.mu.Lock()
defer m.mu.Unlock()
data, ok := m.objects[key]
if !ok {
return nil, 0, ErrNotFound
}
return io.NopCloser(bytes.NewReader(data)), int64(len(data)), nil
}
func (m *Memory) Delete(_ context.Context, key string) error {
if err := m.check(); err != nil {
return err
}
m.mu.Lock()
defer m.mu.Unlock()
delete(m.objects, key)
delete(m.modified, key)
return nil
}
// Keys возвращает ключи объектов для проверок в тестах.
func (m *Memory) Keys() []string {
m.mu.Lock()
defer m.mu.Unlock()
out := make([]string, 0, len(m.objects))
for k := range m.objects {
out = append(out, k)
}
return out
}
+34
View File
@@ -0,0 +1,34 @@
// Package objectstore — хранилище байтов вложений. Интерфейс не зависит от конкретного сервера.
package objectstore
import (
"context"
"errors"
"io"
"time"
)
// ErrNotFound — в bucket нет объекта. Метаданные пишутся после объекта, поэтому для существующего
// вложения это нарушение согласованности, а не обычная ошибка клиента.
var ErrNotFound = errors.New("objectstore: object not found")
// ObjectInfo — то, что очистителю нужно знать об объекте из листинга.
type ObjectInfo struct {
Key string
LastModified time.Time
}
type Store interface {
// Put передаёт объект потоком: size байт из body, без чтения всего файла в память.
Put(ctx context.Context, key, contentType string, body io.Reader, size int64) error
// Get возвращает поток и размер объекта. Поток обязательно закрыть.
Get(ctx context.Context, key string) (io.ReadCloser, int64, error)
Delete(ctx context.Context, key string) error
}
// Lister обходит объекты bucket. Право на листинг есть только у очистителя, поэтому метод вынесен
// из Store: API не может и не должно перечислять объекты.
type Lister interface {
// List вызывает visit для каждого объекта с заданным префиксом.
List(ctx context.Context, prefix string, visit func(ObjectInfo) error) error
}
+251
View File
@@ -0,0 +1,251 @@
package objectstore
import (
"context"
"crypto/hmac"
"crypto/sha256"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"os"
"strings"
"time"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
// S3 работает с любым S3-совместимым сервером; на стенде это SeaweedFS.
type S3 struct {
signingCreds *credentials.Credentials
region string
ticketKey []byte
client *minio.Client
core minio.Core
endpoint string
bucket string
timeout time.Duration
}
var (
_ Store = (*S3)(nil)
_ Lister = (*S3)(nil)
)
// NewS3 только готовит клиента и не обращается к серверу: недоступность S3 при запуске не мешает
// реплике обслуживать пользователей и сообщения.
func NewS3(cfg config.S3) (*S3, error) {
u, err := url.Parse(cfg.Endpoint)
if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") {
return nil, errors.New("objectstore: S3_ENDPOINT must be http(s)://host:port")
}
id, err := readSecret("S3_ACCESS_KEY_ID_FILE", cfg.AccessKeyIDFile)
if err != nil {
return nil, err
}
secret, err := readSecret("S3_SECRET_ACCESS_KEY_FILE", cfg.SecretAccessKeyFile)
if err != nil {
return nil, err
}
client, err := minio.New(u.Host, &minio.Options{
Creds: credentials.NewStaticV4(id, secret, ""),
Secure: u.Scheme == "https",
Region: cfg.Region,
BucketLookup: minio.BucketLookupPath,
})
if err != nil {
return nil, fmt.Errorf("objectstore: client: %w", err)
}
return &S3{
signingCreds: credentials.NewStaticV4(id, secret, ""),
region: cfg.Region,
ticketKey: []byte(secret),
client: client,
core: minio.Core{Client: client},
endpoint: cfg.Endpoint,
bucket: cfg.Bucket,
timeout: time.Duration(cfg.TimeoutMs) * time.Millisecond,
}, nil
}
func readSecret(name, path string) (string, error) {
if path == "" {
return "", fmt.Errorf("objectstore: %s is required", name)
}
b, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("objectstore: read %s: %w", name, err)
}
v := strings.TrimSpace(string(b))
if v == "" {
return "", fmt.Errorf("objectstore: %s is empty", name)
}
return v, nil
}
// unavailable скрывает детали S3 от клиента: наружу уходит только 503.
func unavailable(op string, err error) error {
return fmt.Errorf("%w: s3 %s: %v", domain.ErrUnavailable, op, err)
}
// Put отправляет объект одним запросом и не буферизует его. Multipart выключен намеренно: при обрыве
// одиночного PUT объект не появляется, а незавершённых multipart-загрузок, которые надо отдельно
// искать и отменять, просто не существует.
func (s *S3) Put(ctx context.Context, key, contentType string, body io.Reader, size int64) error {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
info, err := s.client.PutObject(ctx, s.bucket, key, body, size,
minio.PutObjectOptions{ContentType: contentType, DisableMultipart: true})
if err != nil {
return unavailable("put", err)
}
if info.Size != size {
return unavailable("put", fmt.Errorf("stored %d of %d bytes", info.Size, size))
}
return nil
}
// List постранично обходит bucket; размер страницы задаёт сервер, в памяти одна страница.
func (s *S3) List(ctx context.Context, prefix string, visit func(ObjectInfo) error) error {
// Отмена нужна, чтобы при раннем выходе остановить горутину листинга клиента S3.
ctx, cancel := context.WithCancel(ctx)
defer cancel()
for object := range s.client.ListObjects(ctx, s.bucket, minio.ListObjectsOptions{Prefix: prefix, Recursive: true}) {
if object.Err != nil {
return unavailable("list", object.Err)
}
if err := visit(ObjectInfo{Key: object.Key, LastModified: object.LastModified}); err != nil {
return err
}
}
return ctx.Err()
}
func (s *S3) Get(ctx context.Context, key string) (io.ReadCloser, int64, error) {
// Таймаут нужен только на получение ответа: чтение потока ограничивает родительский контекст.
ctx, cancel := context.WithCancel(ctx)
timer := time.AfterFunc(s.timeout, cancel)
body, info, _, err := s.core.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{})
timer.Stop()
if err != nil {
cancel()
if minio.ToErrorResponse(err).Code == "NoSuchKey" {
return nil, 0, ErrNotFound
}
return nil, 0, unavailable("get", err)
}
return &cancelOnClose{ReadCloser: body, cancel: cancel}, info.Size, nil
}
type cancelOnClose struct {
io.ReadCloser
cancel context.CancelFunc
}
func (c *cancelOnClose) Close() error {
defer c.cancel()
return c.ReadCloser.Close()
}
func (s *S3) Delete(ctx context.Context, key string) error {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
if err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{}); err != nil {
return unavailable("delete", err)
}
return nil
}
// EnsureBucket создаёт bucket, если его нет. Повторный запуск ничего не меняет и не трогает объекты.
func (s *S3) EnsureBucket(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
exists, err := s.client.BucketExists(ctx, s.bucket)
if err != nil {
return fmt.Errorf("objectstore: bucket exists: %w", err)
}
if exists {
return nil
}
err = s.client.MakeBucket(ctx, s.bucket, minio.MakeBucketOptions{})
if err != nil && minio.ToErrorResponse(err).Code != "BucketAlreadyOwnedByYou" {
return fmt.Errorf("objectstore: make bucket: %w", err)
}
return nil
}
// RemovePolicy удаляет политику bucket, если она есть, и сообщает, была ли она. Доступ на стенде
// определяют только ключи, поэтому любая политика — чужеродное изменение, а не настройка.
func (s *S3) RemovePolicy(ctx context.Context) (bool, error) {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
policy, err := s.client.GetBucketPolicy(ctx, s.bucket)
if err != nil && minio.ToErrorResponse(err).Code != "NoSuchBucketPolicy" {
return false, fmt.Errorf("objectstore: get policy: %w", err)
}
if policy == "" {
return false, nil
}
if err := s.client.SetBucketPolicy(ctx, s.bucket, ""); err != nil {
return false, fmt.Errorf("objectstore: remove policy: %w", err)
}
return true, nil
}
// CheckPrivate делает запрос без подписи и ожидает отказ. Политику bucket никто не задаёт, поэтому
// приватность — поведение по умолчанию, а эта проверка не даёт запустить стенд, если это не так.
func (s *S3) CheckPrivate(ctx context.Context) error {
ctx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(s.endpoint, "/")+"/"+s.bucket+"/", nil)
if err != nil {
return err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return fmt.Errorf("objectstore: anonymous probe: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusForbidden && resp.StatusCode != http.StatusUnauthorized {
return fmt.Errorf("objectstore: anonymous listing returned %d, bucket is not private", resp.StatusCode)
}
return nil
}
// UploadMAC uses a separate domain from S3 request signatures. Shared credentials
// allow init and complete to run on different replicas without pending DB rows.
func (s *S3) UploadMAC(data []byte) []byte {
h := hmac.New(sha256.New, s.ticketKey)
h.Write([]byte("lab4-upload-ticket-v1\x00"))
h.Write(data)
return h.Sum(nil)
}
func (s *S3) PresignUpload(ctx context.Context, key, contentType string, size int64) (string, error) {
endpoint := os.Getenv("S3_PUBLIC_ENDPOINT")
if endpoint == "" {
endpoint = s.endpoint
}
u, err := url.Parse(endpoint)
if err != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") {
return "", domain.ErrUnavailable
}
// Presign with the public Host from the outset: rewriting a signed URL breaks SigV4.
client, err := minio.New(u.Host, &minio.Options{Creds: s.signingCreds, Secure: u.Scheme == "https", Region: s.region, BucketLookup: minio.BucketLookupPath})
if err != nil {
return "", unavailable("presign", err)
}
headers := http.Header{}
headers.Set("Content-Type", contentType)
headers.Set("Content-Length", fmt.Sprint(size))
signed, err := client.PresignHeader(ctx, http.MethodPut, s.bucket, key, 60*time.Second, nil, headers)
if err != nil {
return "", unavailable("presign", err)
}
return signed.String(), nil
}
+112
View File
@@ -0,0 +1,112 @@
package password
import (
"context"
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
type Params struct {
MemoryKiB uint32
Iterations uint32
Parallelism uint8
SaltLen uint32
KeyLen uint32
}
var Default = Params{
MemoryKiB: 19 * 1024,
Iterations: 2,
Parallelism: 1,
SaltLen: 16,
KeyLen: 32,
}
var ErrMalformedHash = errors.New("password: malformed hash")
var b64 = base64.RawStdEncoding
type Hasher struct {
params Params
slots chan struct{}
}
func NewHasher(p Params, maxConcurrent int) *Hasher {
if maxConcurrent <= 0 {
maxConcurrent = 1
}
return &Hasher{params: p, slots: make(chan struct{}, maxConcurrent)}
}
func (h *Hasher) acquire(ctx context.Context) error {
select {
case h.slots <- struct{}{}:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func (h *Hasher) release() { <-h.slots }
// Hash возвращает PHC-строку Argon2id со случайной солью.
func (h *Hasher) Hash(ctx context.Context, plain string) (string, error) {
salt := make([]byte, h.params.SaltLen)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("password: rand: %w", err)
}
if err := h.acquire(ctx); err != nil {
return "", err
}
defer h.release()
p := h.params
key := argon2.IDKey([]byte(plain), salt, p.Iterations, p.MemoryKiB, p.Parallelism, p.KeyLen)
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version, p.MemoryKiB, p.Iterations, p.Parallelism,
b64.EncodeToString(salt), b64.EncodeToString(key)), nil
}
func (h *Hasher) Verify(ctx context.Context, plain, encoded string) (bool, error) {
p, salt, want, err := decode(encoded)
if err != nil {
return false, err
}
if err := h.acquire(ctx); err != nil {
return false, err
}
defer h.release()
got := argon2.IDKey([]byte(plain), salt, p.Iterations, p.MemoryKiB, p.Parallelism, uint32(len(want)))
return subtle.ConstantTimeCompare(got, want) == 1, nil
}
func decode(encoded string) (Params, []byte, []byte, error) {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[0] != "" || parts[1] != "argon2id" {
return Params{}, nil, nil, ErrMalformedHash
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || version != argon2.Version {
return Params{}, nil, nil, ErrMalformedHash
}
var p Params
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &p.MemoryKiB, &p.Iterations, &p.Parallelism); err != nil {
return Params{}, nil, nil, ErrMalformedHash
}
salt, err := b64.DecodeString(parts[4])
if err != nil || len(salt) == 0 {
return Params{}, nil, nil, ErrMalformedHash
}
key, err := b64.DecodeString(parts[5])
if err != nil || len(key) == 0 {
return Params{}, nil, nil, ErrMalformedHash
}
return p, salt, key, nil
}
+76
View File
@@ -0,0 +1,76 @@
package password
import (
"context"
"errors"
"strings"
"testing"
)
var testParams = Params{MemoryKiB: 64, Iterations: 1, Parallelism: 1, SaltLen: 16, KeyLen: 32}
func TestHashVerify(t *testing.T) {
h := NewHasher(testParams, 2)
ctx := context.Background()
pw := "пароль:с-двоеточием-и-юникодом"
encoded, err := h.Hash(ctx, pw)
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(encoded, "$argon2id$v=19$m=64,t=1,p=1$") {
t.Errorf("unexpected format %q", encoded)
}
if strings.Contains(encoded, pw) {
t.Error("hash contains plaintext")
}
ok, err := h.Verify(ctx, pw, encoded)
if err != nil || !ok {
t.Errorf("Verify(correct) = %v, %v", ok, err)
}
ok, err = h.Verify(ctx, pw+"x", encoded)
if err != nil || ok {
t.Errorf("Verify(wrong) = %v, %v", ok, err)
}
}
func TestHash_RandomSalt(t *testing.T) {
h := NewHasher(testParams, 1)
a, _ := h.Hash(context.Background(), "same-password-123")
b, _ := h.Hash(context.Background(), "same-password-123")
if a == b {
t.Error("two hashes of the same password are equal: salt is not random")
}
}
func TestVerify_UsesParamsFromHash(t *testing.T) {
old := NewHasher(testParams, 1)
encoded, _ := old.Hash(context.Background(), "long-enough-password")
stronger := testParams
stronger.Iterations = 3
ok, err := NewHasher(stronger, 1).Verify(context.Background(), "long-enough-password", encoded)
if err != nil || !ok {
t.Errorf("old hash must verify after params change: %v, %v", ok, err)
}
}
func TestVerify_Malformed(t *testing.T) {
h := NewHasher(testParams, 1)
for _, s := range []string{"", "!", "$argon2i$v=19$m=64,t=1,p=1$AAAA$AAAA", "$argon2id$v=19$m=64$AAAA$AAAA"} {
if _, err := h.Verify(context.Background(), "x", s); !errors.Is(err, ErrMalformedHash) {
t.Errorf("Verify(%q) err = %v, want ErrMalformedHash", s, err)
}
}
}
func TestHash_RespectsContextWhenBusy(t *testing.T) {
h := NewHasher(testParams, 1)
h.slots <- struct{}{} // единственный слот занят
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := h.Hash(ctx, "long-enough-password"); !errors.Is(err, context.Canceled) {
t.Errorf("err = %v, want context.Canceled", err)
}
}
+290
View File
@@ -0,0 +1,290 @@
package service
import (
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"io"
"log/slog"
"mime"
"os"
"time"
"github.com/google/uuid"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/imagecheck"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
var _ AttachmentsService = (*Attachments)(nil)
// ObjectKeyPrefix — префикс ключей оригиналов. Очиститель обходит только его.
const ObjectKeyPrefix = "originals/"
// Предел на компенсирующее удаление объекта, когда запись метаданных не удалась.
const compensationTimeout = 5 * time.Second
type AttachmentLimits struct {
MaxUploadBytes int64
MaxImagePixels int64
MaxConcurrentUploads int
}
type attachmentRepo interface {
store.ChatStore
store.AttachmentStore
}
type Attachments struct {
repo attachmentRepo
objects objectstore.Store
limits AttachmentLimits
checker *imagecheck.Checker
// uploads — слоты загрузок. Вместе с лимитом размера они ограничивают диск реплики под временные
// файлы; память на одну загрузку от размера файла не зависит.
uploads chan struct{}
logger *slog.Logger
}
func NewAttachments(repo attachmentRepo, objects objectstore.Store, limits AttachmentLimits, logger *slog.Logger) *Attachments {
return &Attachments{
repo: repo,
objects: objects,
limits: limits,
checker: imagecheck.New(limits.MaxImagePixels),
uploads: make(chan struct{}, limits.MaxConcurrentUploads),
logger: logger,
}
}
// Upload выполняет проверки от дешёвых к дорогим: доступ, параметры, заявленный размер и только
// потом чтение тела. Тело идёт потоком во временный файл, из него в декодер и в S3, поэтому в памяти
// файл целиком не лежит. Порядок записи: сначала объект, затем метаданные, поэтому строка в БД
// ссылается на устойчивый staging; 202 означает сохранённый оригинал и намерение обработки.
func (a *Attachments) Upload(ctx context.Context, in UploadInput) (domain.Attachment, error) {
chatID, err := validate.CanonicalUUID("chat_id", in.ChatID)
if err != nil {
return domain.Attachment{}, err
}
if _, err := a.repo.ChatByID(ctx, in.CallerID, chatID); err != nil {
return domain.Attachment{}, err
}
if err := validate.Filename(in.Filename); err != nil {
return domain.Attachment{}, err
}
declared, err := parseImageType(in.ContentType)
if err != nil {
return domain.Attachment{}, err
}
if in.ContentLength > a.limits.MaxUploadBytes {
return domain.Attachment{}, domain.ErrPayloadTooLarge
}
select {
case a.uploads <- struct{}{}:
defer func() { <-a.uploads }()
default:
return domain.Attachment{}, domain.ErrRateLimited
}
spool, size, sum, err := a.spoolBody(in.Body)
if err != nil {
return domain.Attachment{}, err
}
defer spool.Close()
if err := a.checkImage(ctx, spool, declared); err != nil {
return domain.Attachment{}, err
}
if _, err := spool.Seek(0, io.SeekStart); err != nil {
return domain.Attachment{}, fmt.Errorf("%w: spool: %v", domain.ErrUnavailable, err)
}
id := uuid.NewString()
att := domain.Attachment{
ID: id,
ChatID: chatID,
OwnerID: in.CallerID,
Filename: in.Filename,
ContentType: declared,
SizeBytes: size,
SHA256: sum,
ObjectKey: "staging/" + id,
Status: domain.StatusQueued,
}
if err := a.objects.Put(ctx, att.ObjectKey, att.ContentType, spool, size); err != nil {
// Объект мог успеть сохраниться. Удалять его здесь бессмысленно: при недоступном S3 удаление
// тоже не пройдёт, а клиент лишние секунды ждал бы ответа. Его уберёт очиститель.
a.logger.Warn("attachment object put failed", slog.Any("err", err))
return domain.Attachment{}, err
}
saved, err := a.repo.CreateAttachment(ctx, att)
if err != nil {
a.compensate(ctx, att)
return domain.Attachment{}, err
}
return saved, nil
}
// checkImage сравнивает заявленный тип с настоящим до декодирования: подмена типа не тратит память.
func (a *Attachments) checkImage(ctx context.Context, file io.ReadSeeker, declared string) error {
detected, err := a.checker.Inspect(file)
if err == nil && detected != declared {
return domain.ErrUnsupportedMedia
}
if err == nil {
err = a.checker.Decode(ctx, file)
}
switch {
case err == nil:
return nil
case errors.Is(err, imagecheck.ErrTooManyPixels):
return domain.ErrPayloadTooLarge
case errors.Is(err, imagecheck.ErrUnsupported):
return domain.ErrUnsupportedMedia
case errors.Is(err, imagecheck.ErrBusy):
return domain.ErrRateLimited
}
return fmt.Errorf("%w: image check: %v", domain.ErrUnavailable, err)
}
// compensate убирает объект, для которого метаданные не сохранились. Контекст отвязан от запроса:
// клиент мог уже отключиться. Удалять можно, только убедившись, что строки нет: ошибка INSERT не
// доказывает отсутствие записи (COMMIT мог пройти, а ответ потеряться), и удаление оставило бы
// подтверждённую строку без файла. Если проверить нельзя, объект остаётся очистителю: он удаляет
// только объекты без строки и только после grace period (cmd/janitor).
func (a *Attachments) compensate(ctx context.Context, att domain.Attachment) {
ctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), compensationTimeout)
defer cancel()
exists, err := a.repo.AttachmentExists(ctx, att.ID)
if err != nil {
a.logger.Warn("orphan check failed, object is left to the janitor", slog.String("object_key", att.ObjectKey), slog.Any("err", err))
return
}
if exists {
a.logger.Warn("metadata write reported an error but the row exists, object is kept", slog.String("attachment_id", att.ID))
return
}
if err := a.objects.Delete(ctx, att.ObjectKey); err != nil {
a.logger.Warn("compensating delete failed, object is left to the janitor", slog.String("object_key", att.ObjectKey), slog.Any("err", err))
}
}
// spoolBody пишет тело во временный файл и считает SHA-256 на лету. Файл удаляется из каталога сразу
// после создания: данные живут, пока он открыт, поэтому при любом завершении, даже kill -9, на диске
// ничего не остаётся и отдельная уборка не нужна. Это не хранилище: 202 вернётся только после S3 и PostgreSQL.
func (a *Attachments) spoolBody(body io.Reader) (*os.File, int64, string, error) {
file, err := os.CreateTemp("", "upload-*")
if err != nil {
return nil, 0, "", fmt.Errorf("%w: spool: %v", domain.ErrUnavailable, err)
}
if err := os.Remove(file.Name()); err != nil {
file.Close()
return nil, 0, "", fmt.Errorf("%w: spool: %v", domain.ErrUnavailable, err)
}
hash := sha256.New()
source := &errorTrackingReader{r: body}
// LimitReader на байт больше лимита: так отличается файл ровно на границе от файла больше неё.
n, err := io.Copy(io.MultiWriter(file, hash), io.LimitReader(source, a.limits.MaxUploadBytes+1))
switch {
case source.err != nil:
file.Close()
// Клиент оборвал передачу или не уложился в таймаут. Отвечать чаще всего уже некому.
return nil, 0, "", &validate.Error{Field: "body", Reason: "cannot read body"}
case err != nil:
file.Close()
return nil, 0, "", fmt.Errorf("%w: spool: %v", domain.ErrUnavailable, err)
case n > a.limits.MaxUploadBytes:
file.Close()
return nil, 0, "", domain.ErrPayloadTooLarge
}
return file, n, hex.EncodeToString(hash.Sum(nil)), nil
}
// errorTrackingReader отделяет ошибку чтения от клиента (400) от ошибки записи на диск (503).
type errorTrackingReader struct {
r io.Reader
err error
}
func (e *errorTrackingReader) Read(p []byte) (int, error) {
n, err := e.r.Read(p)
if err != nil && !errors.Is(err, io.EOF) {
e.err = err
}
return n, err
}
func parseImageType(header string) (string, error) {
mediaType, _, err := mime.ParseMediaType(header)
if err != nil {
return "", domain.ErrUnsupportedMedia
}
switch mediaType {
case domain.ContentTypePNG, domain.ContentTypeJPEG:
return mediaType, nil
}
return "", domain.ErrUnsupportedMedia
}
func (a *Attachments) Get(ctx context.Context, callerID, attachmentID string) (domain.Attachment, error) {
id, err := validate.CanonicalUUID("attachment_id", attachmentID)
if err != nil {
return domain.Attachment{}, err
}
return a.repo.AttachmentForMember(ctx, callerID, id)
}
func (a *Attachments) Content(ctx context.Context, callerID, attachmentID, variant string) (domain.Attachment, io.ReadCloser, error) {
if err := validateVariantName(variant); err != nil {
return domain.Attachment{}, nil, err
}
att, err := a.Get(ctx, callerID, attachmentID)
if err != nil {
return domain.Attachment{}, nil, err
}
if att.Status != domain.StatusReady {
return domain.Attachment{}, nil, domain.ErrConflict
}
if variant != VariantOriginal {
found := false
for _, v := range att.Variants {
if v.Name == variant {
att.ObjectKey = "variants/" + att.ID + "/v1/" + variant
att.ContentType, att.SizeBytes, att.SHA256 = v.ContentType, v.SizeBytes, v.SHA256
found = true
break
}
}
if !found {
return domain.Attachment{}, nil, domain.ErrNotFound
}
}
body, size, err := a.objects.Get(ctx, att.ObjectKey)
if err != nil {
if errors.Is(err, objectstore.ErrNotFound) {
return domain.Attachment{}, nil, fmt.Errorf("attachment %s: object missing in bucket", att.ID)
}
a.logger.Warn("attachment object get failed", slog.Any("err", err))
return domain.Attachment{}, nil, err
}
if size != att.SizeBytes {
body.Close()
return domain.Attachment{}, nil, fmt.Errorf("attachment %s: object size %d differs from metadata %d", att.ID, size, att.SizeBytes)
}
return att, body, nil
}
func validateVariantName(variant string) error {
switch variant {
case VariantOriginal, "thumbnail", "crop", "optimized":
return nil
}
return &validate.Error{Field: "variant", Reason: "unknown variant"}
}
+101
View File
@@ -0,0 +1,101 @@
package service
import (
"context"
"errors"
"fmt"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/password"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/session"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/token"
)
var (
_ AuthService = (*Auth)(nil)
)
type Auth struct {
users store.UserStore
sessions session.Store
hasher *password.Hasher
ttl time.Duration
now func() time.Time
dummyHash string
}
func NewAuth(users store.UserStore, sessions session.Store, hasher *password.Hasher, ttl time.Duration) (*Auth, error) {
dummy, err := hasher.Hash(context.Background(), "dummy-password-for-timing")
if err != nil {
return nil, fmt.Errorf("auth: dummy hash: %w", err)
}
return &Auth{
users: users,
sessions: sessions,
hasher: hasher,
ttl: ttl,
now: time.Now,
dummyHash: dummy,
}, nil
}
func (a *Auth) Login(ctx context.Context, username, plainPassword string) (domain.Session, error) {
user, hash, err := a.users.CredentialsByUsername(ctx, username)
switch {
case errors.Is(err, domain.ErrNotFound):
_, _ = a.hasher.Verify(ctx, plainPassword, a.dummyHash)
return domain.Session{}, domain.ErrUnauthorized
case err != nil:
return domain.Session{}, err
}
ok, err := a.hasher.Verify(ctx, plainPassword, hash)
if err != nil {
if errors.Is(err, password.ErrMalformedHash) {
return domain.Session{}, domain.ErrUnauthorized
}
return domain.Session{}, err
}
if !ok {
return domain.Session{}, domain.ErrUnauthorized
}
plain, tokenHash, err := token.New()
if err != nil {
return domain.Session{}, err
}
expiresAt := a.now().Add(a.ttl).UTC().Truncate(time.Second)
if err := a.sessions.Save(ctx, tokenHash, session.Session{UserID: user.ID, ExpiresAt: expiresAt}); err != nil {
return domain.Session{}, err
}
return domain.Session{Token: plain, ExpiresAt: expiresAt, User: user}, nil
}
func (a *Auth) Authenticate(ctx context.Context, plainToken string) (string, error) {
tokenHash, err := token.Parse(plainToken)
if err != nil {
return "", domain.ErrUnauthorized
}
s, err := a.sessions.Get(ctx, tokenHash)
if errors.Is(err, session.ErrNotFound) {
return "", domain.ErrUnauthorized
}
if err != nil {
return "", err
}
if !a.now().Before(s.ExpiresAt) {
return "", domain.ErrUnauthorized
}
return s.UserID, nil
}
func (a *Auth) Logout(ctx context.Context, plainToken string) error {
tokenHash, err := token.Parse(plainToken)
if err != nil {
return domain.ErrUnauthorized
}
return a.sessions.Delete(ctx, tokenHash)
}
+47
View File
@@ -0,0 +1,47 @@
package service
import (
"context"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
var (
_ ChatsService = (*Chats)(nil)
)
type Chats struct {
store store.ChatStore
}
func NewChats(s store.ChatStore) *Chats {
return &Chats{store: s}
}
func (c *Chats) Create(ctx context.Context, callerID, title string, memberIDs []string) (domain.Chat, error) {
if err := validate.ChatTitle(title); err != nil {
return domain.Chat{}, err
}
memberIDs, err := validate.MemberIDs(memberIDs, callerID)
if err != nil {
return domain.Chat{}, err
}
return c.store.CreateChat(ctx, callerID, title, memberIDs)
}
func (c *Chats) Get(ctx context.Context, callerID, chatID string) (domain.Chat, error) {
chatID, err := validate.CanonicalUUID("chat_id", chatID)
if err != nil {
return domain.Chat{}, err
}
return c.store.ChatByID(ctx, callerID, chatID)
}
func (c *Chats) List(ctx context.Context, callerID, cursor string, limit int) (domain.Page[domain.Chat], error) {
if err := validate.Limit(limit); err != nil {
return domain.Page[domain.Chat]{}, err
}
return c.store.ListChats(ctx, callerID, cursor, limit)
}
+177
View File
@@ -0,0 +1,177 @@
package service
import (
"context"
"crypto/hmac"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"io"
"strings"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
"github.com/google/uuid"
)
// A ticket is authenticated, not encrypted. No user-supplied object key is accepted.
// Staging keys share the janitor's UUID namespace; they never have metadata.
type directSigner interface {
UploadMAC([]byte) []byte
PresignUpload(context.Context, string, string, int64) (string, error)
}
type DirectInput struct {
Filename string `json:"filename"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
SHA256 string `json:"sha256"`
}
type directTicket struct {
Input DirectInput
ID string
Staging string
Owner string
Chat string
Expires int64
}
type DirectUpload struct {
URL string `json:"url"`
Token string `json:"token"`
ExpiresIn int `json:"expires_in"`
Headers map[string]string `json:"headers"`
}
func (a *Attachments) InitDirect(ctx context.Context, caller, chat string, in DirectInput) (DirectUpload, error) {
chat, err := validate.CanonicalUUID("chat_id", chat)
if err != nil {
return DirectUpload{}, err
}
if _, err = a.repo.ChatByID(ctx, caller, chat); err != nil {
return DirectUpload{}, err
}
if err = validate.Filename(in.Filename); err != nil {
return DirectUpload{}, err
}
if in.ContentType != domain.ContentTypePNG && in.ContentType != domain.ContentTypeJPEG {
return DirectUpload{}, domain.ErrUnsupportedMedia
}
in.ContentType, err = parseImageType(in.ContentType)
if err != nil {
return DirectUpload{}, err
}
if in.SizeBytes > a.limits.MaxUploadBytes {
return DirectUpload{}, domain.ErrPayloadTooLarge
}
sum, err := hex.DecodeString(in.SHA256)
if in.SizeBytes <= 0 || err != nil || len(sum) != 32 {
return DirectUpload{}, domain.ErrInvalidArgument
}
in.SHA256 = strings.ToLower(in.SHA256)
signer, ok := a.objects.(directSigner)
if !ok {
return DirectUpload{}, domain.ErrUnavailable
}
ticket := directTicket{Input: in, ID: uuid.NewString(), Staging: ObjectKeyPrefix + uuid.NewString(), Owner: caller, Chat: chat, Expires: time.Now().Add(2 * time.Minute).Unix()}
data, err := json.Marshal(ticket)
if err != nil {
return DirectUpload{}, err
}
url, err := signer.PresignUpload(ctx, ticket.Staging, in.ContentType, in.SizeBytes)
if err != nil {
return DirectUpload{}, err
}
token := base64.RawURLEncoding.EncodeToString(data) + "." + base64.RawURLEncoding.EncodeToString(signer.UploadMAC(data))
return DirectUpload{URL: url, Token: token, ExpiresIn: 60, Headers: map[string]string{"Content-Type": in.ContentType}}, nil
}
func (a *Attachments) CompleteDirect(ctx context.Context, caller, chat, token string) (domain.Attachment, error) {
signer, ok := a.objects.(directSigner)
if !ok {
return domain.Attachment{}, domain.ErrUnavailable
}
parts := strings.Split(token, ".")
if len(parts) != 2 || len(token) > 4096 {
return domain.Attachment{}, domain.ErrInvalidArgument
}
data, err := base64.RawURLEncoding.DecodeString(parts[0])
if err != nil {
return domain.Attachment{}, domain.ErrInvalidArgument
}
mac, err := base64.RawURLEncoding.DecodeString(parts[1])
if err != nil || !hmac.Equal(mac, signer.UploadMAC(data)) {
return domain.Attachment{}, domain.ErrInvalidArgument
}
var t directTicket
if json.Unmarshal(data, &t) != nil {
return domain.Attachment{}, domain.ErrInvalidArgument
}
if t.Owner != caller || t.Chat != chat {
return domain.Attachment{}, domain.ErrNotFound
}
if _, err := a.repo.ChatByID(ctx, caller, chat); err != nil {
return domain.Attachment{}, err
}
// Retry is idempotent, including a retry after an uncertain database COMMIT.
if att, err := a.repo.AttachmentForMember(ctx, caller, t.ID); err == nil {
return att, nil
} else if !errors.Is(err, domain.ErrNotFound) {
return domain.Attachment{}, err
}
if time.Now().Unix() >= t.Expires {
return domain.Attachment{}, domain.ErrConflict
}
select {
case a.uploads <- struct{}{}:
defer func() { <-a.uploads }()
default:
return domain.Attachment{}, domain.ErrRateLimited
}
body, size, err := a.objects.Get(ctx, t.Staging)
if errors.Is(err, objectstore.ErrNotFound) {
return domain.Attachment{}, domain.ErrConflict
}
if err != nil {
return domain.Attachment{}, err
}
defer body.Close()
if size != t.Input.SizeBytes {
return domain.Attachment{}, domain.ErrInvalidArgument
}
file, actual, sum, err := a.spoolBody(body)
if err != nil {
return domain.Attachment{}, err
}
defer file.Close()
if actual != size || sum != t.Input.SHA256 {
return domain.Attachment{}, domain.ErrInvalidArgument
}
if err = a.checkImage(ctx, file, t.Input.ContentType); err != nil {
return domain.Attachment{}, err
}
if _, err = file.Seek(0, io.SeekStart); err != nil {
return domain.Attachment{}, domain.ErrUnavailable
}
// A unique permanent key per attempt prevents a concurrent failed attempt from
// deleting an object saved by another complete. Clients can write only staging.
att := domain.Attachment{ID: t.ID, ChatID: chat, OwnerID: caller, Filename: t.Input.Filename, ContentType: t.Input.ContentType, SizeBytes: size, SHA256: sum, ObjectKey: ObjectKeyPrefix + uuid.NewString(), Status: domain.StatusReady}
if err = a.objects.Put(ctx, att.ObjectKey, att.ContentType, file, size); err != nil {
return domain.Attachment{}, err
}
saved, err := a.repo.CreateAttachment(ctx, att)
if err != nil {
// Leave unreferenced keys to the janitor: an uncertain COMMIT must not delete data.
if existing, lookup := a.repo.AttachmentForMember(ctx, caller, t.ID); lookup == nil {
return existing, nil
}
return domain.Attachment{}, err
}
// Keep staging until expiry/grace: deleting while its PUT URL is valid allows
// recreation anyway. The janitor reclaims abandoned and completed staging alike.
return saved, nil
}
@@ -0,0 +1,87 @@
package service
import (
"bytes"
"context"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"io"
"log/slog"
"testing"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/janitor"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
)
type signedMemory struct{ *objectstore.Memory }
func (s signedMemory) UploadMAC(b []byte) []byte {
h := sha256.Sum256(append([]byte("test-key"), b...))
return h[:]
}
func (s signedMemory) PresignUpload(_ context.Context, key, _ string, _ int64) (string, error) {
return key, nil
}
func TestDirectSizeExpiryAndCleanup(t *testing.T) {
ctx := context.Background()
repo := store.New()
alice, err := repo.CreateUser(ctx, "alice", "Alice", "hash")
if err != nil {
t.Fatal(err)
}
chat, err := repo.CreateChat(ctx, alice.ID, "chat", []string{alice.ID})
if err != nil {
t.Fatal(err)
}
objects := signedMemory{objectstore.NewMemory()}
logger := slog.New(slog.NewTextHandler(io.Discard, nil))
svc := NewAttachments(repo, objects, AttachmentLimits{MaxUploadBytes: 1024, MaxImagePixels: 100, MaxConcurrentUploads: 2}, logger)
data := []byte("1234")
sum := sha256.Sum256(data)
u, err := svc.InitDirect(ctx, alice.ID, chat.ID, DirectInput{Filename: "x.png", ContentType: "image/png", SizeBytes: 4, SHA256: hex.EncodeToString(sum[:])})
if err != nil {
t.Fatal(err)
}
objects.PutAt(u.URL, data[:3], time.Now())
if _, err = svc.CompleteDirect(ctx, alice.ID, chat.ID, u.Token); !errors.Is(err, domain.ErrInvalidArgument) {
t.Fatalf("wrong size: %v", err)
}
// Expire a correctly authenticated ticket without sleeping in a unit test.
encoded := bytes.Split([]byte(u.Token), []byte("."))[0]
raw, _ := base64.RawURLEncoding.DecodeString(string(encoded))
var ticket directTicket
if err = json.Unmarshal(raw, &ticket); err != nil {
t.Fatal(err)
}
ticket.Expires = time.Now().Add(-time.Second).Unix()
raw, _ = json.Marshal(ticket)
token := base64.RawURLEncoding.EncodeToString(raw) + "." + base64.RawURLEncoding.EncodeToString(objects.UploadMAC(raw))
if _, err = svc.CompleteDirect(ctx, alice.ID, chat.ID, token); !errors.Is(err, domain.ErrConflict) {
t.Fatalf("expired: %v", err)
}
future := time.Now().Add(6 * time.Minute)
report, err := janitor.Run(ctx, objects, noMetadata{}, janitor.Options{Prefix: ObjectKeyPrefix, Grace: 5 * time.Minute, MaxDeletes: 100, Now: func() time.Time { return future }, Logger: logger})
if err != nil || report.Deleted != 1 {
t.Fatalf("cleanup: %+v %v", report, err)
}
if _, _, err = objects.Get(ctx, u.URL); !errors.Is(err, objectstore.ErrNotFound) {
t.Fatalf("abandoned staging remains: %v", err)
}
report, err = janitor.Run(ctx, objects, noMetadata{}, janitor.Options{Prefix: ObjectKeyPrefix, Grace: 5 * time.Minute, MaxDeletes: 100, Now: func() time.Time { return future }, Logger: logger})
if err != nil || report.Deleted != 0 {
t.Fatalf("repeat cleanup: %+v %v", report, err)
}
}
type noMetadata struct{}
func (noMetadata) ExistingObjectKeys(context.Context, []string) (map[string]struct{}, error) {
return map[string]struct{}{}, nil
}
+50
View File
@@ -0,0 +1,50 @@
package service
import (
"context"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
var (
_ MessagesService = (*Messages)(nil)
)
type Messages struct {
store store.MessageStore
}
func NewMessages(s store.MessageStore) *Messages {
return &Messages{store: s}
}
func (m *Messages) Send(ctx context.Context, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error) {
chatID, err := validate.CanonicalUUID("chat_id", chatID)
if err != nil {
return domain.Message{}, err
}
if err := validate.IdempotencyKey(idempotencyKey); err != nil {
return domain.Message{}, err
}
ids, err := validate.AttachmentIDs(attachmentIDs)
if err != nil {
return domain.Message{}, err
}
if err := validate.MessageText(text, len(ids) > 0); err != nil {
return domain.Message{}, err
}
return m.store.AddMessage(ctx, callerID, chatID, idempotencyKey, text, ids)
}
func (m *Messages) List(ctx context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
chatID, err := validate.CanonicalUUID("chat_id", chatID)
if err != nil {
return domain.Page[domain.Message]{}, err
}
if err := validate.Limit(limit); err != nil {
return domain.Page[domain.Message]{}, err
}
return m.store.ListMessages(ctx, callerID, chatID, cursor, limit)
}
+50
View File
@@ -0,0 +1,50 @@
package service
import (
"context"
"io"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
type UsersService interface {
Register(ctx context.Context, username, displayName, password string) (domain.User, error)
Me(ctx context.Context, callerID string) (domain.User, error)
}
type ChatsService interface {
Create(ctx context.Context, callerID, title string, memberIDs []string) (domain.Chat, error)
Get(ctx context.Context, callerID, chatID string) (domain.Chat, error)
List(ctx context.Context, callerID, cursor string, limit int) (domain.Page[domain.Chat], error)
}
type MessagesService interface {
Send(ctx context.Context, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error)
List(ctx context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error)
}
// VariantOriginal — вариант содержимого по умолчанию.
const VariantOriginal = "original"
// UploadInput — параметры загрузки файла. Body читается не дальше лимита размера.
type UploadInput struct {
CallerID string
ChatID string
Filename string
ContentType string
ContentLength int64
Body io.Reader
}
type AttachmentsService interface {
Upload(ctx context.Context, in UploadInput) (domain.Attachment, error)
Get(ctx context.Context, callerID, attachmentID string) (domain.Attachment, error)
// Content возвращает метаданные и поток байтов. Поток обязательно закрыть.
Content(ctx context.Context, callerID, attachmentID, variant string) (domain.Attachment, io.ReadCloser, error)
}
type AuthService interface {
Login(ctx context.Context, username, password string) (domain.Session, error)
Authenticate(ctx context.Context, token string) (userID string, err error)
Logout(ctx context.Context, token string) error
}
+44
View File
@@ -0,0 +1,44 @@
package service
import (
"context"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/password"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate"
)
var (
_ UsersService = (*Users)(nil)
)
type Users struct {
store store.UserStore
hasher *password.Hasher
}
func NewUsers(s store.UserStore, h *password.Hasher) *Users {
return &Users{store: s, hasher: h}
}
func (u *Users) Register(ctx context.Context, username, displayName, plainPassword string) (domain.User, error) {
if err := validate.Username(username); err != nil {
return domain.User{}, err
}
if err := validate.DisplayName(displayName); err != nil {
return domain.User{}, err
}
if err := validate.Password(plainPassword); err != nil {
return domain.User{}, err
}
hash, err := u.hasher.Hash(ctx, plainPassword)
if err != nil {
return domain.User{}, err
}
return u.store.CreateUser(ctx, username, displayName, hash)
}
func (u *Users) Me(ctx context.Context, callerID string) (domain.User, error) {
return u.store.UserByID(ctx, callerID)
}
+49
View File
@@ -0,0 +1,49 @@
package session
import (
"context"
"sync"
"time"
)
var _ Store = (*Memory)(nil)
type Memory struct {
mu sync.Mutex
sessions map[string]Session
now func() time.Time
}
func NewMemory() *Memory {
return &Memory{sessions: make(map[string]Session), now: time.Now}
}
func (m *Memory) Save(_ context.Context, tokenHash []byte, s Session) error {
m.mu.Lock()
defer m.mu.Unlock()
m.sessions[string(tokenHash)] = s
return nil
}
func (m *Memory) Get(_ context.Context, tokenHash []byte) (Session, error) {
m.mu.Lock()
defer m.mu.Unlock()
s, ok := m.sessions[string(tokenHash)]
if !ok {
return Session{}, ErrNotFound
}
if !m.now().Before(s.ExpiresAt) {
delete(m.sessions, string(tokenHash))
return Session{}, ErrNotFound
}
return s, nil
}
func (m *Memory) Delete(_ context.Context, tokenHash []byte) error {
m.mu.Lock()
defer m.mu.Unlock()
delete(m.sessions, string(tokenHash))
return nil
}
func (m *Memory) Ping(context.Context) error { return nil }
+21
View File
@@ -0,0 +1,21 @@
package session
import (
"context"
"errors"
"time"
)
type Session struct {
UserID string `json:"user_id"`
ExpiresAt time.Time `json:"expires_at"`
}
var ErrNotFound = errors.New("session: not found")
type Store interface {
Save(ctx context.Context, tokenHash []byte, s Session) error
Get(ctx context.Context, tokenHash []byte) (Session, error)
Delete(ctx context.Context, tokenHash []byte) error
Ping(ctx context.Context) error
}
+120
View File
@@ -0,0 +1,120 @@
package session
import (
"context"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"os"
"strings"
"time"
"github.com/redis/go-redis/v9"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
var _ Store = (*Valkey)(nil)
const keyPrefix = "session:"
type Valkey struct {
client *redis.Client
}
func NewValkey(client *redis.Client) *Valkey {
return &Valkey{client: client}
}
func Connect(ctx context.Context, cfg config.Cache) (*redis.Client, error) {
url, err := urlFrom(cfg)
if err != nil {
return nil, err
}
opts, err := redis.ParseURL(url)
if err != nil {
return nil, errors.New("session: invalid CACHE_URL")
}
timeout := time.Duration(cfg.TimeoutMs) * time.Millisecond
opts.PoolSize = cfg.PoolSize
opts.DialTimeout = timeout
opts.ReadTimeout = timeout
opts.WriteTimeout = timeout
opts.PoolTimeout = timeout
opts.MaxRetries = 1
client := redis.NewClient(opts)
pingCtx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
if err := client.Ping(pingCtx).Err(); err != nil {
_ = client.Close()
return nil, fmt.Errorf("session: ping: %w", err)
}
return client, nil
}
func urlFrom(cfg config.Cache) (string, error) {
if cfg.URLFile != "" {
b, err := os.ReadFile(cfg.URLFile)
if err != nil {
return "", fmt.Errorf("session: read CACHE_URL_FILE: %w", err)
}
return strings.TrimSpace(string(b)), nil
}
if cfg.URL != "" {
return cfg.URL, nil
}
return "", errors.New("session: CACHE_URL_FILE or CACHE_URL is required")
}
func key(tokenHash []byte) string {
return keyPrefix + hex.EncodeToString(tokenHash)
}
func (v *Valkey) Save(ctx context.Context, tokenHash []byte, s Session) error {
val, err := json.Marshal(s)
if err != nil {
return err
}
// NX: 256-битный токен не совпадёт, но перезаписать чужую сессию нельзя даже теоретически.
err = v.client.SetArgs(ctx, key(tokenHash), val, redis.SetArgs{
Mode: "NX",
ExpireAt: s.ExpiresAt,
}).Err()
if errors.Is(err, redis.Nil) {
return fmt.Errorf("session: token collision")
}
return unavailable(err)
}
func (v *Valkey) Get(ctx context.Context, tokenHash []byte) (Session, error) {
val, err := v.client.Get(ctx, key(tokenHash)).Bytes()
if errors.Is(err, redis.Nil) {
return Session{}, ErrNotFound
}
if err != nil {
return Session{}, unavailable(err)
}
var s Session
if err := json.Unmarshal(val, &s); err != nil {
return Session{}, fmt.Errorf("session: corrupt value: %w", err)
}
return s, nil
}
func (v *Valkey) Delete(ctx context.Context, tokenHash []byte) error {
return unavailable(v.client.Del(ctx, key(tokenHash)).Err())
}
func (v *Valkey) Ping(ctx context.Context) error {
return unavailable(v.client.Ping(ctx).Err())
}
func unavailable(err error) error {
if err == nil {
return nil
}
return fmt.Errorf("%w: session store: %v", domain.ErrUnavailable, err)
}
+117
View File
@@ -0,0 +1,117 @@
package db
import (
"context"
"encoding/json"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/propagation"
"go.opentelemetry.io/otel/trace"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
type Attachments struct {
conn
}
// CreateAttachment сохраняет метаданные. FK на chat_members не даёт записать вложение постороннего.
func (a *Attachments) CreateAttachment(ctx context.Context, att domain.Attachment) (domain.Attachment, error) {
ctx, cancel := a.withTimeout(ctx)
defer cancel()
ctx, span := otel.Tracer("messenger").Start(ctx, "attachment.enqueue", trace.WithSpanKind(trace.SpanKindProducer))
defer span.End()
carrier := propagation.MapCarrier{}
otel.GetTextMapPropagator().Inject(ctx, carrier)
tx, err := a.pool.Begin(ctx)
if err != nil {
return domain.Attachment{}, mapErr(err)
}
defer tx.Rollback(ctx)
if _, err = tx.Exec(ctx, "SELECT set_config('messenger.traceparent',$1,true), set_config('messenger.tracestate',$2,true)", carrier.Get("traceparent"), carrier.Get("tracestate")); err != nil {
return domain.Attachment{}, mapErr(err)
}
err = tx.QueryRow(ctx, `
INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
RETURNING created_at, updated_at`,
att.ID, att.ChatID, att.OwnerID, att.Filename, att.ContentType, att.SizeBytes, att.SHA256, att.ObjectKey, att.Status,
).Scan(&att.CreatedAt, &att.UpdatedAt)
if isFKViolation(err) {
return domain.Attachment{}, domain.ErrNotFound
}
if err != nil {
return domain.Attachment{}, mapErr(err)
}
if err := tx.Commit(ctx); err != nil {
return domain.Attachment{}, mapErr(err)
}
att.CreatedAt = att.CreatedAt.UTC()
att.UpdatedAt = att.UpdatedAt.UTC()
return att, nil
}
// AttachmentForMember возвращает вложение, только если вызывающий состоит в его чате: для
// постороннего результат неотличим от отсутствующего объекта.
func (a *Attachments) AttachmentForMember(ctx context.Context, callerID, attachmentID string) (domain.Attachment, error) {
ctx, cancel := a.withTimeout(ctx)
defer cancel()
var att domain.Attachment
var variants []byte
err := a.pool.QueryRow(ctx, `
SELECT a.id::text, a.chat_id::text, a.owner_id::text, a.filename, a.content_type, a.size_bytes,
a.sha256, a.object_key, a.status, a.created_at, a.updated_at, a.variants, a.error_code
FROM attachments a
JOIN chat_members cm ON cm.chat_id = a.chat_id AND cm.user_id = $2
WHERE a.id = $1`,
attachmentID, callerID,
).Scan(&att.ID, &att.ChatID, &att.OwnerID, &att.Filename, &att.ContentType, &att.SizeBytes,
&att.SHA256, &att.ObjectKey, &att.Status, &att.CreatedAt, &att.UpdatedAt, &variants, &att.ErrorCode)
if err != nil {
return domain.Attachment{}, mapErr(err)
}
att.CreatedAt = att.CreatedAt.UTC()
att.UpdatedAt = att.UpdatedAt.UTC()
if err := json.Unmarshal(variants, &att.Variants); err != nil {
return domain.Attachment{}, err
}
return att, nil
}
// AttachmentExists отвечает без учёта доступа: вызывается только сервером при компенсации.
func (a *Attachments) AttachmentExists(ctx context.Context, attachmentID string) (bool, error) {
ctx, cancel := a.withTimeout(ctx)
defer cancel()
var exists bool
err := a.pool.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM attachments WHERE id = $1)`, attachmentID).Scan(&exists)
if err != nil {
return false, mapErr(err)
}
return exists, nil
}
// ExistingObjectKeys возвращает те ключи из списка, на которые есть строка. Нужен очистителю.
func (a *Attachments) ExistingObjectKeys(ctx context.Context, keys []string) (map[string]struct{}, error) {
ctx, cancel := a.withTimeout(ctx)
defer cancel()
rows, err := a.pool.Query(ctx, `SELECT object_key FROM attachments WHERE object_key = ANY($1)`, keys)
if err != nil {
return nil, mapErr(err)
}
defer rows.Close()
existing := make(map[string]struct{}, len(keys))
for rows.Next() {
var key string
if err := rows.Scan(&key); err != nil {
return nil, mapErr(err)
}
existing[key] = struct{}{}
}
if err := rows.Err(); err != nil {
return nil, mapErr(err)
}
return existing, nil
}
+165
View File
@@ -0,0 +1,165 @@
package db
import (
"context"
"strings"
"time"
"github.com/jackc/pgx/v5"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
type Chats struct {
conn
}
func (c *Chats) CreateChat(ctx context.Context, callerID, title string, memberIDs []string) (domain.Chat, error) {
if strings.TrimSpace(title) == "" {
return domain.Chat{}, domain.ErrInvalidArgument
}
if len(memberIDs) == 0 || len(memberIDs) > 100 {
return domain.Chat{}, domain.ErrInvalidArgument
}
seen := make(map[string]struct{}, len(memberIDs))
callerInMembers := false
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return domain.Chat{}, domain.ErrInvalidArgument
}
seen[id] = struct{}{}
if id == callerID {
callerInMembers = true
}
}
if !callerInMembers {
return domain.Chat{}, domain.ErrInvalidArgument
}
ctx, cancel := c.withTimeout(ctx)
defer cancel()
tx, err := c.pool.Begin(ctx)
if err != nil {
return domain.Chat{}, mapErr(err)
}
defer tx.Rollback(ctx)
chat := domain.Chat{Title: title}
err = tx.QueryRow(ctx, `
INSERT INTO chats (title)
VALUES ($1)
RETURNING id::text, created_at`,
encodeText(title),
).Scan(&chat.ID, &chat.CreatedAt)
if err != nil {
return domain.Chat{}, mapErr(err)
}
_, err = tx.Exec(ctx, `
INSERT INTO chat_members (chat_id, user_id)
SELECT $1, unnest($2::uuid[])`,
chat.ID, memberIDs,
)
if err != nil {
return domain.Chat{}, mapErr(err)
}
if err := tx.Commit(ctx); err != nil {
return domain.Chat{}, mapErr(err)
}
chat.MemberIDs = append([]string(nil), memberIDs...)
chat.CreatedAt = chat.CreatedAt.UTC()
return chat, nil
}
func (c *Chats) ChatByID(ctx context.Context, callerID, chatID string) (domain.Chat, error) {
ctx, cancel := c.withTimeout(ctx)
defer cancel()
chat := domain.Chat{}
err := c.pool.QueryRow(ctx, `
SELECT c.id::text, c.title, c.created_at,
(SELECT array_agg(m.user_id::text ORDER BY m.user_id)
FROM chat_members m WHERE m.chat_id = c.id)
FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $2
WHERE c.id = $1`,
chatID, callerID,
).Scan(&chat.ID, &chat.Title, &chat.CreatedAt, &chat.MemberIDs)
if err != nil {
err = mapErr(err)
if err == domain.ErrInvalidArgument {
return domain.Chat{}, domain.ErrNotFound
}
return domain.Chat{}, err
}
chat.Title = decodeText(chat.Title)
chat.CreatedAt = chat.CreatedAt.UTC()
return chat, nil
}
func (c *Chats) ListChats(ctx context.Context, callerID, cursor string, limit int) (domain.Page[domain.Chat], error) {
if limit <= 0 || limit > 100 {
return domain.Page[domain.Chat]{}, domain.ErrInvalidArgument
}
cur, err := domain.DecodeCursor(cursor)
if err != nil {
return domain.Page[domain.Chat]{}, err
}
scope := "chats:" + callerID
if cursor != "" && cur.Scope != scope {
return domain.Page[domain.Chat]{}, domain.ErrInvalidArgument
}
afterTime, afterID := cursorArgs(cur)
ctx, cancel := c.withTimeout(ctx)
defer cancel()
rows, err := c.pool.Query(ctx, `
SELECT c.id::text, c.title, c.created_at,
(SELECT array_agg(m.user_id::text ORDER BY m.user_id)
FROM chat_members m WHERE m.chat_id = c.id)
FROM chat_members me
JOIN chats c ON c.id = me.chat_id
WHERE me.user_id = $1
AND ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3::uuid))
ORDER BY c.created_at, c.id
LIMIT $4`,
callerID, afterTime, afterID, limit+1,
)
if err != nil {
return domain.Page[domain.Chat]{}, mapErr(err)
}
out, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (domain.Chat, error) {
var ch domain.Chat
err := r.Scan(&ch.ID, &ch.Title, &ch.CreatedAt, &ch.MemberIDs)
ch.Title = decodeText(ch.Title)
ch.CreatedAt = ch.CreatedAt.UTC()
return ch, err
})
if err != nil {
return domain.Page[domain.Chat]{}, mapErr(err)
}
page := domain.Page[domain.Chat]{}
if len(out) > limit {
last := out[limit-1]
page.NextCursor = domain.EncodeCursor(domain.Cursor{
CreatedAt: last.CreatedAt,
ID: last.ID,
Scope: scope,
})
out = out[:limit]
}
page.Items = out
return page, nil
}
func cursorArgs(c domain.Cursor) (*time.Time, *string) {
if c.IsZero() {
return nil, nil
}
return &c.CreatedAt, &c.ID
}
+143
View File
@@ -0,0 +1,143 @@
package db
import (
"context"
"errors"
"fmt"
"os"
"strings"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/telemetry"
)
var _ store.Store = (*DB)(nil)
type DB struct {
*Users
*Chats
*Messages
*Attachments
pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool, queryTimeout time.Duration) *DB {
c := conn{pool: pool, timeout: queryTimeout}
return &DB{
Users: &Users{conn: c},
Chats: &Chats{conn: c},
Messages: &Messages{conn: c},
Attachments: &Attachments{conn: c},
pool: pool,
}
}
func Connect(ctx context.Context, cfg config.Database) (*pgxpool.Pool, error) {
dsn, err := dsnFrom(cfg)
if err != nil {
return nil, err
}
pcfg, err := pgxpool.ParseConfig(dsn)
if err != nil {
return nil, errors.New("db: invalid DSN")
}
tracer := &telemetry.DBTracer{}
pcfg.ConnConfig.Tracer = tracer
pcfg.MaxConns = cfg.MaxConns
pcfg.ConnConfig.ConnectTimeout = time.Duration(cfg.ConnectTimeoutMs) * time.Millisecond
if !cfg.EnableBitmapScan {
pcfg.ConnConfig.RuntimeParams["enable_bitmapscan"] = "off"
}
pool, err := pgxpool.NewWithConfig(ctx, pcfg)
if err != nil {
return nil, fmt.Errorf("db: pool: %w", err)
}
pingCtx, cancel := context.WithTimeout(ctx, pcfg.ConnConfig.ConnectTimeout)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, fmt.Errorf("db: ping: %w", err)
}
if err := telemetry.WatchPool(pool, tracer); err != nil {
pool.Close()
return nil, err
}
return pool, nil
}
func dsnFrom(cfg config.Database) (string, error) {
if cfg.URLFile != "" {
b, err := os.ReadFile(cfg.URLFile)
if err != nil {
return "", fmt.Errorf("db: read DATABASE_URL_FILE: %w", err)
}
return strings.TrimSpace(string(b)), nil
}
if cfg.URL != "" {
return cfg.URL, nil
}
return "", errors.New("db: DATABASE_URL_FILE or DATABASE_URL is required")
}
func (d *DB) Ping(ctx context.Context) error {
return d.pool.Ping(ctx)
}
func (d *DB) Close() {
d.pool.Close()
}
type conn struct {
pool *pgxpool.Pool
timeout time.Duration
}
func (c conn) withTimeout(parent context.Context) (context.Context, context.CancelFunc) {
return context.WithTimeout(parent, c.timeout)
}
const (
codeUniqueViolation = "23505"
codeForeignKeyViolation = "23503"
codeCheckViolation = "23514"
codeInvalidTextRepr = "22P02"
)
func mapErr(err error) error {
if err == nil {
return nil
}
if errors.Is(err, pgx.ErrNoRows) {
return domain.ErrNotFound
}
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
switch pgErr.Code {
case codeUniqueViolation:
return domain.ErrConflict
case codeForeignKeyViolation, codeCheckViolation, codeInvalidTextRepr:
return domain.ErrInvalidArgument
}
switch pgErr.Code[:2] {
case "08", "53", "57":
return fmt.Errorf("%w: db: %s", domain.ErrUnavailable, pgErr.Code)
}
return fmt.Errorf("db: %s: %w", pgErr.Code, err)
}
return fmt.Errorf("%w: db: %v", domain.ErrUnavailable, err)
}
func isFKViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == codeForeignKeyViolation
}
+46
View File
@@ -0,0 +1,46 @@
package db
import (
"context"
"errors"
"fmt"
"testing"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
func TestMapErr(t *testing.T) {
pg := func(code string) error { return &pgconn.PgError{Code: code} }
cases := []struct {
name string
err error
want error
}{
{"no rows", pgx.ErrNoRows, domain.ErrNotFound},
{"unique", pg("23505"), domain.ErrConflict},
{"fk", pg("23503"), domain.ErrInvalidArgument},
{"check", pg("23514"), domain.ErrInvalidArgument},
{"bad uuid text", pg("22P02"), domain.ErrInvalidArgument},
{"admin shutdown (postgres stop)", pg("57P01"), domain.ErrUnavailable},
{"cannot connect now (starting up)", pg("57P03"), domain.ErrUnavailable},
{"connection failure", pg("08006"), domain.ErrUnavailable},
{"too many connections", pg("53300"), domain.ErrUnavailable},
{"timeout", fmt.Errorf("query: %w", context.DeadlineExceeded), domain.ErrUnavailable},
{"dial refused", errors.New("dial tcp: connection refused"), domain.ErrUnavailable},
}
for _, tc := range cases {
if got := mapErr(tc.err); !errors.Is(got, tc.want) {
t.Errorf("%s: mapErr = %v, want %v", tc.name, got, tc.want)
}
}
if got := mapErr(pg("42601")); errors.Is(got, domain.ErrUnavailable) || errors.Is(got, domain.ErrInvalidArgument) {
t.Errorf("syntax error mapped to %v", got)
}
if mapErr(nil) != nil {
t.Error("mapErr(nil) != nil")
}
}
+59
View File
@@ -0,0 +1,59 @@
package db
import (
"context"
"github.com/jackc/pgx/v5"
)
func (m *Messages) AddPendingInvalidation(ctx context.Context, chatID string) (int64, error) {
ctx, cancel := m.withTimeout(ctx)
defer cancel()
var gen int64
err := m.pool.QueryRow(ctx, `
INSERT INTO cache_invalidations (chat_id) VALUES ($1)
ON CONFLICT (chat_id) DO UPDATE
SET gen = nextval('cache_invalidations_gen_seq'), updated_at = now()
RETURNING gen`,
chatID,
).Scan(&gen)
if err != nil {
return 0, mapErr(err)
}
return gen, nil
}
func (m *Messages) PendingInvalidations(ctx context.Context) (map[string]int64, error) {
ctx, cancel := m.withTimeout(ctx)
defer cancel()
rows, err := m.pool.Query(ctx, `SELECT chat_id::text, gen FROM cache_invalidations`)
if err != nil {
return nil, mapErr(err)
}
out := map[string]int64{}
var (
id string
gen int64
)
_, err = pgx.ForEachRow(rows, []any{&id, &gen}, func() error {
out[id] = gen
return nil
})
if err != nil {
return nil, mapErr(err)
}
return out, nil
}
func (m *Messages) ResolvePendingInvalidation(ctx context.Context, chatID string, gen int64) error {
ctx, cancel := m.withTimeout(ctx)
defer cancel()
_, err := m.pool.Exec(ctx,
`DELETE FROM cache_invalidations WHERE chat_id = $1 AND gen = $2`,
chatID, gen,
)
return mapErr(err)
}
+218
View File
@@ -0,0 +1,218 @@
package db
import (
"context"
"errors"
"slices"
"strings"
"time"
"github.com/jackc/pgx/v5"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
type Messages struct {
conn
}
func (m *Messages) AddMessage(ctx context.Context, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error) {
if strings.TrimSpace(text) == "" && len(attachmentIDs) == 0 {
return domain.Message{}, domain.ErrInvalidArgument
}
ctx, cancel := m.withTimeout(ctx)
defer cancel()
tx, err := m.pool.Begin(ctx)
if err != nil {
return domain.Message{}, mapErr(err)
}
defer tx.Rollback(ctx)
msg := domain.Message{ChatID: chatID, AuthorID: callerID, Text: text, AttachmentIDs: attachmentIDs}
err = tx.QueryRow(ctx, `
INSERT INTO message_idempotency_keys (user_id, chat_id, key, message_id)
VALUES ($1, $2, $3, gen_random_uuid())
ON CONFLICT (user_id, chat_id, key) DO NOTHING
RETURNING message_id::text`,
callerID, chatID, idempotencyKey,
).Scan(&msg.ID)
switch {
case errors.Is(err, pgx.ErrNoRows):
return replayMessage(ctx, tx, callerID, chatID, idempotencyKey, text, attachmentIDs)
case isFKViolation(err):
return domain.Message{}, domain.ErrNotFound
case err != nil:
return domain.Message{}, mapErr(err)
}
err = tx.QueryRow(ctx, `
INSERT INTO messages (id, chat_id, sender_id, text)
VALUES ($1, $2, $3, $4)
RETURNING created_at`,
msg.ID, chatID, callerID, encodeText(text),
).Scan(&msg.CreatedAt)
if err != nil {
return domain.Message{}, mapErr(err)
}
// Составной FK сам отклоняет вложение другого чата и неизвестное вложение. Та же транзакция:
// при ошибке не останется ни сообщения, ни ключа идемпотентности.
if len(attachmentIDs) > 0 {
var failed bool
err = tx.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM attachments WHERE chat_id=$1 AND id::text=ANY($2) AND status='failed')`, chatID, attachmentIDs).Scan(&failed)
if err != nil {
return domain.Message{}, mapErr(err)
}
if failed {
return domain.Message{}, domain.ErrConflict
}
_, err = tx.Exec(ctx, `
INSERT INTO message_attachments (message_id, chat_id, attachment_id, position)
SELECT $1, $2, t.id::uuid, t.ord::int
FROM unnest($3::text[]) WITH ORDINALITY AS t(id, ord)`,
msg.ID, chatID, attachmentIDs,
)
if isFKViolation(err) {
return domain.Message{}, domain.ErrNotFound
}
if err != nil {
return domain.Message{}, mapErr(err)
}
}
if err := tx.Commit(ctx); err != nil {
return domain.Message{}, mapErr(err)
}
msg.CreatedAt = msg.CreatedAt.UTC()
return msg, nil
}
func replayMessage(ctx context.Context, tx pgx.Tx, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error) {
msg := domain.Message{ChatID: chatID, AuthorID: callerID}
err := tx.QueryRow(ctx, `
SELECT m.id::text, m.text, m.created_at, COALESCE((SELECT array_agg(ma.attachment_id::text ORDER BY ma.position) FROM message_attachments ma WHERE ma.message_id = m.id), ARRAY[]::text[])
FROM message_idempotency_keys k
JOIN messages m ON m.id = k.message_id
WHERE k.user_id = $1 AND k.chat_id = $2 AND k.key = $3`,
callerID, chatID, idempotencyKey,
).Scan(&msg.ID, &msg.Text, &msg.CreatedAt, &msg.AttachmentIDs)
if errors.Is(err, pgx.ErrNoRows) {
return domain.Message{}, domain.ErrUnavailable
}
if err != nil {
return domain.Message{}, mapErr(err)
}
msg.Text = decodeText(msg.Text)
if msg.Text != text || !slices.Equal(msg.AttachmentIDs, attachmentIDs) {
return domain.Message{}, domain.ErrIdempotencyConflict
}
msg.CreatedAt = msg.CreatedAt.UTC()
return msg, nil
}
func (m *Messages) PurgeIdempotencyKeys(ctx context.Context, ttl time.Duration) (int64, error) {
ctx, cancel := m.withTimeout(ctx)
defer cancel()
tag, err := m.pool.Exec(ctx,
`DELETE FROM message_idempotency_keys WHERE created_at < now() - make_interval(secs => $1)`,
ttl.Seconds(),
)
if err != nil {
return 0, mapErr(err)
}
return tag.RowsAffected(), nil
}
func (m *Messages) ListMessages(ctx context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
member, err := m.IsMember(ctx, chatID, callerID)
if err != nil {
return domain.Page[domain.Message]{}, err
}
if !member {
return domain.Page[domain.Message]{}, domain.ErrNotFound
}
return m.HistoryPage(ctx, chatID, cursor, limit)
}
func (m *Messages) IsMember(ctx context.Context, chatID, userID string) (bool, error) {
ctx, cancel := m.withTimeout(ctx)
defer cancel()
var member bool
err := m.pool.QueryRow(ctx,
`SELECT EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID,
).Scan(&member)
if err != nil {
return false, mapErr(err)
}
return member, nil
}
func (m *Messages) HistoryPage(ctx context.Context, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
if limit <= 0 || limit > 100 {
return domain.Page[domain.Message]{}, domain.ErrInvalidArgument
}
cur, err := domain.DecodeCursor(cursor)
if err != nil {
return domain.Page[domain.Message]{}, err
}
scope := "chat:" + chatID
if cursor != "" && cur.Scope != scope {
return domain.Page[domain.Message]{}, domain.ErrInvalidArgument
}
ctx, cancel := m.withTimeout(ctx)
defer cancel()
var rows pgx.Rows
if cur.IsZero() {
rows, err = m.pool.Query(ctx, `
SELECT m.id::text, m.chat_id::text, m.sender_id::text, m.text, m.created_at,
COALESCE((SELECT array_agg(ma.attachment_id::text ORDER BY ma.position) FROM message_attachments ma WHERE ma.message_id = m.id), ARRAY[]::text[])
FROM messages m
WHERE m.chat_id = $1
ORDER BY m.created_at, m.id
LIMIT $2`,
chatID, limit+1,
)
} else {
rows, err = m.pool.Query(ctx, `
SELECT m.id::text, m.chat_id::text, m.sender_id::text, m.text, m.created_at,
COALESCE((SELECT array_agg(ma.attachment_id::text ORDER BY ma.position) FROM message_attachments ma WHERE ma.message_id = m.id), ARRAY[]::text[])
FROM messages m
WHERE m.chat_id = $1
AND (m.created_at, m.id) > ($2, $3::uuid)
ORDER BY m.created_at, m.id
LIMIT $4`,
chatID, cur.CreatedAt, cur.ID, limit+1,
)
}
if err != nil {
return domain.Page[domain.Message]{}, mapErr(err)
}
out, err := pgx.CollectRows(rows, func(r pgx.CollectableRow) (domain.Message, error) {
var msg domain.Message
err := r.Scan(&msg.ID, &msg.ChatID, &msg.AuthorID, &msg.Text, &msg.CreatedAt, &msg.AttachmentIDs)
msg.Text = decodeText(msg.Text)
msg.CreatedAt = msg.CreatedAt.UTC()
return msg, err
})
if err != nil {
return domain.Page[domain.Message]{}, mapErr(err)
}
page := domain.Page[domain.Message]{}
if len(out) > limit {
last := out[limit-1]
page.NextCursor = domain.EncodeCursor(domain.Cursor{
CreatedAt: last.CreatedAt,
ID: last.ID,
Scope: scope,
})
out = out[:limit]
}
page.Items = out
return page, nil
}
+22
View File
@@ -0,0 +1,22 @@
package db
import "strings"
var (
textEncoder = strings.NewReplacer(`\`, `\\`, "\x00", `\0`)
textDecoder = strings.NewReplacer(`\\`, `\`, `\0`, "\x00")
)
func encodeText(s string) string {
if !strings.ContainsAny(s, "\\\x00") {
return s
}
return textEncoder.Replace(s)
}
func decodeText(s string) string {
if !strings.Contains(s, `\`) {
return s
}
return textDecoder.Replace(s)
}
+18
View File
@@ -0,0 +1,18 @@
package db
import "testing"
func TestTextEscapeRoundTrip(t *testing.T) {
cases := []string{"", "plain", "\x00", "a\x00b", `\`, `\0`, `\\0`, "\\\x00", "\x00\\0\x00", "привет\x00мир"}
for _, s := range cases {
enc := encodeText(s)
for i := 0; i < len(enc); i++ {
if enc[i] == 0 {
t.Fatalf("encodeText(%q) = %q содержит NUL", s, enc)
}
}
if got := decodeText(enc); got != s {
t.Fatalf("decodeText(encodeText(%q)) = %q", s, got)
}
}
}
+89
View File
@@ -0,0 +1,89 @@
package db
import (
"context"
"strings"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
type Users struct {
conn
}
func (u *Users) CreateUser(ctx context.Context, username, displayName, passwordHash string) (domain.User, error) {
if strings.TrimSpace(username) == "" || strings.TrimSpace(displayName) == "" || passwordHash == "" {
return domain.User{}, domain.ErrInvalidArgument
}
ctx, cancel := u.withTimeout(ctx)
defer cancel()
user := domain.User{Username: username, DisplayName: displayName}
err := u.pool.QueryRow(ctx, `
INSERT INTO users (username, display_name, password_hash)
VALUES ($1, $2, $3)
RETURNING id::text, created_at`,
username, encodeText(displayName), passwordHash,
).Scan(&user.ID, &user.CreatedAt)
if err != nil {
return domain.User{}, mapErr(err)
}
user.CreatedAt = user.CreatedAt.UTC()
return user, nil
}
func (u *Users) UserByID(ctx context.Context, id string) (domain.User, error) {
ctx, cancel := u.withTimeout(ctx)
defer cancel()
user := domain.User{}
err := u.pool.QueryRow(ctx, `
SELECT id::text, username, display_name, created_at
FROM users
WHERE id = $1`,
id,
).Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt)
if err != nil {
err = mapErr(err)
if err == domain.ErrInvalidArgument {
return domain.User{}, domain.ErrNotFound
}
return domain.User{}, err
}
user.DisplayName = decodeText(user.DisplayName)
user.CreatedAt = user.CreatedAt.UTC()
return user, nil
}
func (u *Users) CredentialsByUsername(ctx context.Context, username string) (domain.User, string, error) {
ctx, cancel := u.withTimeout(ctx)
defer cancel()
user := domain.User{}
var hash string
err := u.pool.QueryRow(ctx, `
SELECT id::text, username, display_name, created_at, password_hash
FROM users
WHERE username = $1`,
encodeText(username),
).Scan(&user.ID, &user.Username, &user.DisplayName, &user.CreatedAt, &hash)
if err != nil {
return domain.User{}, "", mapErr(err)
}
user.DisplayName = decodeText(user.DisplayName)
user.CreatedAt = user.CreatedAt.UTC()
return user, hash, nil
}
func (u *Users) UsernameExists(ctx context.Context, username string) bool {
ctx, cancel := u.withTimeout(ctx)
defer cancel()
var exists bool
err := u.pool.QueryRow(ctx,
`SELECT EXISTS (SELECT 1 FROM users WHERE username = $1)`,
encodeText(username),
).Scan(&exists)
return err == nil && exists
}
+368
View File
@@ -0,0 +1,368 @@
package store
import (
"context"
"slices"
"strings"
"sync"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
"github.com/google/uuid"
)
var _ Store = (*Memory)(nil)
type Memory struct {
mu sync.RWMutex
users map[string]domain.User
byName map[string]string
hashes map[string]string
chats map[string]*chatBucket
chatOrder []string
lastTime time.Time
idempotency map[string]domain.Message
attachments map[string]domain.Attachment
maxMessages int
messagesTotal int
}
type chatBucket struct {
chat domain.Chat
members map[string]struct{}
messages []domain.Message
}
func New() *Memory {
return NewWithLimit(0)
}
func NewWithLimit(maxMessages int) *Memory {
return &Memory{
users: make(map[string]domain.User),
byName: make(map[string]string),
hashes: make(map[string]string),
chats: make(map[string]*chatBucket),
idempotency: make(map[string]domain.Message),
attachments: make(map[string]domain.Attachment),
maxMessages: maxMessages,
}
}
func (m *Memory) MessagesTotal() int {
m.mu.RLock()
defer m.mu.RUnlock()
return m.messagesTotal
}
func (m *Memory) now() time.Time {
t := time.Now().UTC()
if !t.After(m.lastTime) {
t = m.lastTime.Add(time.Nanosecond)
}
m.lastTime = t
return t
}
func (m *Memory) CreateUser(_ context.Context, username, displayName, passwordHash string) (domain.User, error) {
if strings.TrimSpace(username) == "" || strings.TrimSpace(displayName) == "" {
return domain.User{}, domain.ErrInvalidArgument
}
m.mu.Lock()
defer m.mu.Unlock()
if _, taken := m.byName[username]; taken {
return domain.User{}, domain.ErrConflict
}
u := domain.User{
ID: uuid.NewString(),
Username: username,
DisplayName: displayName,
CreatedAt: m.now(),
}
m.users[u.ID] = u
m.byName[username] = u.ID
m.hashes[u.ID] = passwordHash
return u, nil
}
func (m *Memory) UserByID(_ context.Context, id string) (domain.User, error) {
m.mu.RLock()
defer m.mu.RUnlock()
u, ok := m.users[id]
if !ok {
return domain.User{}, domain.ErrNotFound
}
return u, nil
}
func (m *Memory) CredentialsByUsername(_ context.Context, username string) (domain.User, string, error) {
m.mu.RLock()
defer m.mu.RUnlock()
id, ok := m.byName[username]
if !ok {
return domain.User{}, "", domain.ErrNotFound
}
return m.users[id], m.hashes[id], nil
}
func (m *Memory) UsernameExists(_ context.Context, username string) bool {
m.mu.RLock()
defer m.mu.RUnlock()
_, taken := m.byName[username]
return taken
}
func (m *Memory) CreateChat(_ context.Context, callerID, title string, memberIDs []string) (domain.Chat, error) {
if strings.TrimSpace(title) == "" {
return domain.Chat{}, domain.ErrInvalidArgument
}
if len(memberIDs) == 0 || len(memberIDs) > 100 {
return domain.Chat{}, domain.ErrInvalidArgument
}
seen := make(map[string]struct{}, len(memberIDs))
callerInMembers := false
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return domain.Chat{}, domain.ErrInvalidArgument
}
seen[id] = struct{}{}
if id == callerID {
callerInMembers = true
}
}
if !callerInMembers {
return domain.Chat{}, domain.ErrInvalidArgument
}
m.mu.Lock()
defer m.mu.Unlock()
for _, id := range memberIDs {
if _, ok := m.users[id]; !ok {
return domain.Chat{}, domain.ErrInvalidArgument
}
}
members := append([]string(nil), memberIDs...)
chat := domain.Chat{
ID: uuid.NewString(),
Title: title,
MemberIDs: members,
CreatedAt: m.now(),
}
m.chats[chat.ID] = &chatBucket{
chat: chat,
members: seen,
}
m.chatOrder = append(m.chatOrder, chat.ID)
return cloneChat(chat), nil
}
func (m *Memory) ChatByID(_ context.Context, callerID, chatID string) (domain.Chat, error) {
m.mu.RLock()
defer m.mu.RUnlock()
b, ok := m.chats[chatID]
if !ok {
return domain.Chat{}, domain.ErrNotFound
}
if _, member := b.members[callerID]; !member {
return domain.Chat{}, domain.ErrNotFound
}
return cloneChat(b.chat), nil
}
func (m *Memory) ListChats(_ context.Context, callerID, cursor string, limit int) (domain.Page[domain.Chat], error) {
if limit <= 0 || limit > 100 {
return domain.Page[domain.Chat]{}, domain.ErrInvalidArgument
}
c, err := domain.DecodeCursor(cursor)
if err != nil {
return domain.Page[domain.Chat]{}, err
}
if cursor != "" && c.Scope != "chats:"+callerID {
return domain.Page[domain.Chat]{}, domain.ErrInvalidArgument
}
m.mu.RLock()
defer m.mu.RUnlock()
out := make([]domain.Chat, 0, limit+1)
for _, id := range m.chatOrder {
b := m.chats[id]
if _, member := b.members[callerID]; !member {
continue
}
if !c.Less(b.chat.CreatedAt, b.chat.ID) {
continue
}
out = append(out, cloneChat(b.chat))
if len(out) > limit {
break
}
}
page := domain.Page[domain.Chat]{}
if len(out) > limit {
last := out[limit-1]
page.NextCursor = domain.EncodeCursor(domain.Cursor{
CreatedAt: last.CreatedAt,
ID: last.ID,
Scope: "chats:" + callerID,
})
out = out[:limit]
}
page.Items = out
return page, nil
}
func (m *Memory) AddMessage(_ context.Context, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error) {
if strings.TrimSpace(text) == "" && len(attachmentIDs) == 0 {
return domain.Message{}, domain.ErrInvalidArgument
}
m.mu.Lock()
defer m.mu.Unlock()
b, ok := m.chats[chatID]
if !ok {
return domain.Message{}, domain.ErrNotFound
}
if _, member := b.members[callerID]; !member {
return domain.Message{}, domain.ErrNotFound
}
idemKey := callerID + "\x00" + chatID + "\x00" + idempotencyKey
if prev, ok := m.idempotency[idemKey]; ok {
if prev.Text != text || !slices.Equal(prev.AttachmentIDs, attachmentIDs) {
return domain.Message{}, domain.ErrIdempotencyConflict
}
return prev, nil
}
if m.maxMessages > 0 && m.messagesTotal >= m.maxMessages {
return domain.Message{}, domain.ErrUnavailable
}
for _, id := range attachmentIDs {
if att, ok := m.attachments[id]; !ok || att.ChatID != chatID {
return domain.Message{}, domain.ErrNotFound
}
}
msg := domain.Message{
ID: uuid.NewString(),
ChatID: chatID,
AuthorID: callerID,
Text: text,
CreatedAt: m.now(),
AttachmentIDs: attachmentIDs,
}
b.messages = append(b.messages, msg)
m.idempotency[idemKey] = msg
m.messagesTotal++
return msg, nil
}
func (m *Memory) ListMessages(_ context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error) {
if limit <= 0 || limit > 100 {
return domain.Page[domain.Message]{}, domain.ErrInvalidArgument
}
c, err := domain.DecodeCursor(cursor)
if err != nil {
return domain.Page[domain.Message]{}, err
}
if cursor != "" && c.Scope != "chat:"+chatID {
return domain.Page[domain.Message]{}, domain.ErrInvalidArgument
}
m.mu.RLock()
defer m.mu.RUnlock()
b, ok := m.chats[chatID]
if !ok {
return domain.Page[domain.Message]{}, domain.ErrNotFound
}
if _, member := b.members[callerID]; !member {
return domain.Page[domain.Message]{}, domain.ErrNotFound
}
start := 0
for ; start < len(b.messages); start++ {
if c.Less(b.messages[start].CreatedAt, b.messages[start].ID) {
break
}
}
end := start + limit
hasMore := end < len(b.messages)
if end > len(b.messages) {
end = len(b.messages)
}
out := make([]domain.Message, end-start)
copy(out, b.messages[start:end])
page := domain.Page[domain.Message]{Items: out}
if hasMore && len(out) > 0 {
last := out[len(out)-1]
page.NextCursor = domain.EncodeCursor(domain.Cursor{
CreatedAt: last.CreatedAt,
ID: last.ID,
Scope: "chat:" + chatID,
})
}
return page, nil
}
func (m *Memory) CreateAttachment(_ context.Context, att domain.Attachment) (domain.Attachment, error) {
m.mu.Lock()
defer m.mu.Unlock()
if b, ok := m.chats[att.ChatID]; !ok {
return domain.Attachment{}, domain.ErrNotFound
} else if _, member := b.members[att.OwnerID]; !member {
return domain.Attachment{}, domain.ErrNotFound
}
att.CreatedAt = m.now()
att.UpdatedAt = att.CreatedAt
m.attachments[att.ID] = att
return att, nil
}
func (m *Memory) AttachmentForMember(_ context.Context, callerID, attachmentID string) (domain.Attachment, error) {
m.mu.RLock()
defer m.mu.RUnlock()
att, ok := m.attachments[attachmentID]
if !ok {
return domain.Attachment{}, domain.ErrNotFound
}
if _, member := m.chats[att.ChatID].members[callerID]; !member {
return domain.Attachment{}, domain.ErrNotFound
}
return att, nil
}
func (m *Memory) AttachmentExists(_ context.Context, attachmentID string) (bool, error) {
m.mu.RLock()
defer m.mu.RUnlock()
_, ok := m.attachments[attachmentID]
return ok, nil
}
func cloneChat(c domain.Chat) domain.Chat {
out := c
out.MemberIDs = append([]string(nil), c.MemberIDs...)
return out
}
+43
View File
@@ -0,0 +1,43 @@
package store
import (
"context"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
type UserStore interface {
CreateUser(ctx context.Context, username, displayName, passwordHash string) (domain.User, error)
UserByID(ctx context.Context, id string) (domain.User, error)
CredentialsByUsername(ctx context.Context, username string) (domain.User, string, error)
UsernameExists(ctx context.Context, username string) bool
}
type ChatStore interface {
CreateChat(ctx context.Context, callerID, title string, memberIDs []string) (domain.Chat, error)
ChatByID(ctx context.Context, callerID, chatID string) (domain.Chat, error)
ListChats(ctx context.Context, callerID, cursor string, limit int) (domain.Page[domain.Chat], error)
}
type MessageStore interface {
// AddMessage идемпотентен по (callerID, chatID, idempotencyKey): повтор с тем же
// text и attachmentIDs возвращает исходное сообщение, с другими — domain.ErrIdempotencyConflict.
// Вложение не из этого чата или неизвестное — domain.ErrNotFound.
AddMessage(ctx context.Context, callerID, chatID, idempotencyKey, text string, attachmentIDs []string) (domain.Message, error)
ListMessages(ctx context.Context, callerID, chatID, cursor string, limit int) (domain.Page[domain.Message], error)
}
type AttachmentStore interface {
CreateAttachment(ctx context.Context, att domain.Attachment) (domain.Attachment, error)
// AttachmentForMember для постороннего возвращает domain.ErrNotFound.
AttachmentForMember(ctx context.Context, callerID, attachmentID string) (domain.Attachment, error)
// AttachmentExists нужен компенсации: ошибка INSERT не доказывает, что строки нет.
AttachmentExists(ctx context.Context, attachmentID string) (bool, error)
}
type Store interface {
UserStore
ChatStore
MessageStore
AttachmentStore
}
+98
View File
@@ -0,0 +1,98 @@
package telemetry
import (
"context"
"os"
"runtime"
"strconv"
"strings"
"sync/atomic"
"syscall"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No SQL, parameters, DSN or exception messages are recorded.
type DBTracer struct{ Waiting atomic.Int64 }
func (t *DBTracer) TraceQueryStart(ctx context.Context, _ *pgx.Conn, d pgx.TraceQueryStartData) context.Context {
op := "query"
fields := strings.Fields(d.SQL)
if len(fields) > 0 {
switch strings.ToUpper(fields[0]) {
case "SELECT", "INSERT", "UPDATE", "DELETE", "BEGIN", "COMMIT", "ROLLBACK":
op = strings.ToUpper(fields[0])
}
}
ctx, _ = otel.Tracer("messenger").Start(ctx, "db."+op, trace.WithSpanKind(trace.SpanKindClient), trace.WithAttributes(attribute.String("db.system.name", "postgresql")))
return ctx
}
func (t *DBTracer) TraceQueryEnd(ctx context.Context, _ *pgx.Conn, d pgx.TraceQueryEndData) {
s := trace.SpanFromContext(ctx)
defer s.End()
if d.Err != nil && d.Err != pgx.ErrNoRows {
s.SetStatus(codes.Error, "database query failed")
s.SetAttributes(attribute.String("error.type", "database_error"))
}
}
func (t *DBTracer) TraceAcquireStart(ctx context.Context, _ *pgxpool.Pool, _ pgxpool.TraceAcquireStartData) context.Context {
t.Waiting.Add(1)
return ctx
}
func (t *DBTracer) TraceAcquireEnd(_ context.Context, _ *pgxpool.Pool, _ pgxpool.TraceAcquireEndData) {
t.Waiting.Add(-1)
}
func WatchPool(pool *pgxpool.Pool, tracer *DBTracer) error {
meter := otel.Meter("messenger")
used, err := meter.Int64ObservableGauge("db_pool_used")
if err != nil {
return err
}
waiting, err := meter.Int64ObservableGauge("db_pool_waiting")
if err != nil {
return err
}
capacity, err := meter.Int64ObservableGauge("db_pool_capacity")
if err != nil {
return err
}
cpu, err := meter.Float64ObservableCounter("process_cpu", metric.WithUnit("s"))
if err != nil {
return err
}
ram, err := meter.Int64ObservableGauge("process_memory", metric.WithUnit("By"))
if err != nil {
return err
}
_, err = meter.RegisterCallback(func(_ context.Context, o metric.Observer) error {
st := pool.Stat()
o.ObserveInt64(used, int64(st.AcquiredConns()))
o.ObserveInt64(waiting, tracer.Waiting.Load())
o.ObserveInt64(capacity, int64(st.MaxConns()))
var usage syscall.Rusage
if syscall.Getrusage(syscall.RUSAGE_SELF, &usage) == nil {
o.ObserveFloat64(cpu, float64(usage.Utime.Sec+usage.Stime.Sec)+float64(usage.Utime.Usec+usage.Stime.Usec)/1e6)
}
var mem runtime.MemStats
runtime.ReadMemStats(&mem)
rss := int64(mem.Sys)
if data, e := os.ReadFile("/proc/self/statm"); e == nil {
f := strings.Fields(string(data))
if len(f) > 1 {
if pages, e := strconv.ParseInt(f[1], 10, 64); e == nil {
rss = pages * int64(os.Getpagesize())
}
}
}
o.ObserveInt64(ram, rss)
return nil
}, used, waiting, capacity, cpu, ram)
return err
}

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