From 7b3eab54731d28103cefc9205e35bafa3a433ebf Mon Sep 17 00:00:00 2001 From: Nurlygayanova Ekaterina Date: Thu, 12 Nov 2026 20:32:55 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=A0=205:=20=D0=B0=D1=81=D0=B8=D0=BD?= =?UTF-8?q?=D1=85=D1=80=D0=BE=D0=BD=D0=BD=D0=B0=D1=8F=20=D0=BE=D0=B1=D1=80?= =?UTF-8?q?=D0=B0=D0=B1=D0=BE=D1=82=D0=BA=D0=B0=20=D0=B8=D0=B7=D0=BE=D0=B1?= =?UTF-8?q?=D1=80=D0=B0=D0=B6=D0=B5=D0=BD=D0=B8=D0=B9,=20=D1=83=D1=80?= =?UTF-8?q?=D0=BE=D0=B2=D0=B5=D0=BD=D1=8C=205?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .dockerignore | 1 + .env.example | 29 +- Dockerfile | 99 ++++ REPORT.md | 99 +++- app/cmd/messenger/main.go | 209 +++++++ app/cmd/s3init/main.go | 55 ++ app/cmd/worker/main.go | 375 +++++++++++++ app/cmd/worker/orientation.go | 99 ++++ app/cmd/worker/replay.go | 42 ++ app/cmd/worker/thumbnail.go | 35 ++ app/cmd/worker/variants.go | 87 +++ app/cmd/worker/variants_test.go | 73 +++ app/go.mod | 39 ++ app/go.sum | 79 +++ app/internal/api/http/attachments.go | 140 +++++ app/internal/api/http/auth.go | 69 +++ app/internal/api/http/chats.go | 103 ++++ app/internal/api/http/dto/attachment.go | 27 + app/internal/api/http/dto/chat.go | 18 + app/internal/api/http/dto/message.go | 37 ++ app/internal/api/http/dto/timestamp.go | 20 + app/internal/api/http/dto/user.go | 21 + app/internal/api/http/errors.go | 83 +++ app/internal/api/http/health.go | 24 + app/internal/api/http/messages.go | 80 +++ app/internal/api/http/middleware/auth.go | 61 ++ .../api/http/middleware/content_type.go | 42 ++ .../api/http/middleware/instance_id.go | 14 + app/internal/api/http/middleware/limits.go | 112 ++++ app/internal/api/http/middleware/logger.go | 48 ++ app/internal/api/http/middleware/recover.go | 32 ++ .../api/http/middleware/request_id.go | 22 + app/internal/api/http/router.go | 37 ++ app/internal/api/http/server.go | 174 ++++++ app/internal/api/http/users.go | 114 ++++ app/internal/cache/history.go | 478 ++++++++++++++++ app/internal/config/attachments.go | 40 ++ app/internal/config/config.go | 215 +++++++ app/internal/config/database.go | 13 + app/internal/config/env.go | 176 ++++++ app/internal/config/history_cache.go | 11 + app/internal/config/http.go | 12 + app/internal/config/idempotency.go | 8 + app/internal/config/limits.go | 8 + app/internal/config/logger.go | 5 + app/internal/config/session.go | 13 + app/internal/domain/attachment.go | 39 ++ app/internal/domain/chat.go | 10 + app/internal/domain/errors.go | 27 + app/internal/domain/message.go | 13 + app/internal/domain/page.go | 67 +++ app/internal/domain/session.go | 9 + app/internal/domain/user.go | 10 + app/internal/imagecheck/imagecheck.go | 128 +++++ app/internal/logging/logging.go | 51 ++ app/internal/objectstore/memory.go | 117 ++++ app/internal/objectstore/objectstore.go | 34 ++ app/internal/objectstore/s3.go | 251 +++++++++ app/internal/password/password.go | 112 ++++ app/internal/pipeline/pipeline.go | 91 +++ app/internal/service/attachments.go | 291 ++++++++++ app/internal/service/auth.go | 101 ++++ app/internal/service/chats.go | 47 ++ app/internal/service/messages.go | 50 ++ app/internal/service/service.go | 50 ++ app/internal/service/users.go | 44 ++ app/internal/session/memory.go | 49 ++ app/internal/session/session.go | 21 + app/internal/session/valkey.go | 120 ++++ app/internal/store/db/attachments.go | 127 +++++ app/internal/store/db/chats.go | 165 ++++++ app/internal/store/db/db.go | 136 +++++ app/internal/store/db/invalidations.go | 59 ++ app/internal/store/db/messages.go | 235 ++++++++ app/internal/store/db/text.go | 22 + app/internal/store/db/users.go | 89 +++ app/internal/store/memory.go | 368 ++++++++++++ app/internal/store/store.go | 43 ++ app/internal/token/token.go | 42 ++ app/internal/validate/attachment.go | 70 +++ app/internal/validate/chat.go | 42 ++ app/internal/validate/idempotency.go | 12 + app/internal/validate/message.go | 14 + app/internal/validate/rules.go | 80 +++ app/internal/validate/user.go | 30 + compose.yaml | 363 ++++++++++++ evidence/README.md | 5 - evidence/build.txt | 263 +++++++++ evidence/check.txt | 2 + evidence/environment.json | 12 + evidence/go-tests.txt | 27 + evidence/overload-check.txt | 8 + evidence/overload-results.json | 528 ++++++++++++++++++ evidence/pipeline-check.txt | 6 + evidence/smoke.txt | 2 + evidence/track1-check.txt | 21 + infra/haproxy/haproxy.cfg | 54 ++ infra/s3-gateway/haproxy.cfg | 37 ++ infra/seaweedfs/master.toml | 4 + migrations/00001_create_users_table.sql | 22 + migrations/00002_create_chats_table.sql | 16 + .../00003_create_chat_members_table.sql | 16 + migrations/00004_create_messages_table.sql | 25 + migrations/00005_escape_nul_in_text.sql | 45 ++ ...00006_create_cache_invalidations_table.sql | 23 + ..._create_message_idempotency_keys_table.sql | 32 ++ .../00008_create_attachments_tables.sql | 69 +++ migrations/00009_jobs.sql | 10 + migrations/00010_pipeline.sql | 17 + migrations/00011_overload.sql | 6 + scripts/check-pipeline.py | 145 +++++ scripts/init-secrets.sh | 108 ++++ scripts/overload-study.py | 171 ++++++ scripts/restart.example.sh | 0 scripts/stop-one.example.sh | 0 115 files changed, 8847 insertions(+), 34 deletions(-) create mode 100644 Dockerfile create mode 100644 app/cmd/messenger/main.go create mode 100644 app/cmd/s3init/main.go create mode 100644 app/cmd/worker/main.go create mode 100644 app/cmd/worker/orientation.go create mode 100644 app/cmd/worker/replay.go create mode 100644 app/cmd/worker/thumbnail.go create mode 100644 app/cmd/worker/variants.go create mode 100644 app/cmd/worker/variants_test.go create mode 100644 app/go.mod create mode 100644 app/go.sum create mode 100644 app/internal/api/http/attachments.go create mode 100644 app/internal/api/http/auth.go create mode 100644 app/internal/api/http/chats.go create mode 100644 app/internal/api/http/dto/attachment.go create mode 100644 app/internal/api/http/dto/chat.go create mode 100644 app/internal/api/http/dto/message.go create mode 100644 app/internal/api/http/dto/timestamp.go create mode 100644 app/internal/api/http/dto/user.go create mode 100644 app/internal/api/http/errors.go create mode 100644 app/internal/api/http/health.go create mode 100644 app/internal/api/http/messages.go create mode 100644 app/internal/api/http/middleware/auth.go create mode 100644 app/internal/api/http/middleware/content_type.go create mode 100644 app/internal/api/http/middleware/instance_id.go create mode 100644 app/internal/api/http/middleware/limits.go create mode 100644 app/internal/api/http/middleware/logger.go create mode 100644 app/internal/api/http/middleware/recover.go create mode 100644 app/internal/api/http/middleware/request_id.go create mode 100644 app/internal/api/http/router.go create mode 100644 app/internal/api/http/server.go create mode 100644 app/internal/api/http/users.go create mode 100644 app/internal/cache/history.go create mode 100644 app/internal/config/attachments.go create mode 100644 app/internal/config/config.go create mode 100644 app/internal/config/database.go create mode 100644 app/internal/config/env.go create mode 100644 app/internal/config/history_cache.go create mode 100644 app/internal/config/http.go create mode 100644 app/internal/config/idempotency.go create mode 100644 app/internal/config/limits.go create mode 100644 app/internal/config/logger.go create mode 100644 app/internal/config/session.go create mode 100644 app/internal/domain/attachment.go create mode 100644 app/internal/domain/chat.go create mode 100644 app/internal/domain/errors.go create mode 100644 app/internal/domain/message.go create mode 100644 app/internal/domain/page.go create mode 100644 app/internal/domain/session.go create mode 100644 app/internal/domain/user.go create mode 100644 app/internal/imagecheck/imagecheck.go create mode 100644 app/internal/logging/logging.go create mode 100644 app/internal/objectstore/memory.go create mode 100644 app/internal/objectstore/objectstore.go create mode 100644 app/internal/objectstore/s3.go create mode 100644 app/internal/password/password.go create mode 100644 app/internal/pipeline/pipeline.go create mode 100644 app/internal/service/attachments.go create mode 100644 app/internal/service/auth.go create mode 100644 app/internal/service/chats.go create mode 100644 app/internal/service/messages.go create mode 100644 app/internal/service/service.go create mode 100644 app/internal/service/users.go create mode 100644 app/internal/session/memory.go create mode 100644 app/internal/session/session.go create mode 100644 app/internal/session/valkey.go create mode 100644 app/internal/store/db/attachments.go create mode 100644 app/internal/store/db/chats.go create mode 100644 app/internal/store/db/db.go create mode 100644 app/internal/store/db/invalidations.go create mode 100644 app/internal/store/db/messages.go create mode 100644 app/internal/store/db/text.go create mode 100644 app/internal/store/db/users.go create mode 100644 app/internal/store/memory.go create mode 100644 app/internal/store/store.go create mode 100644 app/internal/token/token.go create mode 100644 app/internal/validate/attachment.go create mode 100644 app/internal/validate/chat.go create mode 100644 app/internal/validate/idempotency.go create mode 100644 app/internal/validate/message.go create mode 100644 app/internal/validate/rules.go create mode 100644 app/internal/validate/user.go create mode 100644 compose.yaml delete mode 100644 evidence/README.md create mode 100644 evidence/build.txt create mode 100644 evidence/check.txt create mode 100644 evidence/environment.json create mode 100644 evidence/go-tests.txt create mode 100644 evidence/overload-check.txt create mode 100644 evidence/overload-results.json create mode 100644 evidence/pipeline-check.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/track1-check.txt create mode 100644 infra/haproxy/haproxy.cfg create mode 100644 infra/s3-gateway/haproxy.cfg create mode 100644 infra/seaweedfs/master.toml create mode 100644 migrations/00001_create_users_table.sql create mode 100644 migrations/00002_create_chats_table.sql create mode 100644 migrations/00003_create_chat_members_table.sql create mode 100644 migrations/00004_create_messages_table.sql create mode 100644 migrations/00005_escape_nul_in_text.sql create mode 100644 migrations/00006_create_cache_invalidations_table.sql create mode 100644 migrations/00007_create_message_idempotency_keys_table.sql create mode 100644 migrations/00008_create_attachments_tables.sql create mode 100644 migrations/00009_jobs.sql create mode 100644 migrations/00010_pipeline.sql create mode 100644 migrations/00011_overload.sql create mode 100644 scripts/check-pipeline.py create mode 100644 scripts/init-secrets.sh create mode 100644 scripts/overload-study.py mode change 100755 => 100644 scripts/restart.example.sh mode change 100755 => 100644 scripts/stop-one.example.sh diff --git a/.dockerignore b/.dockerignore index bc16e55..2b710ee 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,4 @@ __pycache__ node_modules evidence .DS_Store +app/messenger diff --git a/.env.example b/.env.example index 119384b..85feef8 100644 --- a/.env.example +++ b/.env.example @@ -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 @@ -18,8 +18,27 @@ S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id 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 +# Загрузок на одну реплику одновременно; сверх него API отвечает 429. Определяет объём диска под +# временные файлы: не больше MAX_CONCURRENT_UPLOADS x MAX_UPLOAD_BYTES. +MAX_CONCURRENT_UPLOADS=16 +# Очиститель объектов S3 без метаданных. Grace period не меньше 60 с: моложе может быть идущая загрузка. +JANITOR_GRACE_SECONDS=3600 +JANITOR_INTERVAL_SECONDS=600 +JANITOR_MAX_DELETES=1000 +JANITOR_DRY_RUN=false + +# Host used in direct-upload signatures (local development). +S3_PUBLIC_ENDPOINT=http://127.0.0.1:19090 + +# Maximum internal SeaweedFS volumes; existing data is preserved on restart. +S3_MAX_VOLUMES=64 + +# lab5: retries; bounded worker pool. Fault flags are disabled by default. JOB_MAX_ATTEMPTS=5 -JOB_TIMEOUT_SECONDS=60 -STAGING_RETENTION_SECONDS=86400 +FAULT_AFTER_UPLOAD_COMMIT=0 +FAULT_AFTER_OBJECTS=0 +FAULT_BEFORE_ACK=0 + +WORKER_CONCURRENCY=1 +WORKER_PREFETCH=1 +JOB_MAX_INFLIGHT=64 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..7c6fd33 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,99 @@ +# 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 + +# Одноразовая подготовка S3-bucket. +RUN CGO_ENABLED=0 GOOS=linux go build \ + -ldflags="-s -w" \ + -trimpath \ + -o /out/s3init ./cmd/s3init + +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -o /out/worker ./cmd/worker + +# Проверки с настоящим WebP encoder, включая целостность crop после генерации optimized. +# docker build --target tests -t mtusi-lab5-tests . +FROM builder AS tests +RUN apk add --no-cache libwebp-tools +RUN go test -v ./... + +# Этап 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"] + +# Образ одноразового сервиса 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"] + +FROM alpine:3.24.3 AS worker +RUN apk add --no-cache ca-certificates libwebp-tools +COPY --from=builder /out/worker /usr/local/bin/worker +USER nobody +ENTRYPOINT ["/usr/local/bin/worker"] + +# Итоговый образ 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"] diff --git a/REPORT.md b/REPORT.md index e98f75e..b526d73 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,88 @@ -# Отчёт — лабораторная 5 +# Лабораторная 5 — уровень 5, трек 1 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +Автор: Нурлыгаянова Екатерина, группа БПИ2302. Реализация Go, PostgreSQL, Valkey и SeaweedFS; использована помощь Codex. -## Запуск из чистого clone +Стенд всех проверок: macOS arm64, Docker Desktop Linux aarch64, 12 vCPU / 7.65 GiB RAM виртуальной машины, отдельный Compose-проект `lab5-audit`. Дата и параметры среды записаны в `evidence/environment.json`. Проверялась текущая рабочая копия после исправления ожидания готовности API через балансировщик. Версии runtime/образов закреплены в Dockerfile и compose.yaml; лимиты CPU/RAM указаны в compose.yaml. -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Запуск: +```sh +cp .env.example .env # только на чистом clone +sh scripts/init-secrets.sh +docker compose up -d --build --wait +make test +python3 scripts/check-pipeline.py +``` +Остановка: `docker compose stop`; данные сохраняются в volumes. `docker compose down -v` намеренно удаляет учебные данные. -## Архитектура и решения +API сохраняет проверенный оригинал в S3 staging. Метаданные и outbox создаются одной транзакцией PostgreSQL, после COMMIT возвращается 202. Dispatcher в API и worker публикует незавершённые намерения в Valkey (AOF, fsync always, volume); интервал 1 с, повтор публикации через 30 с. Crash до publish или после publish до COMMIT dispatcher приводит к повтору, а не потере. Сообщение содержит только ID, версию, номер попытки и время. PostgreSQL — источник истины, брокер — доставка at least once. -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Worker отдельный: один процесс-владелец защищён сессионной advisory lock PostgreSQL, внутри — WORKER_CONCURRENCY обработчиков (1–8) и общий WORKER_PREFETCH (concurrency–64, включает выполняемые и ожидающие локально сообщения). По умолчанию 1/1; префетч не означает одновременное декодирование всех сообщений. Потеря соединения с этой блокировкой завершает worker; Compose автоматически перезапускает его, заново захватывает блокировку и восстанавливает неподтверждённые сообщения. Попытка захватывается атомарным UPDATE, lease 60 с. Обработка в дочернем процессе с жёстким лимитом 45 с, смерть родителя завершает дочерний процесс. Просроченный processing восстанавливается через outbox. Запись ready проверяет номер захваченной попытки; ready/failed не исполняются повторно. Ключи объектов детерминированы по attachment_id и варианту, pipeline_version=1. -## Доказательства критериев +Варианты после применения EXIF orientation: +- thumbnail: JPEG quality 85, вписан в 256×256 без увеличения; +- crop: JPEG quality 85, центрированный квадрат 128×128, увеличение разрешено; +- optimized: WebP quality 80, вписан в 1280×1280 без увеличения. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Прозрачность компонуется на белый. Decode/re-encode удаляет EXIF/ICC/XMP; WebP дополнительно `-metadata none`. Масштабирование nearest neighbour — учебное упрощение качества. Оригинал сохраняется побайтно. Ready публикуется только после записи всех четырёх объектов. Staging удаляется после ready; неудачная очистка повторяется по сохранённой outbox-строке. Неуспешные staging сохраняются для ручного replay без автоматического удаления; бесконечный retention — ограничение учебного стенда. Непринятые orphan-объекты требуют ручной уборки; автоматический janitor не реализован. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Лимиты worker: 10 MiB, 40 млн пикселей до decode, 45 с на попытку, cgroup 1 GiB и GOMEMLIMIT 512 MiB. OOM/смерть процесса восстанавливается по lease. JPEG/PNG с ошибкой декодирования/размера — постоянная ошибка invalid_image. Ошибки I/O/encoder — временные; максимум JOB_MAX_ATTEMPTS (по умолчанию 5). Exponential backoff с jitter: 0.5–1, 1–2, 2–4… до 32–64 с; доставка дополнительно может задержаться до 30 с. При исчерпании — failed/retry_exhausted. Реестр failed — таблица attachments, error_code не содержит секретов. -## Эксперименты и отказы +Операторские команды: +```sh +docker compose exec worker /usr/local/bin/worker failed +docker compose exec worker /usr/local/bin/worker replay UUID +``` +Replay разрешён только для failed при доступном staging; атомарно сбрасывает попытки, создаёт outbox и audit в attachment_replays. Ready не откатывается. Доступ оператора ограничен доступом к Docker/секретам стенда. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Короткие проверки: +- `cd app && go test ./...` (Linux; на macOS используйте Docker из следующего пункта): сборка, размеры thumbnail, композиция alpha, границы jitter/backoff и целостность вариантов; WebP-проверка запускается при наличии cwebp. +- `docker build --target tests -t mtusi-lab5-tests .`: те же Go-тесты с установленным cwebp, без пропуска проверки вариантов. При DNS-проблемах сети Docker можно добавить `--network host`. +- `make check`: проверка структуры/контракта. +- `make test`: публичный API smoke. +- `python3 scripts/check-pipeline.py`: реальный exit API после COMMIT при остановленном broker; восстановление из outbox; exit worker после S3 до ready и после ready до ack; повторная доставка, запрет replay ready; перезапуск broker/API с принятой задачей; исчерпание двух попыток при недоступном S3, audit и успешный replay failed; автоматический перезапуск worker при потере PostgreSQL-сессии. В тесте lease переводится в прошлое SQL-командой вместо ожидания 60 с. Нагрузка не запускается. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Fault hooks FAULT_AFTER_UPLOAD_COMMIT, FAULT_AFTER_OBJECTS, FAULT_BEFORE_ACK выключены по умолчанию. Worker fault срабатывает один раз на контейнер (маркер в /tmp). Один Docker-host, одна БД, один брокер и один активный worker не обеспечивают HA host. Это идемпотентный эффект с повторной доставкой, не exactly-once. -## Ограничения и следующие шаги +Тест сбоев перед началом и после перезапуска API ждёт HTTP 200 от `/health/ready` по клиентскому адресу через балансировщик. Готовность процесса внутри контейнера ещё не означает, что HAProxy вернул реплики в работу; временный 503 допустим только во время этого ожидания. Проверки метаданных, файлов и состояний выполняются без ослабления требований. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Новый полный прогон: `evidence/track1-check.txt`; вывод аварийных сценариев — `evidence/pipeline-check.txt`, Go-тестов без кеша — `evidence/go-tests.txt`, smoke — `evidence/smoke.txt`, структуры — `evidence/check.txt`, сборки/запуска — `evidence/build.txt`. Сырые нагрузочные замеры — `evidence/overload-results.json`, stdout эксперимента — `evidence/overload-check.txt`. Ссылка на PR добавляется после его создания. + + +## Трек 1: короткая перегрузка очереди + +Гипотеза: увеличение concurrency ускоряет опустошение очереди крупных изображений ценой RSS; избыточный prefetch сам по себе не добавляет CPU. Сравниваем 1/1, 2/2, 4/8 при одинаковом лимите worker 2 CPU / 1 GiB, двух API по 1 CPU / 1 GiB. Глобальный JOB_MAX_INFLIGHT по умолчанию 64; в эксперименте 12. PostgreSQL сериализует проверку числа queued/processing и INSERT через транзакционную advisory lock, поэтому лимит общий для реплик. При заполнении возвращается 429, временный staging отклонённой загрузки удаляется компенсацией. Слоты HTTP-загрузок отдельно ограничивают ещё не принятые запросы. + +Повторение на отдельном учебном проекте (предварительно создать .env и secrets по инструкции выше): +```sh +export COMPOSE_PROJECT_NAME=lab5-audit +export BASE_URL=http://localhost:28085 API_PUBLISH_PORT=28085 +export POSTGRES_PORT=25435 VALKEY_PORT=26385 JOB_MAX_INFLIGHT=12 +docker compose up -d --build --wait +python3 -u scripts/overload-study.py +make test BASE_URL="$BASE_URL" +docker compose down +``` +Порт S3 gateway 19090 также должен быть свободен. Скрипт меняет/останавливает только worker выбранного проекта; запускать при пустой очереди без других клиентов. + +Методика: один прогревочный render на настройку, затем по одному burst для PNG 320×200 и 2000×1400, детерминированная текстура seed=42. При остановленном worker четыре клиента предлагают 16 загрузок: 12 принимаются, 4 получают 429. После запуска worker проверяются ready всех принятых ID, метаданные вариантов и опустошение pending/active, затем новая загрузка и скачивание её оригинала/трёх вариантов. Получается шесть коротких прогонов вместо длительного нагрузочного теста. + +Throughput = 12 / время от команды запуска worker до последнего ready; queue lag = первое processing минус created_at; latency = ready минус created_at. p95 — nearest rank по 12 задачам; включает намеренную остановку worker и сбор burst, но не передачу файла до создания строки. RSS — сумма VmRSS процессов контейнера worker (родитель, render и cwebp, плюс краткоживущий измеритель); сэмплирование с паузой 250 мс плюс время Docker/SQL-вызовов. Это RSS, не docker memory usage; общие страницы могут учитываться повторно. Исходные сэмплы и среда сохраняются в evidence/overload-results.json. + +Результаты 2026-11-12: единый стенд `lab5-audit`, macOS arm64, Docker Desktop Linux aarch64, 12 vCPU / 7.65 GiB RAM VM. Начало нагрузочного прогона: `2026-11-12T16:52:03.496180+00:00`. Суммарная активная нагрузка — десятки секунд. + +| Concurrency/prefetch | Изображение | Throughput, задач/с | Queue lag p95, с | До ready p95, с | RSS max, МиБ | Drain, с | +| --- | --- | --- | --- | --- | --- | --- | +| 1/1 | 320×200 | 7.08 | 2.77 | 2.79 | 29.39 | 1.69 | +| 1/1 | 2000×1400 | 1.62 | 7.78 | 8.12 | 86.66 | 7.41 | +| 2/2 | 320×200 | 7.93 | 2.30 | 2.33 | 13.96 | 1.51 | +| 2/2 | 2000×1400 | 2.34 | 4.59 | 5.96 | 151.33 | 5.12 | +| 4/8 | 320×200 | 8.27 | 2.49 | 2.52 | 81.05 | 1.45 | +| 4/8 | 2000×1400 | 3.55 | 3.20 | 3.80 | 236.79 | 3.38 | + +В каждой строке: 12 принятых, 4 отказа 429, 12 ready с одной попытки, итоговые pending=active=0; дополнительный запрос после разгрузки принят и обработан, байты его оригинала и checksums вариантов проверены скачиванием. При 4/8 наблюдаемый максимум unacked для крупных изображений — 8; одновременно работают максимум 4 render-процесса. Для основных 72 задач проверены ready, список вариантов и checksum оригинала в метаданных. + +Дополнительная перегрузка **без остановки worker**, настройка 4/8: 32 загрузки 2000×1400, 8 клиентов; 16 приняты, 16 получили 429. Наблюдаемый максимум queued+processing=12, все 16 принятых дошли до ready; следующая загрузка также успешна. Приём, разгрузка и контрольный запрос заняли 7.84 с. Сэмплы числа незавершённых задач записаны в JSON. + +Вывод: для крупных файлов throughput 4/8 выше 1/1 на 119.3%, наблюдаемый RSS выше в 2.73 раза. При лимите 2 CPU дополнительные обработчики конкурируют за CPU и S3. Лучший p95 до ready в этом прогоне у 4/8: 3.80 с. Эта latency включает время набора burst и остановку worker, поэтому её нельзя трактовать как изолированную скорость обработки. Больший prefetch переносит ожидание из брокера в локальную очередь worker, но не увеличивает число render; отдельно эффект prefetch этим сравнением не изолирован. + +Ограничения: по одному короткому прогону, всего 12 наблюдений на строку; p95 при таком n равен максимуму, доверительных интервалов нет. Для маленьких файлов получено по 2 RSS-сэмпла, для крупных — 6–14. Накладные расходы запуска/Docker существенны; краткий пик памяти может быть пропущен. Приведены наблюдаемые RSS, не гарантированные абсолютные пики. Замеры доказывают ограниченный burst, backpressure и восстановление, не устойчивую предельную производительность или длительную работу под перегрузкой. Worker с 8×40 Мп может исчерпать cgroup; такое значение не рекомендуется без отдельного подбора памяти. Лимит 12/64 ограничивает незавершённую работу, но не суммарный объём уже готовых/failed файлов; retention остаётся ограничением уровня 4. diff --git a/app/cmd/messenger/main.go b/app/cmd/messenger/main.go new file mode 100644 index 0000000..c3f961e --- /dev/null +++ b/app/cmd/messenger/main.go @@ -0,0 +1,209 @@ +// messenger — сервер API мессенджера, один процесс одной реплики. Своего состояния у реплики нет: +// данные лежат в PostgreSQL, сессии в Valkey, поэтому реплик может быть несколько. +// +// Здесь только сборка: загрузка настроек, подключения, создание сервисов, запуск HTTP-сервера и +// штатное завершение по SIGTERM. Логика находится в internal. +package main + +import ( + "context" + "fmt" + "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/pipeline" + "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" +) + +// 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) + + // Пул подключений к 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() + go pipeline.Dispatch(ctx, pool) + + // Фоновая очистка старых ключей идемпотентности. Останавливается вместе с 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: + } + } +} diff --git a/app/cmd/s3init/main.go b/app/cmd/s3init/main.go new file mode 100644 index 0000000..9135f73 --- /dev/null +++ b/app/cmd/s3init/main.go @@ -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): + } + } +} diff --git a/app/cmd/worker/main.go b/app/cmd/worker/main.go new file mode 100644 index 0000000..7b85403 --- /dev/null +++ b/app/cmd/worker/main.go @@ -0,0 +1,375 @@ +package main + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "image" + + _ "image/jpeg" + _ "image/png" + "io" + "log" + "math/rand/v2" + "os" + "os/exec" + "os/signal" + "strconv" + "sync" + "syscall" + "time" + + "errors" + "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config" + "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain" + "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore" + "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/pipeline" + "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store/db" + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" +) + +func main() { + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) + defer stop() + cfg, err := config.Load() + if err != nil { + log.Fatal(err) + } + pool, err := db.Connect(ctx, cfg.Database) + if err != nil { + log.Fatal(err) + } + defer pool.Close() + objects, err := objectstore.NewS3(cfg.S3) + if err != nil { + log.Fatal(err) + } + if len(os.Args) == 4 && os.Args[1] == "render" { + conn, e := pool.Acquire(ctx) + if e != nil { + os.Exit(1) + } + defer conn.Release() + attempt, _ := strconv.Atoi(os.Args[3]) + e = render(ctx, conn, objects, os.Args[2], attempt) + if e != nil { + var pe permanentError + if errors.As(e, &pe) { + os.Exit(42) + } + os.Exit(1) + } + return + } + if len(os.Args) == 3 && os.Args[1] == "replay" { + if err := replay(ctx, pool, objects, os.Args[2]); err != nil { + log.Fatal(err) + } + log.Print("replay queued") + return + } + if len(os.Args) == 2 && os.Args[1] == "failed" { + rows, e := pool.Query(ctx, `SELECT id::text,error_code,attempts FROM attachments WHERE status='failed' ORDER BY updated_at DESC LIMIT 100`) + if e != nil { + log.Fatal(e) + } + defer rows.Close() + for rows.Next() { + var id, code string + var n int + if e = rows.Scan(&id, &code, &n); e != nil { + log.Fatal(e) + } + fmt.Println(id, code, n) + } + if rows.Err() != nil { + log.Fatal(rows.Err()) + } + return + } + go pipeline.Dispatch(ctx, pool) + c := pipeline.Client() + defer c.Close() + maxAttempts := 5 + if s := os.Getenv("JOB_MAX_ATTEMPTS"); s != "" { + n, e := strconv.Atoi(s) + if e != nil || n < 1 { + log.Fatal("invalid JOB_MAX_ATTEMPTS") + } + maxAttempts = n + } + // Один worker держит сессионную блокировку PostgreSQL. После его смерти новый + // worker возвращает неподтверждённые сообщения в очередь. + lock, err := pool.Acquire(ctx) + if err != nil { + log.Fatal(err) + } + defer lock.Release() + if _, err = lock.Exec(ctx, "SELECT pg_advisory_lock(505001)"); err != nil { + log.Fatal(err) + } + for ctx.Err() == nil { + _, err = c.RPopLPush(ctx, pipeline.Active, pipeline.Pending).Result() + if errors.Is(err, redis.Nil) { + break + } + if err != nil { + log.Fatal("queue recovery failed") + } + } + concurrency := positiveEnv("WORKER_CONCURRENCY", 1, 8) + prefetch := positiveEnv("WORKER_PREFETCH", concurrency, 64) + if prefetch < concurrency { + log.Fatal("WORKER_PREFETCH must be >= WORKER_CONCURRENCY") + } + if int(cfg.Database.MaxConns) < concurrency+2 { + log.Fatal("DB_MAX_CONNS must be >= WORKER_CONCURRENCY+2") + } + slots := make(chan struct{}, prefetch) + jobs := make(chan string, prefetch) + var workers sync.WaitGroup + for i := 0; i < concurrency; i++ { + workers.Add(1) + go func() { + defer workers.Done() + for raw := range jobs { + func() { + defer func() { <-slots }() + conn, e := pool.Acquire(ctx) + if e != nil { + return + } // Active entry is recovered on restart; outbox also retries. + defer conn.Release() + var job pipeline.Job + if json.Unmarshal([]byte(raw), &job) != nil || !validJob(job) { + log.Print("invalid job") + if err := c.Eval(ctx, `redis.call("LPUSH", KEYS[2], ARGV[1]); return redis.call("LREM", KEYS[1], 1, ARGV[1])`, []string{pipeline.Active, "attachments:invalid"}, raw).Err(); err != nil { + return + } + return + } + for ctx.Err() == nil { + done, err := process(ctx, conn, objects, job.AttachmentID, maxAttempts) + if err != nil { + log.Printf("job %s: %v", job.JobID, err) + if conn.Conn().IsClosed() { + log.Fatal("worker database session lost; restart required") + } + } + if done { + if os.Getenv("FAULT_BEFORE_ACK") == "1" { + faultOnce("/tmp/fault-before-ack") + } + if err = c.LRem(ctx, pipeline.Active, 1, raw).Err(); err != nil { + log.Fatal("queue ack failed; restart required") + } + break + } + select { + case <-ctx.Done(): + return + case <-time.After(time.Second): + } + } + }() + } + }() + } + defer func() { close(jobs); workers.Wait() }() + for ctx.Err() == nil { + // The owner session alone holds the advisory lock and performs maintenance. + rows, e := lock.Query(ctx, `SELECT o.attachment_id::text FROM attachment_outbox o JOIN attachments a ON a.id=o.attachment_id WHERE a.status='ready' LIMIT 16`) + if e != nil && lock.Conn().IsClosed() { + log.Fatal("worker database session lost; restart required") + } + if e == nil { + var ids []string + for rows.Next() { + var id string + if rows.Scan(&id) == nil { + ids = append(ids, id) + } + } + rows.Close() + for _, id := range ids { + _ = cleanup(ctx, lock, objects, id) + } + } + select { + case slots <- struct{}{}: + case <-ctx.Done(): + return + case <-time.After(200 * time.Millisecond): + continue + } + raw, err := c.BRPopLPush(ctx, pipeline.Pending, pipeline.Active, time.Second).Result() + if err != nil { + <-slots + continue + } + select { + case jobs <- raw: + case <-ctx.Done(): + <-slots + return + } + } +} + +func positiveEnv(name string, fallback, maximum int) int { + value := os.Getenv(name) + if value == "" { + return fallback + } + n, err := strconv.Atoi(value) + if err != nil || n < 1 || n > maximum { + log.Fatalf("invalid %s (1..%d)", name, maximum) + } + return n +} + +// One owner with bounded concurrent render processes. A killed render subprocess cannot outlive its deadline. +func process(ctx context.Context, p *pgxpool.Conn, s objectstore.Store, id string, max int) (bool, error) { + var attempt int + err := p.QueryRow(ctx, `UPDATE attachments SET status='processing',attempts=attempts+1, + lease_until=now()+interval '60 seconds',processing_started_at=COALESCE(processing_started_at,now()),updated_at=now() + WHERE id=$1 AND attempts<$2 AND ((status='queued' AND next_attempt_at<=now()) OR + (status='processing' AND lease_until= $2 AND (status='queued' OR (status='processing' AND lease_until= max { + code = "retry_exhausted" + status = "failed" + } + if deadline.Err() != nil { + code = "processing_timeout" + } + delay := retryDelay(attempt) + _, e := p.Exec(ctx, `UPDATE attachments SET status=$3,error_code=$4,lease_until=NULL, + next_attempt_at=now()+($5 * interval '1 millisecond'),updated_at=now() + WHERE id=$1 AND attempts=$2 AND status='processing'`, id, attempt, status, code, delay.Milliseconds()) + // The outbox is still present. Ack only after durable retry/failed state. + return e == nil, e +} +func retryDelay(attempt int) time.Duration { + capMs := int64(1000) << min(max(attempt-1, 0), 6) + return time.Duration(capMs/2+rand.Int64N(capMs/2+1)) * time.Millisecond +} + +type permanentError struct{ error } + +func faultOnce(path string) { + f, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600) + if err == nil { + f.Close() + os.Exit(86) + } +} +func render(ctx context.Context, p *pgxpool.Conn, s objectstore.Store, id string, attempt int) error { + var key, ct string + if err := p.QueryRow(ctx, `SELECT object_key,content_type FROM attachments WHERE id=$1 AND attempts=$2 AND status='processing'`, id, attempt).Scan(&key, &ct); err != nil { + return err + } + r, _, err := s.Get(ctx, key) + if err != nil { + return err + } + data, err := io.ReadAll(io.LimitReader(r, 10485761)) + r.Close() + if err != nil { + return err + } + if len(data) > 10485760 { + return permanentError{fmt.Errorf("image too large")} + } + cfg, _, err := image.DecodeConfig(bytes.NewReader(data)) + if err != nil { + return permanentError{err} + } + if cfg.Width <= 0 || cfg.Height <= 0 || int64(cfg.Width)*int64(cfg.Height) > 40000000 { + return permanentError{fmt.Errorf("invalid image dimensions")} + } + im, _, err := image.Decode(bytes.NewReader(data)) + if err != nil { + return permanentError{err} + } + im = orient(im, data) + outputs, err := variants(ctx, im) + if err != nil { + return err + } + original := "originals/" + id + if err = s.Put(ctx, original, ct, bytes.NewReader(data), int64(len(data))); err != nil { + return err + } + var metadata []domain.Variant + for _, o := range outputs { + if err = s.Put(ctx, o.meta.Name+"s/"+id, o.meta.ContentType, bytes.NewReader(o.data), int64(len(o.data))); err != nil { + return err + } + metadata = append(metadata, o.meta) + } + if os.Getenv("FAULT_AFTER_OBJECTS") == "1" { + faultOnce("/tmp/fault-after-objects") + } + meta, _ := json.Marshal(metadata) + thumb, _ := json.Marshal(metadata[0]) + result, err := p.Exec(ctx, `UPDATE attachments SET status='ready',object_key=$2,thumbnail=$3,variants=$4, + error_code=NULL,lease_until=NULL,updated_at=now() WHERE id=$1 AND attempts=$5 AND status='processing'`, id, original, thumb, meta, attempt) + if err != nil { + return err + } + if result.RowsAffected() != 1 { + return fmt.Errorf("lost lease") + } + // Terminal state first; cleanup is retried by the worker maintenance loop. + return cleanup(ctx, p, s, id) +} +func cleanup(ctx context.Context, p *pgxpool.Conn, s objectstore.Store, id string) error { + if err := s.Delete(ctx, "staging/"+id); err != nil { + return err + } + _, err := p.Exec(ctx, `DELETE FROM attachment_outbox WHERE attachment_id=$1 AND EXISTS(SELECT 1 FROM attachments WHERE id=$1 AND status='ready')`, id) + + return err +} + +func validJob(j pipeline.Job) bool { + _, e1 := uuid.Parse(j.JobID) + _, e2 := uuid.Parse(j.AttachmentID) + return e1 == nil && e2 == nil && j.SchemaVersion == 1 && j.PipelineVersion == 1 && j.Type == "attachment.process.v1" && j.Attempt >= 1 && !j.CreatedAt.IsZero() +} diff --git a/app/cmd/worker/orientation.go b/app/cmd/worker/orientation.go new file mode 100644 index 0000000..888a7a4 --- /dev/null +++ b/app/cmd/worker/orientation.go @@ -0,0 +1,99 @@ +package main + +import ( + "bytes" + "encoding/binary" + "image" +) + +// EXIF IFD0 Orientation, включая отражения. Исходные байты не изменяются. +func orient(src image.Image, data []byte) image.Image { + orientation := 1 + if len(data) > 2 && data[0] == 255 && data[1] == 216 { + for pos := 2; pos+4 <= len(data); { + if data[pos] != 255 { + break + } + marker := data[pos+1] + if marker == 0xda || marker == 0xd9 { + break + } + n := int(binary.BigEndian.Uint16(data[pos+2 : pos+4])) + if n < 2 || pos+2+n > len(data) { + break + } + segment := data[pos+4 : pos+2+n] + if marker == 0xe1 && bytes.HasPrefix(segment, []byte("Exif\x00\x00")) { + orientation = exifOrientation(segment[6:]) + break + } + pos += 2 + n + } + } + if orientation < 2 || orientation > 8 { + return src + } + b := src.Bounds() + w, h := b.Dx(), b.Dy() + dw, dh := w, h + if orientation >= 5 { + dw, dh = h, w + } + dst := image.NewNRGBA(image.Rect(0, 0, dw, dh)) + for y := 0; y < h; y++ { + for x := 0; x < w; x++ { + dx, dy := x, y + switch orientation { + case 2: + dx = w - 1 - x + case 3: + dx, dy = w-1-x, h-1-y + case 4: + dy = h - 1 - y + case 5: + dx, dy = y, x + case 6: + dx, dy = h-1-y, x + case 7: + dx, dy = h-1-y, w-1-x + case 8: + dx, dy = y, w-1-x + } + dst.Set(dx, dy, src.At(b.Min.X+x, b.Min.Y+y)) + } + } + return dst +} +func exifOrientation(b []byte) int { + if len(b) < 8 { + return 1 + } + var order binary.ByteOrder + switch string(b[:2]) { + case "II": + order = binary.LittleEndian + case "MM": + order = binary.BigEndian + default: + return 1 + } + if order.Uint16(b[2:4]) != 42 { + return 1 + } + offset := uint64(order.Uint32(b[4:8])) + if offset+2 > uint64(len(b)) { + return 1 + } + count := int(order.Uint16(b[offset : offset+2])) + start := int(offset) + 2 + for i := 0; i < count; i++ { + p := start + i*12 + if p+12 > len(b) { + break + } + if order.Uint16(b[p:p+2]) == 0x112 && order.Uint16(b[p+2:p+4]) == 3 && order.Uint32(b[p+4:p+8]) == 1 { + return int(order.Uint16(b[p+8 : p+10])) + } + } + return 1 +} diff --git a/app/cmd/worker/replay.go b/app/cmd/worker/replay.go new file mode 100644 index 0000000..bcc9695 --- /dev/null +++ b/app/cmd/worker/replay.go @@ -0,0 +1,42 @@ +package main + +import ( + "context" + "fmt" + "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore" + "github.com/google/uuid" + "github.com/jackc/pgx/v5/pgxpool" +) + +func replay(ctx context.Context, p *pgxpool.Pool, s objectstore.Store, id string) error { + if _, err := uuid.Parse(id); err != nil { + return fmt.Errorf("invalid attachment id") + } + tx, err := p.Begin(ctx) + if err != nil { + return err + } + defer tx.Rollback(ctx) + var status, key string + if err = tx.QueryRow(ctx, `SELECT status,object_key FROM attachments WHERE id=$1 FOR UPDATE`, id).Scan(&status, &key); err != nil { + return err + } + if status != "failed" { + return fmt.Errorf("replay requires failed state; ready is never reset") + } + body, _, err := s.Get(ctx, key) + if err != nil { + return fmt.Errorf("staging unavailable") + } + body.Close() + if _, err = tx.Exec(ctx, `UPDATE attachments SET status='queued',attempts=0,processing_started_at=NULL,error_code=NULL,lease_until=NULL,next_attempt_at=now(),updated_at=now() WHERE id=$1`, id); err != nil { + return err + } + if _, err = tx.Exec(ctx, `INSERT INTO attachment_outbox(attachment_id) VALUES($1) ON CONFLICT(attachment_id) DO UPDATE SET next_publish_at=now()`, id); err != nil { + return err + } + if _, err = tx.Exec(ctx, `INSERT INTO attachment_replays(attachment_id) VALUES($1)`, id); err != nil { + return err + } + return tx.Commit(ctx) +} diff --git a/app/cmd/worker/thumbnail.go b/app/cmd/worker/thumbnail.go new file mode 100644 index 0000000..8b85bef --- /dev/null +++ b/app/cmd/worker/thumbnail.go @@ -0,0 +1,35 @@ +package main + +import ( + "bytes" + "image" + "image/color" + "image/jpeg" +) + +func thumbnail(im image.Image) ([]byte, int, int, error) { + b := im.Bounds() + w, h := b.Dx(), b.Dy() + nw, nh := w, h + if w > 256 || h > 256 { + if w >= h { + nw = 256 + nh = max(1, h*256/w) + } else { + nh = 256 + nw = max(1, w*256/h) + } + } + thumb := image.NewRGBA(image.Rect(0, 0, nw, nh)) + for y := 0; y < nh; y++ { + for x := 0; x < nw; x++ { + rr, gg, bb, aa := im.At(b.Min.X+x*w/nw, b.Min.Y+y*h/nh).RGBA() + thumb.SetRGBA(x, y, color.RGBA{uint8((rr + 65535 - aa) >> 8), uint8((gg + 65535 - aa) >> 8), uint8((bb + 65535 - aa) >> 8), 255}) + } + } + var out bytes.Buffer + if err := jpeg.Encode(&out, thumb, &jpeg.Options{Quality: 85}); err != nil { + return nil, 0, 0, err + } + return out.Bytes(), nw, nh, nil +} diff --git a/app/cmd/worker/variants.go b/app/cmd/worker/variants.go new file mode 100644 index 0000000..865582f --- /dev/null +++ b/app/cmd/worker/variants.go @@ -0,0 +1,87 @@ +package main + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain" + "image" + "image/color" + "image/jpeg" + "image/png" + "os" + "os/exec" + "syscall" +) + +type output struct { + meta domain.Variant + data []byte +} + +func newOutput(name, ct string, data []byte, w, h int) output { + sum := sha256.Sum256(data) + return output{domain.Variant{Name: name, ContentType: ct, SizeBytes: int64(len(data)), Width: w, Height: h, SHA256: hex.EncodeToString(sum[:])}, data} +} + +// Decode/re-encode drops EXIF/ICC/XMP; orientation is applied before this function. +func variants(ctx context.Context, im image.Image) ([]output, error) { + thumb, w, h, err := thumbnail(im) + if err != nil { + return nil, err + } + out := []output{newOutput("thumbnail", "image/jpeg", thumb, w, h)} + b := im.Bounds() + side := min(b.Dx(), b.Dy()) + x, y := b.Min.X+(b.Dx()-side)/2, b.Min.Y+(b.Dy()-side)/2 + crop := resize(im, image.Rect(x, y, x+side, y+side), 128, 128) + var buf bytes.Buffer + if err = jpeg.Encode(&buf, crop, &jpeg.Options{Quality: 85}); err != nil { + return nil, err + } + out = append(out, newOutput("crop", "image/jpeg", bytes.Clone(buf.Bytes()), 128, 128)) + w, h = b.Dx(), b.Dy() + if w > 1280 || h > 1280 { + if w >= h { + h = max(1, h*1280/w) + w = 1280 + } else { + w = max(1, w*1280/h) + h = 1280 + } + } + buf.Reset() + if err = png.Encode(&buf, resize(im, b, w, h)); err != nil { + return nil, err + } + f, err := os.CreateTemp("", "optimized-*.png") + if err != nil { + return nil, err + } + defer os.Remove(f.Name()) + if _, err = f.Write(buf.Bytes()); err != nil { + f.Close() + return nil, err + } + if err = f.Close(); err != nil { + return nil, err + } + cmd := exec.CommandContext(ctx, "cwebp", "-quiet", "-q", "80", "-metadata", "none", "-o", "-", f.Name()) + cmd.SysProcAttr = &syscall.SysProcAttr{Pdeathsig: syscall.SIGKILL} + data, err := cmd.Output() + if err != nil { + return nil, err + } + return append(out, newOutput("optimized", "image/webp", data, w, h)), nil +} +func resize(im image.Image, b image.Rectangle, w, h int) *image.RGBA { + dst := image.NewRGBA(image.Rect(0, 0, w, h)) + for y := 0; y < h; y++ { + for x := 0; x < w; x++ { + r, g, bl, a := im.At(b.Min.X+x*b.Dx()/w, b.Min.Y+y*b.Dy()/h).RGBA() + dst.SetRGBA(x, y, color.RGBA{uint8((r + 65535 - a) >> 8), uint8((g + 65535 - a) >> 8), uint8((bl + 65535 - a) >> 8), 255}) + } + } + return dst +} diff --git a/app/cmd/worker/variants_test.go b/app/cmd/worker/variants_test.go new file mode 100644 index 0000000..9be79f0 --- /dev/null +++ b/app/cmd/worker/variants_test.go @@ -0,0 +1,73 @@ +package main + +import ( + "bytes" + "context" + "crypto/sha256" + "encoding/hex" + "image" + "image/color" + "image/jpeg" + "os/exec" + "testing" + "time" +) + +func TestImageContract(t *testing.T) { + im := image.NewNRGBA(image.Rect(0, 0, 320, 200)) + im.SetNRGBA(160, 100, color.NRGBA{R: 255, A: 128}) + data, w, h, err := thumbnail(im) + if err != nil { + t.Fatal(err) + } + cfg, err := jpeg.DecodeConfig(bytes.NewReader(data)) + if err != nil || w != 256 || h != 160 || cfg.Width != 256 || cfg.Height != 160 { + t.Fatal("thumbnail contract", cfg, err) + } + // Transparent input must become white, not black. + small := image.NewNRGBA(image.Rect(0, 0, 8, 4)) + data, w, h, err = thumbnail(small) + decoded, err := jpeg.Decode(bytes.NewReader(data)) + if err != nil || w != 8 || h != 4 { + t.Fatal("small image enlarged", err) + } + r, g, b, _ := decoded.At(0, 0).RGBA() + if r < 65000 || g < 65000 || b < 65000 { + t.Fatal("alpha not composited on white") + } +} + +func TestRetryDelayBounds(t *testing.T) { + for attempt := 1; attempt <= 12; attempt++ { + ceiling := time.Second << min(attempt-1, 6) + for i := 0; i < 100; i++ { + delay := retryDelay(attempt) + if delay < ceiling/2 || delay > ceiling { + t.Fatalf("attempt %d delay %s outside [%s, %s]", attempt, delay, ceiling/2, ceiling) + } + } + } +} +func TestRealVariants(t *testing.T) { + if _, err := exec.LookPath("cwebp"); err != nil { + t.Skip("cwebp is installed in the worker image") + } + outputs, err := variants(context.Background(), image.NewRGBA(image.Rect(0, 0, 320, 200))) + if err != nil { + t.Fatal(err) + } + for _, output := range outputs { + sum := sha256.Sum256(output.data) + if hex.EncodeToString(sum[:]) != output.meta.SHA256 || int64(len(output.data)) != output.meta.SizeBytes { + t.Fatalf("%s bytes differ from metadata", output.meta.Name) + } + } + crop, err := jpeg.DecodeConfig(bytes.NewReader(outputs[1].data)) + if err != nil || crop.Width != 128 || crop.Height != 128 { + t.Fatal("crop", err) + } + webp := outputs[2] + if webp.meta.Width != 320 || webp.meta.Height != 200 || !bytes.Equal(webp.data[:4], []byte("RIFF")) || !bytes.Equal(webp.data[8:12], []byte("WEBP")) { + t.Fatal("WebP contract") + } +} diff --git a/app/go.mod b/app/go.mod new file mode 100644 index 0000000..c4d4c1d --- /dev/null +++ b/app/go.mod @@ -0,0 +1,39 @@ +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 + golang.org/x/crypto v0.57.0 + golang.org/x/sync v0.23.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.2.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/goccy/go-json v0.10.5 // 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 + golang.org/x/net v0.60.0 // indirect + golang.org/x/sys v0.48.0 // indirect + golang.org/x/text v0.42.0 // indirect +) diff --git a/app/go.sum b/app/go.sum new file mode 100644 index 0000000..cf065f5 --- /dev/null +++ b/app/go.sum @@ -0,0 +1,79 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.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/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/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.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= +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= +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= diff --git a/app/internal/api/http/attachments.go b/app/internal/api/http/attachments.go new file mode 100644 index 0000000..a64f9d4 --- /dev/null +++ b/app/internal/api/http/attachments.go @@ -0,0 +1,140 @@ +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 { + 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: attachmentVariants(a), + ErrorCode: a.ErrorCode, + CreatedAt: dto.NewTimestamp(a.CreatedAt), + UpdatedAt: dto.NewTimestamp(a.UpdatedAt), + } +} + +func attachmentVariants(a domain.Attachment) []dto.VariantResponse { + v := []dto.VariantResponse{} + if a.Status == domain.StatusReady { + for _, t := range a.Variants { + v = append(v, dto.VariantResponse{Name: t.Name, ContentType: t.ContentType, SizeBytes: t.SizeBytes, Width: t.Width, Height: t.Height, SHA256: t.SHA256}) + } + } + return v +} diff --git a/app/internal/api/http/auth.go b/app/internal/api/http/auth.go new file mode 100644 index 0000000..535a2a5 --- /dev/null +++ b/app/internal/api/http/auth.go @@ -0,0 +1,69 @@ +package http + +import ( + "encoding/base64" + "errors" + "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 { + if c.Request().ContentLength > 0 { + 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 +} diff --git a/app/internal/api/http/chats.go b/app/internal/api/http/chats.go new file mode 100644 index 0000000..7f64886 --- /dev/null +++ b/app/internal/api/http/chats.go @@ -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 +} diff --git a/app/internal/api/http/dto/attachment.go b/app/internal/api/http/dto/attachment.go new file mode 100644 index 0000000..a59e9ed --- /dev/null +++ b/app/internal/api/http/dto/attachment.go @@ -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"` +} diff --git a/app/internal/api/http/dto/chat.go b/app/internal/api/http/dto/chat.go new file mode 100644 index 0000000..7f7bbdd --- /dev/null +++ b/app/internal/api/http/dto/chat.go @@ -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"` +} diff --git a/app/internal/api/http/dto/message.go b/app/internal/api/http/dto/message.go new file mode 100644 index 0000000..bd1c268 --- /dev/null +++ b/app/internal/api/http/dto/message.go @@ -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"` +} diff --git a/app/internal/api/http/dto/timestamp.go b/app/internal/api/http/dto/timestamp.go new file mode 100644 index 0000000..02a5693 --- /dev/null +++ b/app/internal/api/http/dto/timestamp.go @@ -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 +} diff --git a/app/internal/api/http/dto/user.go b/app/internal/api/http/dto/user.go new file mode 100644 index 0000000..65905cf --- /dev/null +++ b/app/internal/api/http/dto/user.go @@ -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"` +} diff --git a/app/internal/api/http/errors.go b/app/internal/api/http/errors.go new file mode 100644 index 0000000..5a4dc8f --- /dev/null +++ b/app/internal/api/http/errors.go @@ -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), + }, + }) +} diff --git a/app/internal/api/http/health.go b/app/internal/api/http/health.go new file mode 100644 index 0000000..ae459ea --- /dev/null +++ b/app/internal/api/http/health.go @@ -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"}) + } +} diff --git a/app/internal/api/http/messages.go b/app/internal/api/http/messages.go new file mode 100644 index 0000000..8012183 --- /dev/null +++ b/app/internal/api/http/messages.go @@ -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} +} diff --git a/app/internal/api/http/middleware/auth.go b/app/internal/api/http/middleware/auth.go new file mode 100644 index 0000000..c21a1ef --- /dev/null +++ b/app/internal/api/http/middleware/auth.go @@ -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) +} diff --git a/app/internal/api/http/middleware/content_type.go b/app/internal/api/http/middleware/content_type.go new file mode 100644 index 0000000..dc6ef03 --- /dev/null +++ b/app/internal/api/http/middleware/content_type.go @@ -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") +} diff --git a/app/internal/api/http/middleware/instance_id.go b/app/internal/api/http/middleware/instance_id.go new file mode 100644 index 0000000..0c6cde4 --- /dev/null +++ b/app/internal/api/http/middleware/instance_id.go @@ -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) + } + } +} diff --git a/app/internal/api/http/middleware/limits.go b/app/internal/api/http/middleware/limits.go new file mode 100644 index 0000000..48ca874 --- /dev/null +++ b/app/internal/api/http/middleware/limits.go @@ -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" +} diff --git a/app/internal/api/http/middleware/logger.go b/app/internal/api/http/middleware/logger.go new file mode 100644 index 0000000..ed94ef1 --- /dev/null +++ b/app/internal/api/http/middleware/logger.go @@ -0,0 +1,48 @@ +package middleware + +import ( + "log/slog" + "time" + + "github.com/labstack/echo/v4" +) + +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) + uid, _ := c.Get(AuthUserIDKey).(string) + + attrs := []slog.Attr{ + slog.String("request_id", rid), + slog.String("method", c.Request().Method), + slog.String("path", c.Request().URL.Path), + slog.Int("status", status), + slog.Int64("duration_ms", time.Since(start).Milliseconds()), + slog.String("remote_ip", c.RealIP()), + } + if uid != "" { + attrs = append(attrs, slog.String("user_id", uid)) + } + + 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 + } + } +} diff --git a/app/internal/api/http/middleware/recover.go b/app/internal/api/http/middleware/recover.go new file mode 100644 index 0000000..862313d --- /dev/null +++ b/app/internal/api/http/middleware/recover.go @@ -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) + } + } +} diff --git a/app/internal/api/http/middleware/request_id.go b/app/internal/api/http/middleware/request_id.go new file mode 100644 index 0000000..6447646 --- /dev/null +++ b/app/internal/api/http/middleware/request_id.go @@ -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) + } + } +} diff --git a/app/internal/api/http/router.go b/app/internal/api/http/router.go new file mode 100644 index 0000000..e41d896 --- /dev/null +++ b/app/internal/api/http/router.go @@ -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) +} diff --git a/app/internal/api/http/server.go b/app/internal/api/http/server.go new file mode 100644 index 0000000..811a319 --- /dev/null +++ b/app/internal/api/http/server.go @@ -0,0 +1,174 @@ +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" +) + +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(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", +} diff --git a/app/internal/api/http/users.go b/app/internal/api/http/users.go new file mode 100644 index 0000000..2533a19 --- /dev/null +++ b/app/internal/api/http/users.go @@ -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" +} diff --git a/app/internal/cache/history.go b/app/internal/cache/history.go new file mode 100644 index 0000000..e389e05 --- /dev/null +++ b/app/internal/cache/history.go @@ -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 +} diff --git a/app/internal/config/attachments.go b/app/internal/config/attachments.go new file mode 100644 index 0000000..6e815c7 --- /dev/null +++ b/app/internal/config/attachments.go @@ -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 +} diff --git a/app/internal/config/config.go b/app/internal/config/config.go new file mode 100644 index 0000000..df07780 --- /dev/null +++ b/app/internal/config/config.go @@ -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 +} diff --git a/app/internal/config/database.go b/app/internal/config/database.go new file mode 100644 index 0000000..05a0086 --- /dev/null +++ b/app/internal/config/database.go @@ -0,0 +1,13 @@ +package config + +type Database struct { + URLFile string + URL string + MaxConns int32 + ConnectTimeoutMs int + QueryTimeoutMs int + // EnableBitmapScan: по умолчанию выключено. Для чата, которого ещё нет в статистике, + // планировщик может ожидать почти пустой результат и выбрать чтение всего чата с сортировкой. + // Это гипотеза: замеров, подтверждающих выигрыш, в evidence нет. Флаг нужен для сравнения. + EnableBitmapScan bool +} diff --git a/app/internal/config/env.go b/app/internal/config/env.go new file mode 100644 index 0000000..21e91c0 --- /dev/null +++ b/app/internal/config/env.go @@ -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 +} diff --git a/app/internal/config/history_cache.go b/app/internal/config/history_cache.go new file mode 100644 index 0000000..e28fb81 --- /dev/null +++ b/app/internal/config/history_cache.go @@ -0,0 +1,11 @@ +package config + +type HistoryCache struct { + Mode string + URLFile string + URL string + PageTTLSeconds int + TimeoutMs int + PoolSize int + FillDelayMs int +} diff --git a/app/internal/config/http.go b/app/internal/config/http.go new file mode 100644 index 0000000..3059c71 --- /dev/null +++ b/app/internal/config/http.go @@ -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 +} diff --git a/app/internal/config/idempotency.go b/app/internal/config/idempotency.go new file mode 100644 index 0000000..32c97cc --- /dev/null +++ b/app/internal/config/idempotency.go @@ -0,0 +1,8 @@ +package config + +// MinIdempotencyTTLSeconds — контракт требует хранить результат не менее 24 часов. +const MinIdempotencyTTLSeconds = 86400 + +type Idempotency struct { + TTLSeconds int +} diff --git a/app/internal/config/limits.go b/app/internal/config/limits.go new file mode 100644 index 0000000..889fab5 --- /dev/null +++ b/app/internal/config/limits.go @@ -0,0 +1,8 @@ +package config + +type Limits struct { + MaxBodyBytes int64 + MaxInFlight int + MaxMessagesGlobal int + MaxHeapBytes uint64 +} diff --git a/app/internal/config/logger.go b/app/internal/config/logger.go new file mode 100644 index 0000000..be8e36b --- /dev/null +++ b/app/internal/config/logger.go @@ -0,0 +1,5 @@ +package config + +type Logger struct { + Level string +} diff --git a/app/internal/config/session.go b/app/internal/config/session.go new file mode 100644 index 0000000..56e0da4 --- /dev/null +++ b/app/internal/config/session.go @@ -0,0 +1,13 @@ +package config + +type Session struct { + Store string + TTLSeconds int +} + +type Cache struct { + URLFile string + URL string + PoolSize int + TimeoutMs int +} diff --git a/app/internal/domain/attachment.go b/app/internal/domain/attachment.go new file mode 100644 index 0000000..5dc1069 --- /dev/null +++ b/app/internal/domain/attachment.go @@ -0,0 +1,39 @@ +package domain + +import "time" + +// StatusReady — единственное состояние вложения в lab4: метаданные появляются только после +// сохранения оригинала. Асинхронные состояния добавляются с lab5. +const StatusReady = "ready" + +const ( + ContentTypePNG = "image/png" + ContentTypeJPEG = "image/jpeg" +) + +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"` +} + +type Attachment struct { + Variants []Variant + Thumbnail Variant + ErrorCode *string + ID string + ChatID string + OwnerID string + Filename string + ContentType string + SizeBytes int64 + SHA256 string + // ObjectKey — внутренний ключ в bucket, назначает сервер. В публичный API не попадает. + ObjectKey string + Status string + CreatedAt time.Time + UpdatedAt time.Time +} diff --git a/app/internal/domain/chat.go b/app/internal/domain/chat.go new file mode 100644 index 0000000..2de7174 --- /dev/null +++ b/app/internal/domain/chat.go @@ -0,0 +1,10 @@ +package domain + +import "time" + +type Chat struct { + ID string + Title string + MemberIDs []string + CreatedAt time.Time +} diff --git a/app/internal/domain/errors.go b/app/internal/domain/errors.go new file mode 100644 index 0000000..02ad86e --- /dev/null +++ b/app/internal/domain/errors.go @@ -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") +) diff --git a/app/internal/domain/message.go b/app/internal/domain/message.go new file mode 100644 index 0000000..036fd12 --- /dev/null +++ b/app/internal/domain/message.go @@ -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 +} diff --git a/app/internal/domain/page.go b/app/internal/domain/page.go new file mode 100644 index 0000000..494a7a4 --- /dev/null +++ b/app/internal/domain/page.go @@ -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 +} diff --git a/app/internal/domain/session.go b/app/internal/domain/session.go new file mode 100644 index 0000000..f62cd52 --- /dev/null +++ b/app/internal/domain/session.go @@ -0,0 +1,9 @@ +package domain + +import "time" + +type Session struct { + Token string + ExpiresAt time.Time + User User +} diff --git a/app/internal/domain/user.go b/app/internal/domain/user.go new file mode 100644 index 0000000..34d5235 --- /dev/null +++ b/app/internal/domain/user.go @@ -0,0 +1,10 @@ +package domain + +import "time" + +type User struct { + ID string + Username string + DisplayName string + CreatedAt time.Time +} diff --git a/app/internal/imagecheck/imagecheck.go b/app/internal/imagecheck/imagecheck.go new file mode 100644 index 0000000..437020a --- /dev/null +++ b/app/internal/imagecheck/imagecheck.go @@ -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 +} diff --git a/app/internal/logging/logging.go b/app/internal/logging/logging.go new file mode 100644 index 0000000..551b53b --- /dev/null +++ b/app/internal/logging/logging.go @@ -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) + } +} diff --git a/app/internal/objectstore/memory.go b/app/internal/objectstore/memory.go new file mode 100644 index 0000000..5a90821 --- /dev/null +++ b/app/internal/objectstore/memory.go @@ -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 +} diff --git a/app/internal/objectstore/objectstore.go b/app/internal/objectstore/objectstore.go new file mode 100644 index 0000000..1432550 --- /dev/null +++ b/app/internal/objectstore/objectstore.go @@ -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 +} diff --git a/app/internal/objectstore/s3.go b/app/internal/objectstore/s3.go new file mode 100644 index 0000000..e03d75d --- /dev/null +++ b/app/internal/objectstore/s3.go @@ -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 +} diff --git a/app/internal/password/password.go b/app/internal/password/password.go new file mode 100644 index 0000000..5959fd3 --- /dev/null +++ b/app/internal/password/password.go @@ -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 +} diff --git a/app/internal/pipeline/pipeline.go b/app/internal/pipeline/pipeline.go new file mode 100644 index 0000000..7537f7f --- /dev/null +++ b/app/internal/pipeline/pipeline.go @@ -0,0 +1,91 @@ +package pipeline + +import ( + "context" + "encoding/json" + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" + "os" + "time" +) + +const Pending = "attachments:pending" +const Active = "attachments:active" + +type Job struct { + SchemaVersion int `json:"schema_version"` + JobID string `json:"job_id"` + Type string `json:"type"` + AttachmentID string `json:"attachment_id"` + PipelineVersion int `json:"pipeline_version"` + Attempt int `json:"attempt"` + CreatedAt time.Time `json:"created_at"` +} + +func Client() *redis.Client { + addr := os.Getenv("BROKER_ADDR") + if addr == "" { + addr = "broker:6379" + } + return redis.NewClient(&redis.Options{Addr: addr}) +} +func Publish(ctx context.Context, id string, attempt int, created time.Time) error { + c := Client() + defer c.Close() + b, err := json.Marshal(Job{1, id, "attachment.process.v1", id, 1, attempt, created.UTC()}) + if err != nil { + return err + } + return c.LPush(ctx, Pending, string(b)).Err() +} + +// Dispatch republishes unfinished intentions. Duplicate messages are expected. +func Dispatch(ctx context.Context, p *pgxpool.Pool) { + for ctx.Err() == nil { + func() { + tx, err := p.Begin(ctx) + if err != nil { + return + } + defer tx.Rollback(ctx) + rows, err := tx.Query(ctx, `SELECT o.attachment_id::text,a.attempts+1,a.created_at FROM attachment_outbox o JOIN attachments a ON a.id=o.attachment_id + WHERE o.next_publish_at<=now() AND ((a.status='queued' AND a.next_attempt_at<=now()) OR (a.status='processing' AND a.lease_until 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: "queued", + } + 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 + } + if os.Getenv("FAULT_AFTER_UPLOAD_COMMIT") == "1" { + os.Exit(86) + } // Только для локальной проверки окна COMMIT/publish. + 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, на диске +// ничего не остаётся и отдельная уборка не нужна. Это не хранилище: 201 вернётся только после S3. +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 = variant + "s/" + att.ID + 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"} +} diff --git a/app/internal/service/auth.go b/app/internal/service/auth.go new file mode 100644 index 0000000..770735e --- /dev/null +++ b/app/internal/service/auth.go @@ -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) +} diff --git a/app/internal/service/chats.go b/app/internal/service/chats.go new file mode 100644 index 0000000..b3db00c --- /dev/null +++ b/app/internal/service/chats.go @@ -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) +} diff --git a/app/internal/service/messages.go b/app/internal/service/messages.go new file mode 100644 index 0000000..3d4c5bd --- /dev/null +++ b/app/internal/service/messages.go @@ -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) +} diff --git a/app/internal/service/service.go b/app/internal/service/service.go new file mode 100644 index 0000000..cc65ada --- /dev/null +++ b/app/internal/service/service.go @@ -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 +} diff --git a/app/internal/service/users.go b/app/internal/service/users.go new file mode 100644 index 0000000..297938c --- /dev/null +++ b/app/internal/service/users.go @@ -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) +} diff --git a/app/internal/session/memory.go b/app/internal/session/memory.go new file mode 100644 index 0000000..b6896df --- /dev/null +++ b/app/internal/session/memory.go @@ -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 } diff --git a/app/internal/session/session.go b/app/internal/session/session.go new file mode 100644 index 0000000..7e3047c --- /dev/null +++ b/app/internal/session/session.go @@ -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 +} diff --git a/app/internal/session/valkey.go b/app/internal/session/valkey.go new file mode 100644 index 0000000..9deddbd --- /dev/null +++ b/app/internal/session/valkey.go @@ -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) +} diff --git a/app/internal/store/db/attachments.go b/app/internal/store/db/attachments.go new file mode 100644 index 0000000..c7b0ac8 --- /dev/null +++ b/app/internal/store/db/attachments.go @@ -0,0 +1,127 @@ +package db + +import ( + "context" + "fmt" + "os" + "strconv" + + "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() + + tx, err := a.pool.Begin(ctx) + if err != nil { + return domain.Attachment{}, mapErr(err) + } + defer tx.Rollback(ctx) + // Serialize admission across API replicas. Only unfinished jobs consume capacity. + limit := 64 + if value := os.Getenv("JOB_MAX_INFLIGHT"); value != "" { + n, e := strconv.Atoi(value) + if e != nil || n < 1 { + return domain.Attachment{}, fmt.Errorf("invalid JOB_MAX_INFLIGHT") + } + limit = n + } + if _, err = tx.Exec(ctx, `SELECT pg_advisory_xact_lock(505002)`); err != nil { + return domain.Attachment{}, mapErr(err) + } + var outstanding int + if err = tx.QueryRow(ctx, `SELECT count(*) FROM attachments WHERE status IN ('queued','processing')`).Scan(&outstanding); err != nil { + return domain.Attachment{}, mapErr(err) + } + if outstanding >= limit { + return domain.Attachment{}, domain.ErrRateLimited + } + 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.Exec(ctx, `INSERT INTO attachment_outbox(attachment_id) VALUES ($1)`, att.ID); 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 + 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.thumbnail, a.error_code, a.variants + 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, &att.Thumbnail, &att.ErrorCode, &att.Variants) + if err != nil { + return domain.Attachment{}, mapErr(err) + } + att.CreatedAt = att.CreatedAt.UTC() + att.UpdatedAt = att.UpdatedAt.UTC() + 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 +} diff --git a/app/internal/store/db/chats.go b/app/internal/store/db/chats.go new file mode 100644 index 0000000..104ef5f --- /dev/null +++ b/app/internal/store/db/chats.go @@ -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 +} diff --git a/app/internal/store/db/db.go b/app/internal/store/db/db.go new file mode 100644 index 0000000..b0660de --- /dev/null +++ b/app/internal/store/db/db.go @@ -0,0 +1,136 @@ +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" +) + +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") + } + 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) + } + 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 +} diff --git a/app/internal/store/db/invalidations.go b/app/internal/store/db/invalidations.go new file mode 100644 index 0000000..3bcaf7f --- /dev/null +++ b/app/internal/store/db/invalidations.go @@ -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) +} diff --git a/app/internal/store/db/messages.go b/app/internal/store/db/messages.go new file mode 100644 index 0000000..ea34247 --- /dev/null +++ b/app/internal/store/db/messages.go @@ -0,0 +1,235 @@ +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 { + rows, e := tx.Query(ctx, `SELECT id::text, status FROM attachments WHERE chat_id=$1 AND id=ANY($2::uuid[]) FOR SHARE`, chatID, attachmentIDs) + if e != nil { + return domain.Message{}, mapErr(e) + } + count := 0 + failed := false + for rows.Next() { + var id, status string + if e = rows.Scan(&id, &status); e != nil { + rows.Close() + return domain.Message{}, mapErr(e) + } + count++ + failed = failed || status == "failed" + } + e = rows.Err() + rows.Close() + if e != nil { + return domain.Message{}, mapErr(e) + } + if count != len(attachmentIDs) { + return domain.Message{}, domain.ErrNotFound + } + 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 +} diff --git a/app/internal/store/db/text.go b/app/internal/store/db/text.go new file mode 100644 index 0000000..4c9e30f --- /dev/null +++ b/app/internal/store/db/text.go @@ -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) +} diff --git a/app/internal/store/db/users.go b/app/internal/store/db/users.go new file mode 100644 index 0000000..3ab1beb --- /dev/null +++ b/app/internal/store/db/users.go @@ -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 +} diff --git a/app/internal/store/memory.go b/app/internal/store/memory.go new file mode 100644 index 0000000..9249118 --- /dev/null +++ b/app/internal/store/memory.go @@ -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 +} diff --git a/app/internal/store/store.go b/app/internal/store/store.go new file mode 100644 index 0000000..727f949 --- /dev/null +++ b/app/internal/store/store.go @@ -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 +} diff --git a/app/internal/token/token.go b/app/internal/token/token.go new file mode 100644 index 0000000..877c8db --- /dev/null +++ b/app/internal/token/token.go @@ -0,0 +1,42 @@ +package token + +import ( + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "errors" + "fmt" +) + +const Bytes = 32 + +var encoding = base64.RawURLEncoding + +var EncodedLen = encoding.EncodedLen(Bytes) + +var ErrMalformed = errors.New("token: malformed") + +func New() (plain string, hash []byte, err error) { + buf := make([]byte, Bytes) + if _, err := rand.Read(buf); err != nil { + return "", nil, fmt.Errorf("token: rand: %w", err) + } + plain = encoding.EncodeToString(buf) + return plain, Hash(plain), nil +} + +func Hash(plain string) []byte { + sum := sha256.Sum256([]byte(plain)) + return sum[:] +} + +func Parse(plain string) ([]byte, error) { + if len(plain) != EncodedLen { + return nil, ErrMalformed + } + raw, err := encoding.DecodeString(plain) + if err != nil || len(raw) != Bytes { + return nil, ErrMalformed + } + return Hash(plain), nil +} diff --git a/app/internal/validate/attachment.go b/app/internal/validate/attachment.go new file mode 100644 index 0000000..05e880f --- /dev/null +++ b/app/internal/validate/attachment.go @@ -0,0 +1,70 @@ +package validate + +import ( + "fmt" + "strings" + "unicode" + "unicode/utf8" +) + +const ( + FilenameMinLen = 1 + FilenameMaxLen = 255 + + AttachmentIDsMax = 10 +) + +// Filename проверяет отображаемое имя. Оно нигде не используется как путь, но попадает в заголовки +// и к другим клиентам, поэтому разделители и невидимые управляющие символы запрещены. +func Filename(s string) error { + if !utf8.ValidString(s) { + return newError("filename", "must be valid UTF-8") + } + if !notOnlyWhitespace(s) { + return newError("filename", "must not be empty or whitespace only") + } + if !codePointsBetween(s, FilenameMinLen, FilenameMaxLen) { + return newError("filename", fmt.Sprintf("length must be in [%d, %d] code points", FilenameMinLen, FilenameMaxLen)) + } + if s == "." || s == ".." { + return newError("filename", "must not be a path component") + } + if strings.ContainsFunc(s, unsafeFilenameRune) { + return newError("filename", "must not contain path separators or control characters") + } + return nil +} + +func unsafeFilenameRune(r rune) bool { + switch { + case r == '/', r == '\\', unicode.IsControl(r): + return true + case r == '
', r == '
': + return true + case r >= '‪' && r <= '‮', r >= '⁦' && r <= '⁩': + // Символы смены направления текста позволяют выдать evil.exe за безобидное имя. + return true + } + return false +} + +// AttachmentIDs приводит ID к каноничному виду с сохранением порядка. +func AttachmentIDs(ids []string) ([]string, error) { + if len(ids) > AttachmentIDsMax { + return nil, newError("attachment_ids", fmt.Sprintf("count must be at most %d", AttachmentIDsMax)) + } + out := make([]string, 0, len(ids)) + seen := make(map[string]struct{}, len(ids)) + for i, raw := range ids { + id, err := CanonicalUUID(fmt.Sprintf("attachment_ids[%d]", i), raw) + if err != nil { + return nil, err + } + if _, dup := seen[id]; dup { + return nil, newError("attachment_ids", "must not contain duplicates") + } + seen[id] = struct{}{} + out = append(out, id) + } + return out, nil +} diff --git a/app/internal/validate/chat.go b/app/internal/validate/chat.go new file mode 100644 index 0000000..62bf3f6 --- /dev/null +++ b/app/internal/validate/chat.go @@ -0,0 +1,42 @@ +package validate + +import "fmt" + +func ChatTitle(s string) error { + if !notOnlyWhitespace(s) { + return newError("title", "must not be empty or whitespace only") + } + if !codePointsBetween(s, ChatTitleMinLen, ChatTitleMaxLen) { + return newError("title", fmt.Sprintf("length must be in [%d, %d] code points", ChatTitleMinLen, ChatTitleMaxLen)) + } + return nil +} + +func MemberIDs(ids []string, callerID string) ([]string, error) { + if len(ids) < MemberIDsMin || len(ids) > MemberIDsMax { + return nil, newError("member_ids", fmt.Sprintf("count must be in [%d, %d]", MemberIDsMin, MemberIDsMax)) + } + + out := make([]string, 0, len(ids)) + seen := make(map[string]struct{}, len(ids)) + callerIn := false + for i, raw := range ids { + id, err := CanonicalUUID(fmt.Sprintf("member_ids[%d]", i), raw) + if err != nil { + return nil, err + } + if _, dup := seen[id]; dup { + return nil, newError("member_ids", "must not contain duplicates") + } + seen[id] = struct{}{} + if id == callerID { + callerIn = true + } + out = append(out, id) + } + + if !callerIn { + return nil, newError("member_ids", "must contain caller") + } + return out, nil +} diff --git a/app/internal/validate/idempotency.go b/app/internal/validate/idempotency.go new file mode 100644 index 0000000..68411a1 --- /dev/null +++ b/app/internal/validate/idempotency.go @@ -0,0 +1,12 @@ +package validate + +import "regexp" + +var idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + +func IdempotencyKey(s string) error { + if !idempotencyKeyPattern.MatchString(s) { + return newError("Idempotency-Key", "must match [A-Za-z0-9._:-]{1,128}") + } + return nil +} diff --git a/app/internal/validate/message.go b/app/internal/validate/message.go new file mode 100644 index 0000000..2ec37d9 --- /dev/null +++ b/app/internal/validate/message.go @@ -0,0 +1,14 @@ +package validate + +import "fmt" + +// MessageText: пустой или пробельный текст допустим, только если у сообщения есть вложения. +func MessageText(s string, hasAttachments bool) error { + if !hasAttachments && !notOnlyWhitespace(s) { + return newError("text", "must not be empty or whitespace only") + } + if !codePointsBetween(s, 0, MessageTextMaxLen) { + return newError("text", fmt.Sprintf("length must be at most %d code points", MessageTextMaxLen)) + } + return nil +} diff --git a/app/internal/validate/rules.go b/app/internal/validate/rules.go new file mode 100644 index 0000000..05792a9 --- /dev/null +++ b/app/internal/validate/rules.go @@ -0,0 +1,80 @@ +package validate + +import ( + "fmt" + "regexp" + "strings" + "unicode/utf8" + + "github.com/google/uuid" +) + +const ( + UsernameMinLen = 3 + UsernameMaxLen = 32 + + DisplayNameMinLen = 1 + DisplayNameMaxLen = 100 + + PasswordMinLen = 12 + PasswordMaxLen = 128 + + ChatTitleMinLen = 1 + ChatTitleMaxLen = 100 + + MessageTextMaxLen = 4000 + + MemberIDsMin = 1 + MemberIDsMax = 100 + + LimitMin = 1 + LimitMax = 100 + LimitDefault = 50 +) + +var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +func CanonicalUUID(field, s string) (string, error) { + if len(s) != 36 { + return "", newError(field, "must be a valid UUID") + } + u, err := uuid.Parse(s) + if err != nil { + return "", newError(field, "must be a valid UUID") + } + return u.String(), nil +} + +func Limit(n int) error { + if n < LimitMin || n > LimitMax { + return newError("limit", fmt.Sprintf("must be in [%d, %d]", LimitMin, LimitMax)) + } + return nil +} + +func codePointsBetween(s string, min, max int) bool { + n := utf8.RuneCountInString(s) + return n >= min && n <= max +} + +func notOnlyWhitespace(s string) bool { + return strings.TrimSpace(s) != "" +} + +type Error struct { + Field string + Reason string +} + +func (e *Error) Error() string { + return e.Field + ": " + e.Reason +} + +func (e *Error) Is(target error) bool { + _, ok := target.(*Error) + return ok +} + +func newError(field, reason string) *Error { + return &Error{Field: field, Reason: reason} +} diff --git a/app/internal/validate/user.go b/app/internal/validate/user.go new file mode 100644 index 0000000..cf97468 --- /dev/null +++ b/app/internal/validate/user.go @@ -0,0 +1,30 @@ +package validate + +import "fmt" + +func Username(s string) error { + if !usernamePattern.MatchString(s) { + return newError("username", fmt.Sprintf("must match [a-z0-9_]{%d,%d}", UsernameMinLen, UsernameMaxLen)) + } + return nil +} + +func DisplayName(s string) error { + if !notOnlyWhitespace(s) { + return newError("display_name", "must not be empty or whitespace only") + } + if !codePointsBetween(s, DisplayNameMinLen, DisplayNameMaxLen) { + return newError("display_name", fmt.Sprintf("length must be in [%d, %d] code points", DisplayNameMinLen, DisplayNameMaxLen)) + } + return nil +} + +func Password(s string) error { + if !notOnlyWhitespace(s) { + return newError("password", "must not be empty or whitespace only") + } + if !codePointsBetween(s, PasswordMinLen, PasswordMaxLen) { + return newError("password", fmt.Sprintf("length must be in [%d, %d] code points", PasswordMinLen, PasswordMaxLen)) + } + return nil +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..62fa2f6 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,363 @@ +# Весь стенд лабораторной: LB, реплики API, PostgreSQL, Valkey, S3 (SeaweedFS) и одноразовая подготовка. +# Запуск: docker compose --env-file .env up -d --wait Перед первым запуском: sh scripts/init-secrets.sh +# Остановка с сохранением данных: docker compose --env-file .env down С удалением данных: добавить -v +# Значения вида ${X:-8080} можно менять через окружение или .env. + +name: mtusi-lab5 + +# Секреты лежат в файлах вне Git и видны контейнеру в /run/secrets только там, где подключены. +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + valkey_password: + file: ./secrets/valkey_password + cache_url: + file: ./secrets/cache_url + valkey_cache_password: + file: ./secrets/valkey_cache_password + history_cache_url: + file: ./secrets/history_cache_url + s3_access_key_id: + file: ./secrets/s3_access_key_id + s3_secret_access_key: + file: ./secrets/s3_secret_access_key + s3_admin_access_key_id: + file: ./secrets/s3_admin_access_key_id + s3_admin_secret_access_key: + file: ./secrets/s3_admin_secret_access_key + s3_janitor_access_key_id: + file: ./secrets/s3_janitor_access_key_id + s3_janitor_secret_access_key: + file: ./secrets/s3_janitor_secret_access_key + s3_config: + file: ./secrets/s3_config + +services: + broker: + image: valkey/valkey:8.1.3-alpine + command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "always", "--maxmemory-policy", "noeviction"] + volumes: + - brokerdata:/data + restart: unless-stopped + + worker: + build: + context: . + target: worker + env_file: .env + environment: + BROKER_ADDR: broker:6379 + JOB_MAX_ATTEMPTS: ${JOB_MAX_ATTEMPTS:-5} + WORKER_CONCURRENCY: ${WORKER_CONCURRENCY:-1} + WORKER_PREFETCH: ${WORKER_PREFETCH:-1} + GOMEMLIMIT: 512MiB + FAULT_AFTER_OBJECTS: ${FAULT_AFTER_OBJECTS:-0} + FAULT_BEFORE_ACK: ${FAULT_BEFORE_ACK:-0} + secrets: + - database_url + - s3_access_key_id + - s3_secret_access_key + depends_on: + migrate: + condition: service_completed_successfully + s3-init: + condition: service_completed_successfully + broker: + condition: service_started + deploy: + resources: + limits: + cpus: "2.0" + memory: 1G + restart: unless-stopped + + # Основная БД и источник истины. Общая для всех реплик; реплицирования нет, поэтому это единая точка отказа. + postgres: + image: postgres:17.6-alpine + deploy: + resources: + limits: + cpus: "2.0" + memory: 1G + # pg_stat_statements собирает статистику запросов для диагностики. + command: + - postgres + - -c + - shared_preload_libraries=pg_stat_statements + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + # Именованный том: данные переживают пересоздание контейнера и удаляются только через down -v. + volumes: + - pgdata:/var/lib/postgresql/data + # Только 127.0.0.1: для диагностики с этого хоста. Из сети порт недоступен. + ports: + - "127.0.0.1:${POSTGRES_PORT:-5432}:5432" + # Готовность БД: от неё зависят migrate и API. + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + start_period: 10s + # Docker поднимет контейнер после сбоя, но не после ручной остановки: тесты отказа это используют. + restart: unless-stopped + + # Общее хранилище сессий: поэтому токен принимает любая реплика API. + valkey: + image: valkey/valkey:8.1.3-alpine + deploy: + resources: + limits: + cpus: "1.0" + memory: 256M + # Файл журнала с записью на диск раз в секунду: сессии переживают перезапуск, при аварии + # возможна потеря последней секунды. noeviction: при нехватке памяти сессии не вытесняются молча. + # $$ передаёт $ в контейнер: пароль читается из секрета при запуске, а не хранится в файле. + command: + - /bin/sh + - -c + - >- + exec valkey-server + --appendonly yes + --appendfsync everysec + --maxmemory 128mb + --maxmemory-policy noeviction + --requirepass "$$(cat /run/secrets/valkey_password)" + secrets: + - valkey_password + volumes: + - valkeydata:/data + # Только 127.0.0.1: для диагностики с этого хоста. + ports: + - "127.0.0.1:${VALKEY_PORT:-6379}:6379" + healthcheck: + test: + - CMD-SHELL + - 'valkey-cli -a "$$(cat /run/secrets/valkey_password)" ping 2>/dev/null | grep -q PONG' + interval: 5s + timeout: 3s + retries: 10 + start_period: 5s + restart: unless-stopped + + # Приватное хранилище байтов вложений. Порты на хост не публикуются. Находится только во внутренней + # сети s3-private: остальные сервисы видят его через s3-gateway и только порт S3. + # -ip.bind=127.0.0.1 важен для приватности: master, volume и filer отдают файлы БЕЗ проверки подписи + # S3, поэтому они доступны только внутри этого контейнера. Из сети стенда виден только шлюз S3 на 9000. + # -volume.preStopSeconds=0: иначе процесс ждёт 10 с при остановке и не успевает до SIGKILL. + s3: + image: chrislusf/seaweedfs:4.00 + deploy: + resources: + limits: + cpus: "1.0" + memory: 1G + entrypoint: ["weed"] + command: + - server + - -dir=/data + - -ip=127.0.0.1 + - -ip.bind=127.0.0.1 + - -master.volumeSizeLimitMB=1024 + - -volume.max=${S3_MAX_VOLUMES:-64} + - -volume.preStopSeconds=0 + - -filer + - -s3 + - -s3.ip.bind=0.0.0.0 + - -s3.port=9000 + - -s3.config=/run/secrets/s3_config + networks: + s3-private: + aliases: + - s3-storage + secrets: + - s3_config + volumes: + - s3data:/data + - ./infra/seaweedfs/master.toml:/etc/seaweedfs/master.toml:ro + # healthz отвечает только шлюз; готовность записи подтверждает s3-init. + healthcheck: + test: ["CMD", "wget", "--quiet", "--spider", "http://127.0.0.1:9000/healthz"] + interval: 3s + timeout: 3s + retries: 20 + start_period: 30s + restart: unless-stopped + + # Шлюз к S3: в общей сети отвечает на имя s3 и пропускает только порт 9000. Служебные порты + # SeaweedFS (в том числе gRPC шлюза 19000, открытый на всех интерфейсах) из общей сети недоступны. + s3-gateway: + ports: + - "127.0.0.1:19090:9000" + image: haproxy:3.2.9-alpine + deploy: + resources: + limits: + cpus: "0.5" + memory: 64M + volumes: + - ./infra/s3-gateway/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + networks: + default: + aliases: + - s3 + s3-private: + healthcheck: + test: ["CMD", "wget", "--quiet", "--spider", "http://127.0.0.1:8405/health"] + interval: 3s + timeout: 3s + retries: 10 + start_period: 3s + restart: unless-stopped + + # Одноразовая подготовка S3: создаёт bucket и проверяет, что анонимный доступ запрещён. + # Повторный запуск ничего не меняет и не трогает объекты. Единственный сервис с ключом администратора. + s3-init: + build: + context: . + target: s3init + deploy: + resources: + limits: + cpus: "0.5" + memory: 128M + environment: + S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000} + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_admin_access_key_id + S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_admin_secret_access_key + secrets: + - s3_admin_access_key_id + - s3_admin_secret_access_key + depends_on: + s3: + condition: service_healthy + s3-gateway: + condition: service_healthy + restart: "no" + + # Одноразовый запуск миграций: выполняется один раз до API и завершается. + migrate: + build: + context: . + target: migrate + deploy: + resources: + limits: + cpus: "0.5" + memory: 128M + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: + - database_url + # Миграции начинаются только после готовности БД. + depends_on: + postgres: + condition: service_healthy + # Завершение — штатный итог, перезапускать его не нужно. + restart: "no" + + # Реплики API. Нет container_name и опубликованных портов: сервис масштабируется, а весь трафик + # идёт через LB. Своего состояния у реплик нет. + api: + # target не указан: собирается последний этап Dockerfile. APP_BUILD — метка версии для rolling update. + build: + context: . + args: + APP_BUILD: ${APP_BUILD:-dev} + env_file: .env + deploy: + # Лимиты указаны на одну реплику: при N репликах суммарно N × лимит. + replicas: ${API_REPLICAS:-2} + resources: + limits: + cpus: "1.0" + # Запас под полное декодирование изображения 40 Мп и дисковый кэш временных файлов; замер в REPORT.md. + memory: 1G + # Больше, чем APP_SHUTDOWN_DRAIN_MS + APP_SHUTDOWN_TIMEOUT_MS (3 с + 10 с), иначе Docker пришлёт SIGKILL. + stop_grace_period: 15s + environment: + JOB_MAX_INFLIGHT: ${JOB_MAX_INFLIGHT:-64} + FAULT_AFTER_UPLOAD_COMMIT: ${FAULT_AFTER_UPLOAD_COMMIT:-0} + S3_PUBLIC_ENDPOINT: ${S3_PUBLIC_ENDPOINT:-http://127.0.0.1:19090} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + HISTORY_CACHE: ${HISTORY_CACHE:-off} + HISTORY_CACHE_TTL_SECONDS: ${HISTORY_CACHE_TTL_SECONDS:-30} + HISTORY_CACHE_FILL_DELAY_MS: ${HISTORY_CACHE_FILL_DELAY_MS:-0} + # Подключений к БД на одну реплику: 8 реплик × 10 меньше max_connections (100). + DB_MAX_CONNS: ${DB_MAX_CONNS:-10} + # Выключает bitmap scan в БД. Обоснование в app/internal/config/database.go; замеров, + # подтверждающих это, сейчас в evidence нет. + DB_ENABLE_BITMAPSCAN: ${DB_ENABLE_BITMAPSCAN:-false} + # Цепочка согласована с infra/haproxy/haproxy.cfg, расчёт в REPORT.md. + # Мягкий предел для сборщика мусора и порог защиты от перегрузки: оба ниже лимита контейнера. + GOMEMLIMIT: 800MiB + APP_MAX_HEAP_BYTES: 805306368 + APP_READ_TIMEOUT_MS: 10000 # = timeout http-request LB + APP_WRITE_TIMEOUT_MS: 10000 # < timeout server LB (15 с): 504 от LB не опережает ответ API + APP_IDLE_TIMEOUT_MS: 60000 # > keep-alive LB (30 с): API не закрывает соединение первым + APP_SHUTDOWN_DRAIN_MS: 3000 # > вывода по readiness (2 проверки * 1 с) + APP_SHUTDOWN_TIMEOUT_MS: 10000 # = APP_WRITE_TIMEOUT_MS: запрос успевает завершиться + secrets: + - database_url + - cache_url + - s3_access_key_id + - s3_secret_access_key + # Старт только после готовности хранилищ и успешных миграций. depends_on задаёт лишь порядок + # запуска: выводить упавшую реплику из работы должен LB. + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + migrate: + condition: service_completed_successfully + s3-init: + condition: service_completed_successfully + restart: unless-stopped + + # Балансировщик: единственная публичная точка входа. Настройки в infra/haproxy/haproxy.cfg. + lb: + image: haproxy:3.2.9-alpine + deploy: + resources: + limits: + cpus: "1.0" + memory: 256M + # Конфигурация только для чтения. + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + # Без адреса: порт открыт на всех интерфейсах хоста, в том числе в локальной сети. + ports: + - "${API_PUBLISH_PORT:-8080}:8080" + # Ждать готовности реплик не нужно: LB сам проверяет их и не шлёт трафик на неготовые. + depends_on: + api: + condition: service_started + # Проверяет сам LB, а не реплики: порт 8404 доступен только внутри контейнера. + healthcheck: + test: ["CMD", "wget", "--quiet", "--spider", "http://127.0.0.1:8404/health"] + interval: 5s + timeout: 3s + retries: 5 + start_period: 5s + restart: unless-stopped + +# internal: у этой сети нет выхода наружу. В ней только SeaweedFS и его шлюз. +networks: + s3-private: + internal: true + +# Именованные тома только у хранилищ. Реплики API томов не используют. +volumes: + brokerdata: + pgdata: + valkeydata: + s3data: diff --git a/evidence/README.md b/evidence/README.md deleted file mode 100644 index 8df7001..0000000 --- a/evidence/README.md +++ /dev/null @@ -1,5 +0,0 @@ -# Доказательства - -Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. - -Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. diff --git a/evidence/build.txt b/evidence/build.txt new file mode 100644 index 0000000..0ffc18a --- /dev/null +++ b/evidence/build.txt @@ -0,0 +1,263 @@ + Image lab5-audit-api Building + Image lab5-audit-s3-init Building + Image lab5-audit-migrate Building + Image lab5-audit-worker Building +#1 [internal] load local bake definitions +#1 reading from stdin 2.07kB done +#1 DONE 0.0s + +#2 [migrate internal] load build definition from Dockerfile +#2 transferring dockerfile: 5.40kB done +#2 DONE 0.0s + +#3 [migrate] resolve image config for docker-image://docker.io/docker/dockerfile:1.7 +#3 DONE 1.5s + +#4 [api] docker-image://docker.io/docker/dockerfile:1.7@sha256:a57df69d0ea827fb7266491f2813635de6f17269be881f696fbfdf2d83dda33e +#4 CACHED + +#5 [s3-init internal] load build definition from Dockerfile +#5 transferring dockerfile: 5.40kB done +#5 DONE 0.0s + +#6 [worker internal] load build definition from Dockerfile +#6 transferring dockerfile: 5.40kB done +#6 DONE 0.0s + +#7 [api internal] load build definition from Dockerfile +#7 transferring dockerfile: 5.40kB done +#7 DONE 0.0s + +#8 [migrate internal] load build definition from Dockerfile +#8 transferring dockerfile: 5.40kB done +#8 DONE 0.0s + +#9 [migrate internal] load metadata for docker.io/library/golang:1.26.10-alpine3.24 +#9 DONE 0.8s + +#10 [worker internal] load metadata for docker.io/library/alpine:3.24.3 +#10 DONE 0.9s + +#11 [s3-init internal] load .dockerignore +#11 transferring context: 210B done +#11 DONE 0.0s + +#12 [api internal] load .dockerignore +#12 transferring context: 210B done +#12 DONE 0.0s + +#13 [worker internal] load .dockerignore +#13 transferring context: 210B done +#13 DONE 0.0s + +#14 [migrate internal] load .dockerignore +#14 transferring context: 210B done +#14 DONE 0.0s + +#15 [migrate builder 1/8] FROM docker.io/library/golang:1.26.10-alpine3.24@sha256:87c65a688975c0b1d4585d204874c45ca78354670e3a5f11368c5a492303d696 +#15 DONE 0.0s + +#16 [migrate worker 1/3] FROM docker.io/library/alpine:3.24.3@sha256:be2656061b536c1883c4034790e21d0a09c5aaaf51968b89368a3c0371ea2c9a +#16 DONE 0.0s + +#17 [worker internal] load build context +#17 transferring context: 5.08kB done +#17 DONE 0.0s + +#18 [s3-init internal] load build context +#18 transferring context: 5.08kB done +#18 DONE 0.0s + +#19 [api internal] load build context +#19 transferring context: 206.78kB 0.0s done +#19 DONE 0.0s + +#20 [migrate internal] load build context +#20 transferring context: 15.36kB done +#20 DONE 0.0s + +#21 [worker worker 2/3] RUN apk add --no-cache ca-certificates libwebp-tools +#21 CACHED + +#22 [worker builder 6/8] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/messenger ./cmd/messenger +#22 CACHED + +#23 [worker builder 8/8] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -o /out/worker ./cmd/worker +#23 CACHED + +#24 [worker builder 7/8] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/s3init ./cmd/s3init +#24 CACHED + +#25 [worker builder 3/8] COPY app/go.mod app/go.sum ./ +#25 CACHED + +#26 [worker builder 5/8] COPY app/ ./ +#26 CACHED + +#27 [worker builder 4/8] RUN go mod download +#27 CACHED + +#28 [worker worker 3/3] COPY --from=builder /out/worker /usr/local/bin/worker +#28 CACHED + +#29 [migrate migrate 2/3] COPY --from=goose-builder /go/bin/goose /usr/local/bin/goose +#29 CACHED + +#30 [migrate goose-builder 2/2] 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 +#30 CACHED + +#31 [migrate migrate 3/3] COPY migrations /migrations +#31 CACHED + +#32 [s3-init builder 8/8] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -o /out/worker ./cmd/worker +#32 CACHED + +#33 [s3-init builder 5/8] COPY app/ ./ +#33 CACHED + +#34 [s3-init builder 7/8] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/s3init ./cmd/s3init +#34 CACHED + +#35 [s3-init builder 3/8] COPY app/go.mod app/go.sum ./ +#35 CACHED + +#36 [s3-init builder 6/8] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/messenger ./cmd/messenger +#36 CACHED + +#37 [s3-init builder 4/8] RUN go mod download +#37 CACHED + +#38 [s3-init s3init 2/2] COPY --from=builder /out/s3init /usr/local/bin/s3init +#38 CACHED + +#39 [api builder 8/8] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -o /out/worker ./cmd/worker +#39 CACHED + +#40 [api builder 2/8] WORKDIR /src +#40 CACHED + +#41 [api builder 6/8] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/messenger ./cmd/messenger +#41 CACHED + +#42 [api builder 5/8] COPY app/ ./ +#42 CACHED + +#43 [api stage-6 3/4] WORKDIR /app +#43 CACHED + +#44 [api builder 4/8] RUN go mod download +#44 CACHED + +#45 [api builder 7/8] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/s3init ./cmd/s3init +#45 CACHED + +#46 [api stage-6 2/4] RUN apk add --no-cache ca-certificates && addgroup -S app && adduser -S -G app -H app +#46 CACHED + +#47 [api builder 3/8] COPY app/go.mod app/go.sum ./ +#47 CACHED + +#48 [api stage-6 4/4] COPY --from=builder /out/messenger /app/messenger +#48 CACHED + +#49 [worker] exporting to image +#49 exporting layers done +#49 writing image sha256:aed260f2cecf3ca2f1de52b91a14cc1992760730573d938a57e1a59022fc63f3 done +#49 naming to docker.io/library/lab5-audit-worker done +#49 DONE 0.0s + +#50 [migrate] exporting to image +#50 exporting layers done +#50 writing image sha256:69dc79f5f2cb7f1c467058eaf74aa6583867eb87ab973d4b86320e219545b073 done +#50 naming to docker.io/library/lab5-audit-migrate done +#50 DONE 0.0s + +#51 [s3-init] exporting to image +#51 exporting layers done +#51 writing image sha256:f3eb20bfdff75ffe153b5274962f38a9602bfd2e5a2a3ce3457ff7f95b886a6b done +#51 naming to docker.io/library/lab5-audit-s3-init done +#51 DONE 0.0s + +#52 [api] exporting to image +#52 exporting layers done +#52 writing image sha256:95da3517484aabb8f82598d2c078ea2d1e1bad49511daf941fac61fc5e7e915e 0.0s done +#52 naming to docker.io/library/lab5-audit-api done +#52 DONE 0.0s + +#53 [migrate] resolving provenance for metadata file +#53 DONE 0.0s + +#54 [worker] resolving provenance for metadata file +#54 DONE 0.0s + +#55 [api] resolving provenance for metadata file +#55 DONE 0.0s + +#56 [s3-init] resolving provenance for metadata file +#56 DONE 0.0s + Image lab5-audit-worker Built + Image lab5-audit-s3-init Built + Image lab5-audit-migrate Built + Image lab5-audit-api Built + Container lab5-audit-s3-1 Starting + Container lab5-audit-postgres-1 Starting + Container lab5-audit-valkey-1 Starting + Container lab5-audit-broker-1 Starting + Container lab5-audit-s3-gateway-1 Starting + Container lab5-audit-broker-1 Started + Container lab5-audit-s3-1 Started + Container lab5-audit-postgres-1 Started + Container lab5-audit-postgres-1 Waiting + Container lab5-audit-valkey-1 Started + Container lab5-audit-s3-gateway-1 Started + Container lab5-audit-s3-1 Waiting + Container lab5-audit-s3-gateway-1 Waiting + Container lab5-audit-postgres-1 Healthy + Container lab5-audit-migrate-1 Starting + Container lab5-audit-s3-gateway-1 Healthy + Container lab5-audit-migrate-1 Started + Container lab5-audit-s3-1 Healthy + Container lab5-audit-s3-init-1 Starting + Container lab5-audit-s3-init-1 Started + Container lab5-audit-s3-init-1 Waiting + Container lab5-audit-migrate-1 Waiting + Container lab5-audit-valkey-1 Waiting + Container lab5-audit-migrate-1 Waiting + Container lab5-audit-s3-init-1 Waiting + Container lab5-audit-postgres-1 Waiting + Container lab5-audit-s3-init-1 Exited + Container lab5-audit-migrate-1 Exited + Container lab5-audit-s3-init-1 Exited + Container lab5-audit-valkey-1 Healthy + Container lab5-audit-postgres-1 Healthy + Container lab5-audit-api-1 Starting + Container lab5-audit-migrate-1 Exited + Container lab5-audit-worker-1 Starting + Container lab5-audit-api-1 Started + Container lab5-audit-api-2 Starting + Container lab5-audit-worker-1 Started + Container lab5-audit-api-2 Started + Container lab5-audit-lb-1 Starting + Container lab5-audit-lb-1 Started + Container lab5-audit-lb-1 Waiting + Container lab5-audit-api-1 Waiting + Container lab5-audit-api-2 Waiting + Container lab5-audit-worker-1 Waiting + Container lab5-audit-postgres-1 Waiting + Container lab5-audit-migrate-1 Waiting + Container lab5-audit-s3-gateway-1 Waiting + Container lab5-audit-s3-init-1 Waiting + Container lab5-audit-broker-1 Waiting + Container lab5-audit-valkey-1 Waiting + Container lab5-audit-s3-1 Waiting + Container lab5-audit-broker-1 Healthy + Container lab5-audit-s3-init-1 Exited + Container lab5-audit-migrate-1 Exited + Container lab5-audit-valkey-1 Healthy + Container lab5-audit-s3-gateway-1 Healthy + Container lab5-audit-worker-1 Healthy + Container lab5-audit-postgres-1 Healthy + Container lab5-audit-s3-1 Healthy + Container lab5-audit-api-1 Healthy + Container lab5-audit-api-2 Healthy + Container lab5-audit-lb-1 Healthy diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 0000000..9a55330 --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,2 @@ +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/environment.json b/evidence/environment.json new file mode 100644 index 0000000..f90ea4d --- /dev/null +++ b/evidence/environment.json @@ -0,0 +1,12 @@ +{ + "checked_at_utc": "2026-11-12T16:51:11.187813+00:00", + "host": "Darwin arm64", + "compose_project": "lab5-audit", + "docker": { + "Architecture": "aarch64", + "NCPU": 12, + "MemTotal": 8216776704, + "OperatingSystem": "Docker Desktop", + "ServerVersion": "29.2.1" + } +} diff --git a/evidence/go-tests.txt b/evidence/go-tests.txt new file mode 100644 index 0000000..76b0e21 --- /dev/null +++ b/evidence/go-tests.txt @@ -0,0 +1,27 @@ +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/cmd/messenger [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/cmd/s3init [no test files] +=== RUN TestImageContract +--- PASS: TestImageContract (0.00s) +=== RUN TestRetryDelayBounds +--- PASS: TestRetryDelayBounds (0.00s) +=== RUN TestRealVariants +--- PASS: TestRealVariants (0.01s) +PASS +ok gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/cmd/worker 0.009s +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/middleware [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/cache [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/imagecheck [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/logging [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/objectstore [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/password [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/pipeline [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/service [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/session [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/store/db [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/token [no test files] +? gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/validate [no test files] diff --git a/evidence/overload-check.txt b/evidence/overload-check.txt new file mode 100644 index 0000000..7cdca63 --- /dev/null +++ b/evidence/overload-check.txt @@ -0,0 +1,8 @@ +{"concurrency": 1, "prefetch": 1, "dimensions": [320, 200], "bytes": 32702, "accepted": 12, "rejected_429": 4, "admission_s": 1.136, "drain_s": 1.694, "throughput_jobs_s": 7.084, "queue_lag_p95_s": 2.765, "ready_p95_s": 2.791, "peak_rss_mib": 29.39, "peak_active": 1, "final_queue": [0, 0], "recovery_probe_ready": true} +{"concurrency": 1, "prefetch": 1, "dimensions": [2000, 1400], "bytes": 8404018, "accepted": 12, "rejected_429": 4, "admission_s": 2.05, "drain_s": 7.412, "throughput_jobs_s": 1.619, "queue_lag_p95_s": 7.776, "ready_p95_s": 8.119, "peak_rss_mib": 86.66, "peak_active": 1, "final_queue": [0, 0], "recovery_probe_ready": true} +{"concurrency": 2, "prefetch": 2, "dimensions": [320, 200], "bytes": 32702, "accepted": 12, "rejected_429": 4, "admission_s": 0.835, "drain_s": 1.513, "throughput_jobs_s": 7.933, "queue_lag_p95_s": 2.302, "ready_p95_s": 2.33, "peak_rss_mib": 13.96, "peak_active": 0, "final_queue": [0, 0], "recovery_probe_ready": true} +{"concurrency": 2, "prefetch": 2, "dimensions": [2000, 1400], "bytes": 8404018, "accepted": 12, "rejected_429": 4, "admission_s": 1.567, "drain_s": 5.12, "throughput_jobs_s": 2.344, "queue_lag_p95_s": 4.588, "ready_p95_s": 5.963, "peak_rss_mib": 151.33, "peak_active": 2, "final_queue": [0, 0], "recovery_probe_ready": true} +{"concurrency": 4, "prefetch": 8, "dimensions": [320, 200], "bytes": 32702, "accepted": 12, "rejected_429": 4, "admission_s": 1.086, "drain_s": 1.451, "throughput_jobs_s": 8.27, "queue_lag_p95_s": 2.489, "ready_p95_s": 2.52, "peak_rss_mib": 81.05, "peak_active": 0, "final_queue": [0, 0], "recovery_probe_ready": true} +{"concurrency": 4, "prefetch": 8, "dimensions": [2000, 1400], "bytes": 8404018, "accepted": 12, "rejected_429": 4, "admission_s": 1.187, "drain_s": 3.379, "throughput_jobs_s": 3.551, "queue_lag_p95_s": 3.197, "ready_p95_s": 3.802, "peak_rss_mib": 236.79, "peak_active": 8, "final_queue": [0, 0], "recovery_probe_ready": true} +PASS: six batches drained; accepted work preserved; cap and prefetch enforced +PASS live overload: {"offered": 32, "clients": 8, "accepted": 16, "rejected_429": 16, "max_unfinished": 12, "elapsed_s": 7.84, "all_accepted_ready": true, "recovery_probe_ready": true, "concurrency": 4, "prefetch": 8} diff --git a/evidence/overload-results.json b/evidence/overload-results.json new file mode 100644 index 0000000..59f621a --- /dev/null +++ b/evidence/overload-results.json @@ -0,0 +1,528 @@ +{ + "started_utc": "2026-11-12T16:52:03.496180+00:00", + "configs": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 8 + ] + ], + "cap": 12, + "offered_per_batch": 16, + "samples_interval_s": 0.25, + "results": [ + { + "concurrency": 1, + "prefetch": 1, + "dimensions": [ + 320, + 200 + ], + "bytes": 32702, + "accepted": 12, + "rejected_429": 4, + "admission_s": 1.136, + "drain_s": 1.694, + "throughput_jobs_s": 7.084, + "queue_lag_p95_s": 2.765, + "ready_p95_s": 2.791, + "peak_rss_mib": 29.39, + "peak_active": 1, + "final_queue": [ + 0, + 0 + ], + "recovery_probe_ready": true, + "attempts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "samples": [ + { + "t_s": 1.531, + "rss_kib": 30092, + "pending": 7, + "active": 1 + }, + { + "t_s": 2.024, + "rss_kib": 13248, + "pending": 0, + "active": 0 + } + ] + }, + { + "concurrency": 1, + "prefetch": 1, + "dimensions": [ + 2000, + 1400 + ], + "bytes": 8404018, + "accepted": 12, + "rejected_429": 4, + "admission_s": 2.05, + "drain_s": 7.412, + "throughput_jobs_s": 1.619, + "queue_lag_p95_s": 7.776, + "ready_p95_s": 8.119, + "peak_rss_mib": 86.66, + "peak_active": 1, + "final_queue": [ + 0, + 0 + ], + "recovery_probe_ready": true, + "attempts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "samples": [ + { + "t_s": 1.599, + "rss_kib": 59164, + "pending": 11, + "active": 1 + }, + { + "t_s": 2.051, + "rss_kib": 76372, + "pending": 10, + "active": 1 + }, + { + "t_s": 2.497, + "rss_kib": 75212, + "pending": 8, + "active": 1 + }, + { + "t_s": 2.943, + "rss_kib": 61904, + "pending": 7, + "active": 1 + }, + { + "t_s": 3.43, + "rss_kib": 88736, + "pending": 6, + "active": 1 + }, + { + "t_s": 3.894, + "rss_kib": 63688, + "pending": 4, + "active": 1 + }, + { + "t_s": 4.351, + "rss_kib": 73552, + "pending": 3, + "active": 1 + }, + { + "t_s": 4.815, + "rss_kib": 70504, + "pending": 1, + "active": 1 + }, + { + "t_s": 5.308, + "rss_kib": 66720, + "pending": 1, + "active": 1 + }, + { + "t_s": 5.788, + "rss_kib": 66784, + "pending": 1, + "active": 1 + }, + { + "t_s": 6.267, + "rss_kib": 66780, + "pending": 1, + "active": 1 + }, + { + "t_s": 6.737, + "rss_kib": 66784, + "pending": 1, + "active": 1 + }, + { + "t_s": 7.231, + "rss_kib": 66844, + "pending": 0, + "active": 1 + }, + { + "t_s": 7.68, + "rss_kib": 13236, + "pending": 0, + "active": 0 + } + ] + }, + { + "concurrency": 2, + "prefetch": 2, + "dimensions": [ + 320, + 200 + ], + "bytes": 32702, + "accepted": 12, + "rejected_429": 4, + "admission_s": 0.835, + "drain_s": 1.513, + "throughput_jobs_s": 7.933, + "queue_lag_p95_s": 2.302, + "ready_p95_s": 2.33, + "peak_rss_mib": 13.96, + "peak_active": 0, + "final_queue": [ + 0, + 0 + ], + "recovery_probe_ready": true, + "attempts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "samples": [ + { + "t_s": 1.532, + "rss_kib": 14196, + "pending": 3, + "active": 0 + }, + { + "t_s": 2.015, + "rss_kib": 14296, + "pending": 0, + "active": 0 + } + ] + }, + { + "concurrency": 2, + "prefetch": 2, + "dimensions": [ + 2000, + 1400 + ], + "bytes": 8404018, + "accepted": 12, + "rejected_429": 4, + "admission_s": 1.567, + "drain_s": 5.12, + "throughput_jobs_s": 2.344, + "queue_lag_p95_s": 4.588, + "ready_p95_s": 5.963, + "peak_rss_mib": 151.33, + "peak_active": 2, + "final_queue": [ + 0, + 0 + ], + "recovery_probe_ready": true, + "attempts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "samples": [ + { + "t_s": 1.589, + "rss_kib": 95660, + "pending": 10, + "active": 2 + }, + { + "t_s": 2.045, + "rss_kib": 119908, + "pending": 10, + "active": 2 + }, + { + "t_s": 2.536, + "rss_kib": 149884, + "pending": 8, + "active": 2 + }, + { + "t_s": 3.355, + "rss_kib": 154964, + "pending": 4, + "active": 1 + }, + { + "t_s": 3.821, + "rss_kib": 115940, + "pending": 2, + "active": 2 + }, + { + "t_s": 4.328, + "rss_kib": 111748, + "pending": 0, + "active": 2 + }, + { + "t_s": 4.821, + "rss_kib": 111828, + "pending": 0, + "active": 2 + }, + { + "t_s": 5.293, + "rss_kib": 13312, + "pending": 0, + "active": 0 + }, + { + "t_s": 5.733, + "rss_kib": 13312, + "pending": 0, + "active": 0 + } + ] + }, + { + "concurrency": 4, + "prefetch": 8, + "dimensions": [ + 320, + 200 + ], + "bytes": 32702, + "accepted": 12, + "rejected_429": 4, + "admission_s": 1.086, + "drain_s": 1.451, + "throughput_jobs_s": 8.27, + "queue_lag_p95_s": 2.489, + "ready_p95_s": 2.52, + "peak_rss_mib": 81.05, + "peak_active": 0, + "final_queue": [ + 0, + 0 + ], + "recovery_probe_ready": true, + "attempts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "samples": [ + { + "t_s": 1.53, + "rss_kib": 82996, + "pending": 0, + "active": 0 + }, + { + "t_s": 1.985, + "rss_kib": 14032, + "pending": 0, + "active": 0 + } + ] + }, + { + "concurrency": 4, + "prefetch": 8, + "dimensions": [ + 2000, + 1400 + ], + "bytes": 8404018, + "accepted": 12, + "rejected_429": 4, + "admission_s": 1.187, + "drain_s": 3.379, + "throughput_jobs_s": 3.551, + "queue_lag_p95_s": 3.197, + "ready_p95_s": 3.802, + "peak_rss_mib": 236.79, + "peak_active": 8, + "final_queue": [ + 0, + 0 + ], + "recovery_probe_ready": true, + "attempts": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "samples": [ + { + "t_s": 1.556, + "rss_kib": 186528, + "pending": 4, + "active": 8 + }, + { + "t_s": 2.032, + "rss_kib": 242472, + "pending": 4, + "active": 8 + }, + { + "t_s": 2.547, + "rss_kib": 237892, + "pending": 0, + "active": 8 + }, + { + "t_s": 3.052, + "rss_kib": 204160, + "pending": 0, + "active": 4 + }, + { + "t_s": 3.507, + "rss_kib": 71240, + "pending": 0, + "active": 0 + }, + { + "t_s": 3.968, + "rss_kib": 14116, + "pending": 0, + "active": 0 + } + ] + } + ], + "host": "Darwin arm64", + "docker": { + "Architecture": "aarch64", + "NCPU": 12, + "MemTotal": 8216776704, + "OperatingSystem": "Docker Desktop", + "ServerVersion": "29.2.1" + }, + "live_overload": { + "offered": 32, + "clients": 8, + "accepted": 16, + "rejected_429": 16, + "max_unfinished": 12, + "unfinished_samples": [ + 0, + 0, + 0, + 2, + 9, + 10, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 12, + 8, + 8, + 8, + 9, + 12, + 10, + 8, + 8, + 8, + 6, + 4, + 4, + 3, + 1, + 1, + 1 + ], + "elapsed_s": 7.84, + "all_accepted_ready": true, + "recovery_probe_ready": true, + "concurrency": 4, + "prefetch": 8 + } +} diff --git a/evidence/pipeline-check.txt b/evidence/pipeline-check.txt new file mode 100644 index 0000000..00133bd --- /dev/null +++ b/evidence/pipeline-check.txt @@ -0,0 +1,6 @@ +PASS: crash after COMMIT before publish recovered from outbox +PASS: queued job survives broker/API restart; content blocked until ready +PASS: FAULT_AFTER_OBJECTS, recovery, duplicate no-op, ready replay rejected +PASS: FAULT_BEFORE_ACK, recovery, duplicate no-op, ready replay rejected +PASS: temporary I/O failure, bounded retries, failed content 409, audited replay to ready +PASS: lost DB session automatically restarts worker and processing resumes diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000..6635f4a --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:28085" +PASS: lab5 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/track1-check.txt b/evidence/track1-check.txt new file mode 100644 index 0000000..1c9e3a6 --- /dev/null +++ b/evidence/track1-check.txt @@ -0,0 +1,21 @@ +Дата: 2026-11-12 +Среда: Darwin arm64, Docker Desktop 29.2.1, Linux aarch64. +Compose-проект: lab5-audit. Проверена текущая рабочая копия. +Параметры среды: environment.json. Лимиты: compose.yaml. +Все результаты ниже получены новым полным прогоном после исправления readiness. + +PASS make check — check.txt +PASS docker compose up -d --build --wait — build.txt +PASS docker run --rm lab5-audit-tests go test -count=1 -v ./... — go-tests.txt +PASS python3 -u scripts/check-pipeline.py — pipeline-check.txt, все 6 сценариев +PASS python3 -u scripts/overload-study.py — overload-check.txt и overload-results.json + 3 настройки × 2 размера; 72/72 принятых ready, 24 ожидаемых 429. + Все очереди опустошены; контрольные загрузки и скачивания успешны. + Live burst: 16 accepted, 16 rejected (429), max unfinished 12. + Все принятые live-задачи ready, контрольная загрузка после перегрузки ready. +PASS make test BASE_URL=http://localhost:28085 — smoke.txt, после всех сценариев +PASS git diff --check + +Ограничения: короткие burst, без длительного soak; один Docker-host. +Методика, таблица и ограничения измерений: REPORT.md. +Существующий проект mtusi-lab5 не изменялся. Тестовый проект остановлен с сохранением volumes. diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 0000000..99fae45 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,54 @@ +global + log stdout format raw local0 info + +resolvers docker + nameserver dns 127.0.0.11:53 + accepted_payload_size 8192 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 5s + hold obsolete 5s + +defaults + mode http + log global + option httplog + option dontlognull + + retries 2 + retry-on conn-failure + option redispatch 1 + + timeout connect 500ms + timeout client 30s + timeout server 15s + timeout http-request 10s + timeout http-keep-alive 30s + timeout queue 5s + timeout check 1500ms + + # Ответы самого LB в формате контракта: схема Error и X-Request-Id, совпадающий с request_id. + # Контракт разрешает таким ответам не иметь X-Instance-Id. Ответы реплик эти правила не меняют. + http-error status 502 content-type application/json hdr X-Request-Id "%[var(txn.request_id)]" lf-string '{"error":{"code":"unavailable","message":"Service temporarily unavailable","request_id":"%[var(txn.request_id)]"}}' + http-error status 503 content-type application/json hdr X-Request-Id "%[var(txn.request_id)]" lf-string '{"error":{"code":"unavailable","message":"Service temporarily unavailable","request_id":"%[var(txn.request_id)]"}}' + http-error status 504 content-type application/json hdr X-Request-Id "%[var(txn.request_id)]" lf-string '{"error":{"code":"unavailable","message":"Service temporarily unavailable","request_id":"%[var(txn.request_id)]"}}' + +frontend public + bind :8080 + # Идентификатор для ответов самого LB. У ответов реплик свой X-Request-Id. + http-request set-var(txn.request_id) uuid() + default_backend api + +backend api + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server check init-state down inter 1s fall 2 rise 2 observe layer4 error-limit 2 on-error mark-down resolvers docker init-addr none resolve-prefer ipv4 + server-template api 1-8 api:8080 + +frontend stats + bind 127.0.0.1:8404 + monitor-uri /health + stats enable + stats uri /stats diff --git a/infra/s3-gateway/haproxy.cfg b/infra/s3-gateway/haproxy.cfg new file mode 100644 index 0000000..d8974ec --- /dev/null +++ b/infra/s3-gateway/haproxy.cfg @@ -0,0 +1,37 @@ +# Единственный путь к SeaweedFS из сети стенда: пропускает только порт S3 (9000). +# Нужен потому, что флаг -s3.ip.bind открывает на всех интерфейсах и служебный gRPC-порт шлюза 19000, +# отдельно его не закрыть. Сам SeaweedFS находится во внутренней сети, куда входит только этот шлюз. +# Режим TCP: подпись S3 проверяет сервер, заголовок Host не меняется. + +global + log stdout format raw local0 warning + +resolvers docker + nameserver dns 127.0.0.11:53 + hold valid 2s + hold obsolete 2s + timeout resolve 1s + timeout retry 1s + +defaults + log global + timeout connect 1s + # Больше передачи файла в API (60 с). + timeout client 90s + timeout server 90s + +frontend s3 + mode tcp + bind :9000 + default_backend storage + +backend storage + mode tcp + # Имя s3-storage существует только во внутренней сети. После перезапуска адрес определяется заново. + default-server check inter 1s fall 2 rise 1 init-addr none resolvers docker resolve-prefer ipv4 + server s3 s3-storage:9000 + +frontend health + mode http + bind 127.0.0.1:8405 + monitor-uri /health diff --git a/infra/seaweedfs/master.toml b/infra/seaweedfs/master.toml new file mode 100644 index 0000000..cffbcc0 --- /dev/null +++ b/infra/seaweedfs/master.toml @@ -0,0 +1,4 @@ +# Allocate one volume at a time for this single-node teaching setup. +# The default batch of seven quickly exhausts volume slots across buckets. +[master.volume_growth] +copy_1 = 1 diff --git a/migrations/00001_create_users_table.sql b/migrations/00001_create_users_table.sql new file mode 100644 index 0000000..34e3184 --- /dev/null +++ b/migrations/00001_create_users_table.sql @@ -0,0 +1,22 @@ +-- +goose Up +-- +goose StatementBegin +CREATE TABLE users ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + username text NOT NULL, + display_name text NOT NULL, + -- Строка password KDF (Argon2id/scrypt) вместе с солью и параметрами; никогда не отдаётся в API. + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + + CONSTRAINT users_username_key UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100 + AND btrim(display_name) <> ''), + CONSTRAINT users_password_hash_not_empty CHECK (password_hash <> '') +); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS users; +-- +goose StatementEnd diff --git a/migrations/00002_create_chats_table.sql b/migrations/00002_create_chats_table.sql new file mode 100644 index 0000000..7b5cdd4 --- /dev/null +++ b/migrations/00002_create_chats_table.sql @@ -0,0 +1,16 @@ +-- +goose Up +-- +goose StatementBegin +CREATE TABLE chats ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + title text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100 + AND btrim(title) <> '') +); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS chats; +-- +goose StatementEnd diff --git a/migrations/00003_create_chat_members_table.sql b/migrations/00003_create_chat_members_table.sql new file mode 100644 index 0000000..91aaf57 --- /dev/null +++ b/migrations/00003_create_chat_members_table.sql @@ -0,0 +1,16 @@ +-- +goose Up +-- +goose StatementBegin +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT, + + CONSTRAINT chat_members_pkey PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_id_chat_id_idx ON chat_members (user_id, chat_id); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS chat_members; +-- +goose StatementEnd diff --git a/migrations/00004_create_messages_table.sql b/migrations/00004_create_messages_table.sql new file mode 100644 index 0000000..4466222 --- /dev/null +++ b/migrations/00004_create_messages_table.sql @@ -0,0 +1,25 @@ +-- +goose Up +-- +goose StatementBegin +CREATE TABLE messages ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id uuid NOT NULL, + sender_id uuid NOT NULL, + text text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + + -- Отправитель обязан быть участником этого чата: FK на пару из chat_members. + CONSTRAINT messages_chat_member_fkey FOREIGN KEY (chat_id, sender_id) + REFERENCES chat_members (chat_id, user_id) ON DELETE RESTRICT, + CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000) +); + +-- История чата с keyset-пагинацией: +-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4 +-- Индекс отдаёт страницу без полного scan и без сортировки. +CREATE INDEX messages_chat_id_created_at_id_idx ON messages (chat_id, created_at, id); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS messages; +-- +goose StatementEnd diff --git a/migrations/00005_escape_nul_in_text.sql b/migrations/00005_escape_nul_in_text.sql new file mode 100644 index 0000000..2aede12 --- /dev/null +++ b/migrations/00005_escape_nul_in_text.sql @@ -0,0 +1,45 @@ +-- PostgreSQL text не хранит U+0000, а контракт допускает его в display_name, +-- title и text. Приложение пишет эти поля экранированными: `\` → `\\`, +-- U+0000 → `\0` (app/internal/store/db/text.go). Ограничения длины проверяют +-- раскодированное значение: regexp_replace(x, '\\(.)', '\1', 'g') сворачивает +-- каждую escape-пару в один символ, поэтому char_length совпадает с числом +-- code points исходной строки. + +-- +goose Up +-- +goose StatementBegin +ALTER TABLE users DROP CONSTRAINT users_display_name_len; +ALTER TABLE chats DROP CONSTRAINT chats_title_len; +ALTER TABLE messages DROP CONSTRAINT messages_text_len; + +UPDATE users SET display_name = replace(display_name, '\', '\\') WHERE strpos(display_name, '\') > 0; +UPDATE chats SET title = replace(title, '\', '\\') WHERE strpos(title, '\') > 0; +UPDATE messages SET text = replace(text, '\', '\\') WHERE strpos(text, '\') > 0; + +ALTER TABLE users ADD CONSTRAINT users_display_name_len + CHECK (char_length(regexp_replace(display_name, '\\(.)', '\1', 'g')) BETWEEN 1 AND 100 + AND btrim(regexp_replace(display_name, '\\(.)', '\1', 'g')) <> ''); +ALTER TABLE chats ADD CONSTRAINT chats_title_len + CHECK (char_length(regexp_replace(title, '\\(.)', '\1', 'g')) BETWEEN 1 AND 100 + AND btrim(regexp_replace(title, '\\(.)', '\1', 'g')) <> ''); +ALTER TABLE messages ADD CONSTRAINT messages_text_len + CHECK (char_length(regexp_replace(text, '\\(.)', '\1', 'g')) BETWEEN 1 AND 4000); +-- +goose StatementEnd + +-- +goose Down +-- Откат с потерей: U+0000 непредставим в text и превращается в '0'. +-- +goose StatementBegin +ALTER TABLE users DROP CONSTRAINT users_display_name_len; +ALTER TABLE chats DROP CONSTRAINT chats_title_len; +ALTER TABLE messages DROP CONSTRAINT messages_text_len; + +UPDATE users SET display_name = regexp_replace(display_name, '\\(.)', '\1', 'g') WHERE strpos(display_name, '\') > 0; +UPDATE chats SET title = regexp_replace(title, '\\(.)', '\1', 'g') WHERE strpos(title, '\') > 0; +UPDATE messages SET text = regexp_replace(text, '\\(.)', '\1', 'g') WHERE strpos(text, '\') > 0; + +ALTER TABLE users ADD CONSTRAINT users_display_name_len + CHECK (char_length(display_name) BETWEEN 1 AND 100 AND btrim(display_name) <> ''); +ALTER TABLE chats ADD CONSTRAINT chats_title_len + CHECK (char_length(title) BETWEEN 1 AND 100 AND btrim(title) <> ''); +ALTER TABLE messages ADD CONSTRAINT messages_text_len + CHECK (char_length(text) BETWEEN 1 AND 4000); +-- +goose StatementEnd diff --git a/migrations/00006_create_cache_invalidations_table.sql b/migrations/00006_create_cache_invalidations_table.sql new file mode 100644 index 0000000..852dddb --- /dev/null +++ b/migrations/00006_create_cache_invalidations_table.sql @@ -0,0 +1,23 @@ +-- Отложенная инвалидация кэша истории. Если после COMMIT сообщения сброс +-- версии чата в Valkey не удался, строка фиксирует долг до ответа 201 и +-- переживает рестарт API. gen берётся из общей последовательности и при +-- каждом новом сбое получает ещё не выданное значение: строку удаляет только +-- тот повтор, который видел актуальный gen (compare-and-delete). Счётчик +-- внутри строки не годится: после удаления строки он начался бы снова с 1. + +-- +goose Up +-- +goose StatementBegin +CREATE SEQUENCE cache_invalidations_gen_seq; + +CREATE TABLE cache_invalidations ( + chat_id uuid PRIMARY KEY REFERENCES chats (id) ON DELETE CASCADE, + gen bigint NOT NULL DEFAULT nextval('cache_invalidations_gen_seq'), + updated_at timestamptz NOT NULL DEFAULT now() +); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS cache_invalidations; +DROP SEQUENCE IF EXISTS cache_invalidations_gen_seq; +-- +goose StatementEnd diff --git a/migrations/00007_create_message_idempotency_keys_table.sql b/migrations/00007_create_message_idempotency_keys_table.sql new file mode 100644 index 0000000..e4c1b49 --- /dev/null +++ b/migrations/00007_create_message_idempotency_keys_table.sql @@ -0,0 +1,32 @@ +-- Идемпотентность отправки сообщений, общая для всех реплик API. +-- Область ключа: пользователь + чат + ключ (метод и путь у эндпоинта фиксированы). +-- Строка ключа и сообщение пишутся одной транзакцией: конкурентный INSERT с тем же +-- ключом ждёт её завершения и после COMMIT получает конфликт, после ROLLBACK — вставляет. +-- FK на chat_members не даёт появиться ключу постороннего, поэтому существующий ключ +-- означает, что вызывающий — участник чата. Это и есть проверка доступа при повторе. +-- FK на messages отложенный: ключ вставляется первым, чтобы захватить право на запись. + +-- +goose Up +-- +goose StatementBegin +CREATE TABLE message_idempotency_keys ( + user_id uuid NOT NULL, + chat_id uuid NOT NULL, + key text NOT NULL, + message_id uuid NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + + PRIMARY KEY (user_id, chat_id, key), + CONSTRAINT message_idempotency_keys_member_fkey FOREIGN KEY (chat_id, user_id) + REFERENCES chat_members (chat_id, user_id) ON DELETE RESTRICT, + CONSTRAINT message_idempotency_keys_message_fkey FOREIGN KEY (message_id) + REFERENCES messages (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED +); + +-- Для удаления ключей старше срока хранения. +CREATE INDEX message_idempotency_keys_created_at_idx ON message_idempotency_keys (created_at); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE IF EXISTS message_idempotency_keys; +-- +goose StatementEnd diff --git a/migrations/00008_create_attachments_tables.sql b/migrations/00008_create_attachments_tables.sql new file mode 100644 index 0000000..f752e24 --- /dev/null +++ b/migrations/00008_create_attachments_tables.sql @@ -0,0 +1,69 @@ +-- Вложения: метаданные живут здесь, байты — в приватном S3-bucket (object_key назначает сервер). +-- Составные FK гарантируют на уровне БД: загрузил участник чата, а сообщение ссылается только +-- на вложения своего чата. Поэтому чужое вложение в сообщении невозможно даже при ошибке в коде. +-- Текст сообщения теперь может быть пустым: правило «пустой текст только с вложением» проверяет +-- приложение, потому что вложения пишутся отдельной таблицей. + +-- +goose Up +-- +goose StatementBegin +CREATE TABLE attachments ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL, + owner_id uuid NOT NULL, + filename text NOT NULL, + content_type text NOT NULL, + size_bytes bigint NOT NULL, + sha256 text NOT NULL, + object_key text NOT NULL, + status text NOT NULL DEFAULT 'ready', + created_at timestamptz NOT NULL DEFAULT now(), + updated_at timestamptz NOT NULL DEFAULT now(), + + CONSTRAINT attachments_member_fkey FOREIGN KEY (chat_id, owner_id) + REFERENCES chat_members (chat_id, user_id) ON DELETE RESTRICT, + CONSTRAINT attachments_chat_id_id_key UNIQUE (chat_id, id), + CONSTRAINT attachments_object_key_key UNIQUE (object_key), + CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255), + CONSTRAINT attachments_content_type CHECK (content_type IN ('image/png', 'image/jpeg')), + CONSTRAINT attachments_size CHECK (size_bytes BETWEEN 1 AND 10485760), + CONSTRAINT attachments_sha256 CHECK (sha256 ~ '^[a-f0-9]{64}$'), + CONSTRAINT attachments_status CHECK (status = 'ready') +); + +ALTER TABLE messages ADD CONSTRAINT messages_id_chat_id_key UNIQUE (id, chat_id); + +-- position сохраняет порядок attachment_ids из запроса: повтор POST и чтение истории возвращают +-- тот же порядок. +CREATE TABLE message_attachments ( + message_id uuid NOT NULL, + chat_id uuid NOT NULL, + attachment_id uuid NOT NULL, + position int NOT NULL, + + PRIMARY KEY (message_id, attachment_id), + CONSTRAINT message_attachments_position_key UNIQUE (message_id, position), + CONSTRAINT message_attachments_message_fkey FOREIGN KEY (message_id, chat_id) + REFERENCES messages (id, chat_id) ON DELETE CASCADE, + CONSTRAINT message_attachments_attachment_fkey FOREIGN KEY (chat_id, attachment_id) + REFERENCES attachments (chat_id, id) ON DELETE RESTRICT +); + +CREATE INDEX message_attachments_chat_id_attachment_id_idx ON message_attachments (chat_id, attachment_id); + +ALTER TABLE messages DROP CONSTRAINT messages_text_len; +ALTER TABLE messages ADD CONSTRAINT messages_text_len + CHECK (char_length(regexp_replace(text, '\\(.)', '\1', 'g')) <= 4000); +-- +goose StatementEnd + +-- +goose Down +-- Откат удаляет только метаданные: объекты в bucket остаются. Сообщения без текста получают +-- заполнитель, иначе прежнее ограничение нельзя вернуть. +-- +goose StatementBegin +UPDATE messages SET text = '(attachment)' WHERE text = ''; +ALTER TABLE messages DROP CONSTRAINT messages_text_len; +ALTER TABLE messages ADD CONSTRAINT messages_text_len + CHECK (char_length(regexp_replace(text, '\\(.)', '\1', 'g')) BETWEEN 1 AND 4000); +DROP TABLE message_attachments; +ALTER TABLE messages DROP CONSTRAINT messages_id_chat_id_key; +DROP TABLE attachments; +-- +goose StatementEnd diff --git a/migrations/00009_jobs.sql b/migrations/00009_jobs.sql new file mode 100644 index 0000000..5b7ff54 --- /dev/null +++ b/migrations/00009_jobs.sql @@ -0,0 +1,10 @@ +-- +goose Up +ALTER TABLE attachments DROP CONSTRAINT attachments_status; +ALTER TABLE attachments ADD CONSTRAINT attachments_status CHECK (status IN ('queued','processing','ready','failed')); +ALTER TABLE attachments ADD COLUMN thumbnail jsonb NOT NULL DEFAULT '{}'; +ALTER TABLE attachments ADD COLUMN error_code text; +ALTER TABLE attachments ADD COLUMN attempts int NOT NULL DEFAULT 0; +-- +goose Down +ALTER TABLE attachments DROP COLUMN attempts; +ALTER TABLE attachments DROP COLUMN error_code; +ALTER TABLE attachments DROP COLUMN thumbnail; diff --git a/migrations/00010_pipeline.sql b/migrations/00010_pipeline.sql new file mode 100644 index 0000000..e691527 --- /dev/null +++ b/migrations/00010_pipeline.sql @@ -0,0 +1,17 @@ +-- +goose Up +ALTER TABLE attachments ADD COLUMN variants jsonb NOT NULL DEFAULT '[]'; +ALTER TABLE attachments ADD COLUMN lease_until timestamptz; +ALTER TABLE attachments ADD COLUMN next_attempt_at timestamptz NOT NULL DEFAULT now(); +CREATE TABLE attachment_outbox ( + attachment_id uuid PRIMARY KEY REFERENCES attachments(id), + next_publish_at timestamptz NOT NULL DEFAULT now() +); +CREATE TABLE attachment_replays ( + id bigserial PRIMARY KEY, attachment_id uuid NOT NULL REFERENCES attachments(id), + replayed_at timestamptz NOT NULL DEFAULT now() +); +INSERT INTO attachment_outbox(attachment_id) SELECT id FROM attachments WHERE status IN ('queued','processing'); +-- +goose Down +DROP TABLE attachment_replays; +DROP TABLE attachment_outbox; +ALTER TABLE attachments DROP COLUMN variants, DROP COLUMN lease_until, DROP COLUMN next_attempt_at; diff --git a/migrations/00011_overload.sql b/migrations/00011_overload.sql new file mode 100644 index 0000000..c9709f2 --- /dev/null +++ b/migrations/00011_overload.sql @@ -0,0 +1,6 @@ +-- +goose Up +ALTER TABLE attachments ADD COLUMN processing_started_at timestamptz; +CREATE INDEX attachments_unfinished ON attachments(status) WHERE status IN ('queued','processing'); +-- +goose Down +DROP INDEX attachments_unfinished; +ALTER TABLE attachments DROP COLUMN processing_started_at; diff --git a/scripts/check-pipeline.py b/scripts/check-pipeline.py new file mode 100644 index 0000000..84772dd --- /dev/null +++ b/scripts/check-pipeline.py @@ -0,0 +1,145 @@ +#!/usr/bin/env python3 +"""Short local fault checks; requires a running Compose stand. No load test.""" +import hashlib +import json +import subprocess +import sys +import time +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, Failure, check +from image_probe import jpeg_size + +def dc(*args, ok=True): + r = subprocess.run(['docker', 'compose', *args], capture_output=True, text=True, timeout=90) + if ok and r.returncode: + raise RuntimeError('compose action failed: ' + ' '.join(args[:2])) + return r + +def sql(query): + return dc('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-At', '-v', 'ON_ERROR_STOP=1', '-c', query).stdout.strip() + +def wait_for(predicate, message, timeout=100): + end = time.monotonic()+timeout + while time.monotonic()int(before) + wait_for(restarted,'worker did not restart after losing DB session') + att,content=c.attachment(a,chat) + verify(c,a,att,content) + print('PASS: lost DB session automatically restarts worker and processing resumes') +finally: + subprocess.run(['docker','rm','-f','lab5-retry-worker'],capture_output=True) + dc('start','broker','worker',ok=False) diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100644 index 0000000..de4b14d --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,108 @@ +#!/bin/sh +# Создаёт локальные секреты стенда в каталоге secrets/ (он в .gitignore). Запускается один раз +# на чистом clone, до первого docker compose up: compose.yaml читает секреты из этих файлов. +# +# Запуск из любого каталога: sh scripts/init-secrets.sh +# Настройки через окружение: POSTGRES_USER, POSTGRES_DB (по умолчанию messenger). +# Повторный запуск безопасен: непустые файлы не перезаписываются, значения секретов не печатаются. +# Не удаляйте пароль при существующих томах: PostgreSQL задаёт пароль только при создании своего +# тома, и новый пароль с ним не совпадёт. + +# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную. +set -eu + +# Перейти в корень проекта: все пути ниже указаны относительно него. +cd "$(dirname "$0")/.." +DIR=secrets +# Должны совпадать с POSTGRES_USER и POSTGRES_DB сервиса postgres в compose.yaml. +DB_USER="${POSTGRES_USER:-messenger}" +DB_NAME="${POSTGRES_DB:-messenger}" + +# Новые файлы и каталог сразу доступны только владельцу: секрет не открыт ни на миг. +umask 077 +mkdir -p "$DIR" + +# Пароль PostgreSQL: 24 случайных байта в hex. -s: файла нет или он пуст. +if [ ! -s "$DIR/postgres_password" ]; then + # hex, чтобы пароль не требовал URL-экранирования в DSN. + od -An -tx1 -N24 /dev/urandom | tr -d ' \n' > "$DIR/postgres_password" + echo "init-secrets: created $DIR/postgres_password" +fi + +# Строка подключения к БД для API и migrate. Хост postgres — имя сервиса в сети Compose. +# TLS выключен: подключение идёт только внутри сети учебного стенда. +if [ ! -s "$DIR/database_url" ]; then + pw="$(cat "$DIR/postgres_password")" + printf 'postgres://%s:%s@postgres:5432/%s?sslmode=disable' "$DB_USER" "$pw" "$DB_NAME" > "$DIR/database_url" + echo "init-secrets: created $DIR/database_url" +fi + +# Пароль Valkey, в котором хранятся сессии. +if [ ! -s "$DIR/valkey_password" ]; then + od -An -tx1 -N24 /dev/urandom | tr -d ' \n' > "$DIR/valkey_password" + echo "init-secrets: created $DIR/valkey_password" +fi + +# Адрес хранилища сессий для API. +if [ ! -s "$DIR/cache_url" ]; then + pw="$(cat "$DIR/valkey_password")" + printf 'redis://:%s@valkey:6379/0' "$pw" > "$DIR/cache_url" + echo "init-secrets: created $DIR/cache_url" +fi + +# Пароль отдельного Valkey для кэша истории (необязательный профиль). Перевод строки в кавычках +# ниже — это символ для удаления, как \n в блоках выше. +if [ ! -s "$DIR/valkey_cache_password" ]; then + od -An -tx1 -N24 /dev/urandom | tr -d ' +' > "$DIR/valkey_cache_password" + echo "init-secrets: created $DIR/valkey_cache_password" +fi + +# Адрес кэша истории для API. +if [ ! -s "$DIR/history_cache_url" ]; then + pw="$(cat "$DIR/valkey_cache_password")" + printf 'redis://:%s@valkey-cache:6379/0' "$pw" > "$DIR/history_cache_url" + echo "init-secrets: created $DIR/history_cache_url" +fi + +# Ключи S3, отдельные на каждую роль. Hex: значения не требуют экранирования в JSON. +# s3_* — API; s3_janitor_* — очиститель; s3_admin_* — только подготовка bucket (s3-init). +for role in s3 s3_janitor s3_admin; do + if [ ! -s "$DIR/${role}_access_key_id" ]; then + od -An -tx1 -N10 /dev/urandom | tr -d ' \n' > "$DIR/${role}_access_key_id" + echo "init-secrets: created $DIR/${role}_access_key_id" + fi + if [ ! -s "$DIR/${role}_secret_access_key" ]; then + od -An -tx1 -N20 /dev/urandom | tr -d ' \n' > "$DIR/${role}_secret_access_key" + echo "init-secrets: created $DIR/${role}_secret_access_key" + fi +done + +# Пользователи SeaweedFS. Выводится из ключей выше и перезаписывается всегда, поэтому изменение прав +# здесь применяется и к уже созданному стенду (после перезапуска сервиса s3). Секретов не добавляет. +# Отсутствие записи anonymous означает, что запрос без подписи получает отказ: bucket приватный. +# Права на запись ограничены префиксом объектов, а не bucket: в SeaweedFS Write: разрешает +# и PUT политики bucket, то есть позволил бы API сделать bucket публичным (найдено cmd/s3check). +BUCKET="$(sed -n 's/^S3_BUCKET=//p' .env 2>/dev/null || true)" +BUCKET="${BUCKET:-messenger-attachments}" +identity() { + printf '{"name":"%s","credentials":[{"accessKey":"%s","secretKey":"%s"}],"actions":[%s]}' \ + "$1" "$(cat "$DIR/$2_access_key_id")" "$(cat "$DIR/$2_secret_access_key")" "$3" +} +{ + printf '{"identities":[' + identity messenger-admin s3_admin '"Admin","Read","Write","List"' + printf ',' + identity messenger-api s3 "\"Read:$BUCKET/*\",\"Write:$BUCKET/*\"" + printf ',' + identity messenger-janitor s3_janitor "\"List:$BUCKET\",\"Write:$BUCKET/originals/*\"" + printf ']}' +} > "$DIR/s3_config" + +# Каталог закрыт от других пользователей хоста. Сами файлы открыты на чтение: Compose монтирует +# их в контейнеры с правами хоста, а процессы там работают не от root (API — uid 100). +chmod 0700 "$DIR" +chmod 0644 "$DIR/postgres_password" "$DIR/database_url" "$DIR/valkey_password" "$DIR/cache_url" "$DIR/valkey_cache_password" "$DIR/history_cache_url" \ + "$DIR/s3_access_key_id" "$DIR/s3_secret_access_key" \ + "$DIR/s3_janitor_access_key_id" "$DIR/s3_janitor_secret_access_key" \ + "$DIR/s3_admin_access_key_id" "$DIR/s3_admin_secret_access_key" "$DIR/s3_config" diff --git a/scripts/overload-study.py b/scripts/overload-study.py new file mode 100644 index 0000000..4d5b404 --- /dev/null +++ b/scripts/overload-study.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 +"""Bounded track-1 experiment, stdlib only. Run on a dedicated Compose project. +JOB_MAX_INFLIGHT=12 must be configured in API. Six batches, 16 uploads each. +""" +import concurrent.futures +import datetime as dt +import json +import os +from pathlib import Path +import random +import struct +import subprocess +import sys +import threading +import time +import zlib +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, check + +ROOT=Path(__file__).resolve().parents[1] +OUTPUT=ROOT/'evidence/overload-results.json' +CONFIGS=((1,1),(2,2),(4,8)) + +def dc(*args, env=None): + result=subprocess.run(['docker','compose',*args],env=env,capture_output=True,text=True,timeout=90) + if result.returncode: raise RuntimeError('compose failed: '+' '.join(args[:2])+': '+result.stderr[-600:]) + return result.stdout.strip() + +def sql(query): + return dc('exec','-T','postgres','psql','-U','messenger','-d','messenger','-At','-v','ON_ERROR_STOP=1','-c',query) + +def png(w,h): + # Repeat deterministic textured rows: compact upload, real image decode/WebP work. + rng=random.Random(42) + rows=[rng.randbytes(w*3) for _ in range(32)] + raw=b''.join(b'\x00'+rows[y%32] for y in range(h)) + def chunk(name,data):return struct.pack('!I',len(data))+name+data+struct.pack('!I',zlib.crc32(name+data)&0xffffffff) + return b'\x89PNG\r\n\x1a\n'+chunk(b'IHDR',struct.pack('!2I5B',w,h,8,2,0,0,0))+chunk(b'IDAT',zlib.compress(raw,1))+chunk(b'IEND',b'') + +def percentile(values,p=.95): + import math + return sorted(values)[max(0,math.ceil(len(values)*p)-1)] + +def queue(): + return [int(dc('exec','-T','broker','valkey-cli','LLEN',name)) for name in ('attachments:pending','attachments:active')] + +def live_overload(): + data=json.loads(OUTPUT.read_text()) + c=Client(); actor,_,_,chat=c.bootstrap() + content=png(2000,1400) + samples=[]; stop=threading.Event() + def monitor(): + while not stop.is_set(): + samples.append(int(sql("SELECT count(*) FROM attachments WHERE status IN ('queued','processing')"))) + stop.wait(.1) + def upload(_): + return Client().call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=live.png', + expected=[202,429],actor=actor,raw=content,headers={'Content-Type':'image/png'},schema='Attachment') + thread=threading.Thread(target=monitor);thread.start();start=time.monotonic() + try: + with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor: + replies=list(executor.map(upload,range(32))) + ids=[r['json']['id'] for r in replies if r['status']==202] + rejected=sum(r['status']==429 for r in replies) + check(rejected>0,'live burst did not create backpressure') + deadline=time.monotonic()+75 + while sql("SELECT count(*) FROM attachments WHERE status IN ('queued','processing')")!='0': + check(time.monotonic()