ЛР 4 — БВТ2303 — Вейнмайер — на 5 #56

Closed
Weinmaier_Andrew wants to merge 11 commits from Weinmaier_Andrew/mtusi2026lab4:solution/bvt2303-weinmaier into main
117 changed files with 8454 additions and 19 deletions
+2
View File
@@ -18,3 +18,5 @@ __pycache__
node_modules
evidence
.DS_Store
bin
experiments
+7 -1
View File
@@ -7,7 +7,7 @@ SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
SESSION_STORE=redis
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
@@ -18,3 +18,9 @@ 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
# Graceful shutdown: after SIGTERM readiness=503 for DRAIN_DELAY, then Shutdown up to SHUTDOWN_TIMEOUT.
DRAIN_DELAY=3s
SHUTDOWN_TIMEOUT=8s
# Reconciler (PostgreSQL <-> S3): background pass interval and safe grace period.
RECONCILE_INTERVAL=10m
RECONCILE_GRACE=1h
+102
View File
@@ -0,0 +1,102 @@
# Реальный прогон Docker-стенда lab4 на GitHub-hosted runner.
# Нужен потому, что на машине разработки нет аппаратной виртуализации для Docker Desktop.
# Три независимых стенда параллельно; все результаты — настоящие прогоны.
name: lab4 stand
on:
push:
branches: [lab4]
workflow_dispatch:
permissions:
contents: read
concurrency:
group: lab4-stand-${{ github.ref }}
cancel-in-progress: true
env:
PYTHONUTF8: "1"
jobs:
stand:
name: Стенд — ${{ matrix.part }}
runs-on: ubuntu-24.04
timeout-minutes: 45
strategy:
fail-fast: false
matrix:
part: [base, files, track2]
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- uses: actions/setup-go@v5
with:
go-version-file: go.mod
- name: Unit-тесты Go
if: matrix.part == 'base'
run: |
mkdir -p evidence
go test ./... 2>&1 | tee evidence/go_test.txt
- name: Секреты и запуск стенда
shell: bash
run: |
set -o pipefail
mkdir -p evidence
chmod +x scripts/*.sh infra/s3/init.sh
sh scripts/init-secrets.sh
docker compose --env-file .env config --quiet
# Диагностика в evidence: лог job недоступен из сети разработчика.
for img in $(docker compose config --images | sort -u | grep -v -- '-api:local'); do
if docker pull -q "$img" > /dev/null 2>> evidence/pull_${{ matrix.part }}.log; then echo "ok $img"; else echo "FAIL $img"; fi
done | tee -a evidence/pull_${{ matrix.part }}.log
docker compose --env-file .env build 2>&1 | tail -40 > evidence/build_${{ matrix.part }}.log
docker compose --env-file .env up -d --wait 2>&1 | tee evidence/up_${{ matrix.part }}.log
docker compose logs --no-color s3-init 2>&1 | tee evidence/s3init_${{ matrix.part }}.log
- name: make check + доказательства (${{ matrix.part }})
run: |
make check PYTHON=python
PYTHON=python sh scripts/collect-evidence.sh ${{ matrix.part }}
- name: Окружение runner
if: always()
run: |
mkdir -p evidence
{ nproc; free -m; docker version --format '{{.Server.Version}}'; docker compose version; } > evidence/runner_${{ matrix.part }}.txt
docker compose ps -a > evidence/docker_ps_final_${{ matrix.part }}.txt || true
docker compose logs --no-color > evidence/compose_logs_${{ matrix.part }}.log 2>&1 || true
- uses: actions/upload-artifact@v4
if: always()
with:
name: evidence-${{ matrix.part }}
path: evidence/
# api.github.com недоступен из сети разработчика, а github.com (git) — доступен,
# поэтому артефакты публикуются в ветку lab4-results.
publish:
name: Публикация результатов в ветку lab4-results
needs: [stand]
if: always()
runs-on: ubuntu-24.04
permissions:
contents: write
steps:
- uses: actions/checkout@v4
- uses: actions/download-artifact@v4
with:
path: collected
- name: Commit в lab4-results
run: |
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git checkout -q --orphan lab4-results
git rm -rf -q .
{ echo "source_commit=${{ github.sha }}"
echo "run=${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
echo "stand=${{ needs.stand.result }}"; } > collected/RUN.txt
cp -r collected/. .
rm -rf collected
git add -A
git commit -q -m "results for ${{ github.sha }}"
git push -f origin lab4-results
+56
View File
@@ -0,0 +1,56 @@
# ============================================================
# Stage 1: builder — компилируем статический бинарник
# ============================================================
FROM golang:1.26-alpine@sha256:27f2d3b83cfc5803c8078f8e730af0f7c431bf067afaec8f60a36fb763187cba AS builder
WORKDIR /src
# Сначала манифесты зависимостей — кэшируем слой.
COPY go.mod go.sum ./
RUN go mod download
# Затем исходники.
COPY . .
# Статический бинарник с оптимизациями:
# CGO_ENABLED=0 — статическая линковка (не требует libc)
# -ldflags="-s -w" — убираем отладочную информацию
# -trimpath — убираем пути сборки из бинарника
RUN CGO_ENABLED=0 GOOS=linux go build \
-ldflags="-s -w" \
-trimpath \
-o /out/ \
./cmd/api ./cmd/reconcile
# ============================================================
# Stage 2: runtime — минимальный образ только с бинарником
# ============================================================
FROM alpine:3.20@sha256:d9e853e87e55526f6b2917df91a2115c36dd7c696a35be12163d44e6e2a4b6bc
# ca-certificates — для HTTPS в lab2+
# tzdata — для корректной работы с временными зонами
RUN apk --no-cache add ca-certificates tzdata
# Непривилегированный пользователь (UID/GID 1001).
RUN addgroup -g 1001 -S appgroup && \
adduser -u 1001 -S appuser -G appgroup
WORKDIR /app
# Копируем бинарник и сразу выставляем владельца.
COPY --from=builder --chown=appuser:appgroup /out/api /app/api
# reconcile — сверка PostgreSQL и S3 (сервис reconciler и ручной запуск).
COPY --from=builder --chown=appuser:appgroup /out/reconcile /app/reconcile
# Переключаемся на непривилегированного пользователя.
USER 1001:1001
# Информативно: какой порт слушает приложение.
EXPOSE 8080
# Healthcheck: readiness (БД + Redis + не в режиме drain).
HEALTHCHECK --interval=5s --timeout=2s --start-period=5s --retries=3 \
CMD wget --spider -q http://localhost:8080/health/ready || exit 1
# Exec-форма CMD — критично для доставки SIGTERM в приложение.
CMD ["/app/api"]
+24 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test load test-persistence test-failover up down test-files test-reconcile reconcile-dry reconcile-apply evidence
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -28,3 +28,26 @@ test-persistence:
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
# --- Студенческие цели (lab4) ---
up:
sh scripts/init-secrets.sh
docker compose --env-file .env up -d --build --wait
down:
docker compose --env-file .env stop
test-files:
$(PYTHON) student-tests/attachments_negative.py --base-url "$(BASE_URL)"
test-reconcile:
$(PYTHON) student-tests/reconcile_faults.py --base-url "$(BASE_URL)"
reconcile-dry:
docker compose run --rm --no-deps --entrypoint /app/reconcile reconciler
reconcile-apply:
docker compose run --rm --no-deps --entrypoint /app/reconcile reconciler --apply
evidence:
sh scripts/collect-evidence.sh all
+193 -17
View File
@@ -1,37 +1,213 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Вейнмайер Андрей Андреевич, БВТ2303
- Целевая оценка: 5 (уровни 3, 4 и трек 2 «Согласованность двух хранилищ»)
- Commit/PR: ветка `solution/bvt2303-weinmaier` в https://gitea.privcloud.tech/WeinmaierAndrew/mtusi2026lab4, PR в mtusi2026/mtusi2026lab4
- Основа: собственная lab3 (PR mtusi2026/mtusi2026lab3#43) — балансировка, идемпотентность, отказ реплики
- Использованные источники:
- Контракт: contracts/openapi.json, contracts/README.md (разделы «Вложения»)
- Библиотеки: github.com/minio/minio-go/v7, github.com/jackc/pgx/v5, github.com/redis/go-redis/v9, golang.org/x/crypto/argon2
- Спецификации: PNG (ISO/IEC 15948: chunks, CRC, Adam7), JPEG (ITU T.81: маркеры, SOF, SOS, EOI)
- Документация: MinIO (`mc admin policy`, `mc anonymous`), AWS S3 ListObjectsV2, Docker Compose
- Помощь ИИ: ИИ-ассистент использовался при реализации и отладке; все результаты ниже — реальные прогоны, ссылки на них приведены.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
### Версии
| Компонент | Образ |
| --- | --- |
| API, reconciler | golang:1.26-alpine → alpine:3.20, оба закреплены по digest в Dockerfile; один образ, два бинарника (`/app/api`, `/app/reconcile`) |
| S3 | `bitnamilegacy/minio:2025.4.22@sha256:50cec18a…` — MinIO RELEASE.2025-04-22T22-12-26Z |
| Bootstrap S3 | `bitnamilegacy/minio-client:2025.4.16@sha256:8a86e441…` — mc RELEASE.2025-04-16 |
| LB / БД / сессии | haproxy:3.0.5-alpine, postgres:16.4-alpine, redis:7.4.1-alpine (digest в `evidence/images.txt`) |
| Миграции | migrate/migrate:v4.17.0 |
**Почему Bitnami.** Официальные образы `minio/minio` и `minio/mc` в ходе работы оказались недоступны и на Docker Hub (`repository does not exist`), и на quay.io (`unauthorized`) — проверено отдельным прогоном на GitHub runner. Использована сборка Bitnami **того же релиза MinIO**, закреплённая по digest. Запасной вариант из задания, если и она пропадёт, — SeaweedFS (`chrislusf/seaweedfs:3.97`, доступен).
Prerequisites: Docker с Compose v2, Python 3.9+, POSIX shell (Linux/macOS/WSL или Git Bash).
### Команды
```sh
sh scripts/init-secrets.sh # .env и secrets/ (пароли и ключи S3 генерируются, не печатаются)
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait # postgres, redis, s3 → migrate, s3-init → api×2, reconciler → lb
make test # публичный smoke lab4
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && sh scripts/restore.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-files # негативный набор вложений
make test-reconcile # трек 2: внедрение расхождений
make reconcile-dry # отчёт reconciler без изменений
sh scripts/collect-evidence.sh all # все доказательства в evidence/
```
Остановка без потери данных: `docker compose --env-file .env stop`. Намеренное удаление учебных данных: `docker compose --env-file .env down -v` (удаляет `pg_data`, `redis_data`, `s3_data`).
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ──► lb (HAProxy, единственный опубликованный порт 127.0.0.1:8080)
▼
api × N ──► postgres: users, chats, messages, attachments (метаданные), message_attachments
│ ──► redis: сессии, кэш истории
└───────► s3 (MinIO, сеть back, порты не опубликованы, консоль off): bucket messenger-attachments (private)
reconciler (тот же образ, --apply --interval 10m --grace 1h) ──► postgres + s3
s3-init (one-shot): bucket, anonymous none, политика и пользователь API
```
**Перенесено из lab3:** всё — X-Instance-Id, идемпотентность, HAProxy с readiness, drain по SIGTERM, сессии в Redis, версия кэша истории в PostgreSQL, однократные миграции, скрипты отказа.
**Новое в lab4:**
1. **Модель данных** ([0004_attachments.up.sql](migrations/0004_attachments.up.sql)): `attachments(id, chat_id, owner_id, filename, object_key UNIQUE, status uploading|ready|missing, content_type, size_bytes, sha256, …)` и `message_attachments(message_id, attachment_id, position)`. Object key `a/{chat_id}/{attachment_id}` назначает сервер; filename только отображается.
2. **Загрузка** ([attachment.go](internal/service/attachment.go)):
1. членство в чате (иначе 404) → filename (иначе 400) → Content-Type png/jpeg (иначе 415) → `Content-Length > 10 MiB` → 413 **без чтения тела**; без Content-Length тело читается максимум до лимита + 1 байт;
2. формат по первым байтам (подмена MIME → 415); ранний отказ по пикселям, если заголовок в первых 64 KiB;
3. **намерение** `status=uploading` в PostgreSQL — до записи в S3, поэтому у любого объекта, который может появиться в bucket, есть учётная запись;
4. **один потоковый PUT** в S3; через pipe параллельно идёт SHA-256 и структурная проверка изображения ([imagecheck.go](internal/imagecheck/imagecheck.go)): PNG — CRC каждого chunk, IHDR, длина распакованного IDAT (zlib → io.Discard, с учётом Adam7); JPEG — сегменты, SOF, сканы, EOI. Пиксели не декодируются, лимит 40 млн пикселей проверяется по IHDR/SOF до распаковки, «бомба» 100000×100000 отклоняется по 66 байтам;
5. `status=ready` + content_type/size/sha256 → **201** только после того, как объект и метаданные сохранены.
3. **Компенсация.** Ошибка до `MarkReady` (битое изображение, отказ S3, обрыв клиента) — сразу удаляются объект и намерение. Ошибка `MarkReady` — **исход неизвестен**: объект не удаляется, намерение удаляется, только если оно всё ещё `uploading` (см. «Исправления, найденные тестами»). Остатки любых сбоев убирает reconciler.
4. **Скачивание** — только через API, без redirect: проверка членства в чате вложения, `Content-Type` оригинала, `Content-Length`, сверка размера с метаданными, `Cache-Control: private, no-store`. `variant=original`/по умолчанию — байты; `thumbnail|crop|optimized` — 404 (у ready-объекта lab4 вариантов нет); прочее — 400.
5. **Сообщения**: `attachment_ids` (0–10 уникальных UUID, по умолчанию `[]`), `text=""` допустим только с вложениями. Вложения проверяются и блокируются `FOR SHARE` в транзакции сообщения: того же чата, `ready`; чужое/неизвестное/незавершённое — 404, в карантине — 409. Порядок сохраняется; отпечаток идемпотентности включает `attachment_ids` (отсутствие = `[]`, другой порядок = другое тело → 409).
6. **S3 и права** ([infra/s3/init.sh](infra/s3/init.sh)): идемпотентный bootstrap — `mb --ignore-existing`, `anonymous set none`, политика `messenger-api` (Get/Put/Delete объектов и List только этого bucket), отдельный пользователь API. Root-ключ есть только у `s3` и `s3-init`; у API и reconciler — ключ с политикой. Консоль MinIO выключена (`MINIO_BROWSER=off`), порты S3 не публикуются.
7. **Readiness не включает S3** — сознательно: без S3 работают регистрация, сессии, чаты и текстовые сообщения, а эндпоинты вложений отвечают 503. Если бы S3 входил в readiness, LB снял бы все реплики и уронил весь мессенджер из-за одной функции.
8. **Таймауты**: обычный API 5 s, загрузка/скачивание 30 s (`ReadTimeout` 30 s), HAProxy `timeout server 15s`; minio-go — 2 повтора вместо 10, чтобы отказ S3 давал быстрый 503, а не таймаут LB.
**Соответствие .env.example**: `S3_ENDPOINT/S3_REGION/S3_BUCKET/S3_*_FILE/MAX_UPLOAD_BYTES/MAX_IMAGE_PIXELS` — как в контракте; `SESSION_STORE=redis`; добавлены `RECONCILE_INTERVAL`, `RECONCILE_GRACE`, `DRAIN_DELAY`, `SHUTDOWN_TIMEOUT`.
## Где запускался стенд
На машине разработки нет аппаратной виртуализации для Docker Desktop, поэтому Docker-проверки выполнены на **GitHub-hosted runner** workflow [.github/workflows/lab4-stand.yml](.github/workflows/lab4-stand.yml): три независимых стенда параллельно (`base`, `files`, `track2`), тот же compose.yaml и те же скрипты. Runner: 2 vCPU, 8 GB, Docker 28.0.4, Compose v2.38.2.
Итоговый прогон: https://github.com/CharaWein/2026_lab3/actions/runs/41881945345 (commit 5119d0b, `stand=success`). Все файлы в `evidence/` — из него. Предыдущие прогоны той же ветки нашли ошибки, исправленные ниже.
До Docker-прогона логика проверялась нативно (PostgreSQL 17, S3-эмулятор moto, 2 процесса API): smoke, негативный набор, reconciler.
## Исправления, найденные тестами
| Что показал тест | Причина | Исправление |
| --- | --- | --- |
| `db-gap`: после паузы PostgreSQL во время `MarkReady` строка стала `ready`, а объекта в S3 нет | клиент отвалился по таймауту LB → контекст отменён → код посчитал UPDATE неудавшимся и удалил объект; но UPDATE уже ушёл в БД и закоммитился после разморозки | `MarkReady` выполняется в собственном контексте (байты уже сохранены, учёт доводится до конца); ошибка `MarkReady` считается **неопределённым исходом** — объект не удаляется. Повторный прогон: `ready` + объект, согласовано |
| `s3-outage`: при остановленном S3 загрузка давала **415** вместо 503 | PUT упал → pipe закрыт с ошибкой → валидатор принял обрыв потока за «битое изображение» | валидатор различает собственную ошибку и обрыв потока снаружи (`trackingReader`); unit-тест [attachment_test.go](internal/service/attachment_test.go) на все четыре причины |
| официальные образы MinIO недоступны | убраны из Docker Hub и quay.io | Bitnami той же версии, по digest |
| файлы секретов 600 читались контейнерами (uid 1001) только потому, что uid runner совпал | права | файлы 644, каталог `secrets/` 700 |
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
### Уровень 3
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Возможности lab3 сохранены | регрессии lab3, идемпотентность, failover ×2, persistence, серия отказов, rolling update | все PASS; 0 дублей, 0 ошибок при остановке реплик, rolling update — 0 ошибок из 34 743 запросов | evidence/regressions.txt, idempotency_concurrent.json, failover_*.txt, failover_series.json, rolling_update*.* |
| S3 в общем стенде; метаданные в PostgreSQL, байты в приватном bucket | compose.yaml, `docker compose ps` | s3, s3-init, reconciler в стенде; у API нет volume, оригиналы только в `s3_data` | evidence/docker_ps.txt |
| POST вложения → 201 ready; оригинал побайтно; Message с attachment_ids; посторонний — 404 | `make test` | `PASS: lab4 public API scenario` (SHA-256 оригинала, 404 у постороннего) | evidence/smoke.txt |
| Реальные PNG/JPEG ≤10 MiB, ≤40 Мпикс; MIME по содержимому; опасные filename; лимиты до чтения/декодирования | `make test-files` | 28 случаев, 0 ответов 5xx (таблица ниже) | evidence/files/attachments_negative.txt |
| Upload → остановка обслужившей реплики → download через другую | `attachments_ops.py failover` | загрузил `5c22e6c38769`, контейнер остановлен, скачивал `cd9621e01c62`, SHA-256 совпал | evidence/files/files_failover.json |
| Restart с volumes сохраняет метаданные и оригинал | `make test-persistence` (lab4 проверяет и файл) | PASS; перезапущены postgres, redis, **s3**, api, lb, reconciler | evidence/persistence.txt |
| Failover lab4 (с проверкой оригинала) | `make test-failover` ×2 | PASS ×2, по 144 записи, 0 ошибок, восстановление записи 3.49 s / 3.35 s | evidence/failover_1.txt, failover_2.txt |
### Уровень 4
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Тесты: большой файл, повреждённое изображение, подмена MIME, чужое attachment_id, вложение другого чата; без 500 | `attachments_negative.py` | 413 по Content-Length (тело не читается) и по chunked 11 MiB; 413 на «бомбе» и 40 000 001 пикселе; 415 на обрезанных/повреждённых PNG и JPEG, подмене MIME в обе стороны, тексте, GIF, пустом теле; 404 на вложение другого чата и неизвестный id; 400 на дубли, >10 id, невалидный UUID | evidence/files/attachments_negative.txt |
| Прерывание загрузки не оставляет неучтённых объектов | `attachments_ops.py interrupt`: отправлен 1 MiB из 4, соединение оборвано | строк 0, объектов 0 (компенсация сразу) | evidence/files/files_interrupt.json |
| Отказ между S3 и БД | `attachments_ops.py db-gap`: PUT прошёл, PostgreSQL на паузе 45 s | клиент получил 504, **201 не было**; после разморозки — `ready` + 1 объект (согласовано); reconciler ничего исправлять не пришлось | evidence/files/files_db-gap.json, compensation_log.txt |
| Механизм сверки/очистки с безопасным grace | reconciler (сервис и `make reconcile-*`) | grace 1h по умолчанию; <5m только с `--unsafe-short-grace`; трек 2 ниже | cmd/reconcile, evidence/track2/ |
| Недоступность S3 | `attachments_ops.py s3-outage` | загрузка **503 за 0.38 s**, скачивание 503, метаданные 200, текстовое сообщение 201, readiness 200, брошенных намерений 0; после старта S3 загрузка снова ready, старый файл цел | evidence/files/files_s3-outage.json |
| ≥10 одновременных загрузок, пик памяти | `attachments_ops.py memory`: 10 и 20 загрузок по 10.2 MB, `memory.peak` cgroup реплик | см. таблицу ниже: +17.7 MiB при 97 MiB трафика, +39.7 MiB при 194 MiB | evidence/files/files_memory.json |
| Bootstrap идемпотентен; отдельные ограниченные credentials; консоль закрыта; private bucket вне API | `attachments_ops.py security` | анонимный GET и LIST изнутри сети — 403; ключ API: свой bucket — да, создать bucket — нет, admin API — нет, видит только `messenger-attachments`; `s3-init` два раза подряд — exit 0, объектов 10→10; порты S3 не опубликованы | evidence/files/files_security.json |
**Пик памяти при одновременных загрузках** (файл 10 187 085 байт, лимит контейнера 256 MiB):
| Параллельно | Успешно | Трафик, MiB | Пик реплики до → после, MiB | Рост, MiB | ≈ на загрузку |
| --- | --- | --- | --- | --- | --- |
| 10 | 10/10 | 97.2 | 7.3 → 25.0 | 17.7 | 1.8 MiB |
| 20 | 20/20 | 194.3 | 8.1 → 47.8 | 39.7 | 2.0 MiB |
Рост пропорционален числу **одновременных** загрузок, а не размеру файла: на загрузку уходят буферы чтения (64 KiB peek, 32 KiB валидатор, чанки подписи minio-go) и служебная память HTTP/GC. Буферизация файла целиком дала бы ≥10 MiB на загрузку (≥200 MiB при 20). Ограничение памяти по числу одновременных загрузок сверху — `maxconn` HAProxy и лимит контейнера; отдельного семафора на загрузки нет.
## Трек 5.2: согласованность двух хранилищ
### Гипотеза
1. Повторяемый reconciler, обходящий PostgreSQL и S3 одним merge-проходом в общем порядке ключей, находит все виды расхождений (сироты, потерянные объекты, брошенные загрузки, подменённый размер) и исправляет их безопасно: dry-run ничего не меняет, повторный прогон ничего не находит, свежие (моложе grace) и используемые сообщениями вложения не удаляются никогда.
2. Память обхода постоянна (O(1) от числа вложений), время линейно и определяется S3 LIST, а не базой.
Разбивка времени по источникам (`wait_ms`) добавлена после первого замера, когда рост времени на пару оказался нелинейным на малых N.
### Методика
**Reconciler** ([reconcile.go](internal/reconcile/reconcile.go), [cmd/reconcile](cmd/reconcile/main.go)): строки `attachments` (`ORDER BY object_key COLLATE "C"`) и `ListObjectsV2` (лексикографический порядок) читаются потоками и сливаются как отсортированные списки. Время «сейчас» берётся из PostgreSQL. Одновременно работает один экземпляр (`pg_try_advisory_lock`).
| Расхождение | Условие | Действие (`--apply`) | Защита |
| --- | --- | --- | --- |
| stale_intent | строка `uploading` старше grace | удалить объект (если есть), затем строку | моложе grace — загрузка может идти |
| orphan_object | объект без строки, старше grace | удалить объект | перед удалением повторная проверка строки по ключу |
| missing_object | строка `ready` без объекта | карантин `status=missing` (API → 503) | перед карантином повторный `Stat` объекта |
| size_mismatch | размер объекта ≠ метаданным | карантин | — |
| restored | `missing`, объект снова есть и размер совпал | `status=ready` | — |
| purge_missing | `missing` старше grace и **ни одно сообщение не ссылается** | удалить строку | `FOR UPDATE` против `FOR SHARE` при прикреплении; используемые остаются навсегда |
Порядок «сначала объект, потом строка» выбран так, чтобы сбой между шагами оставлял учтённое намерение, а не неучтённый объект.
**Внедрение ошибок** ([reconcile_faults.py](student-tests/reconcile_faults.py)): через API — чат и 6 вложений, 3 из них прикреплены к сообщениям. Затем: S3 — старая сирота, свежая сирота, удалены 3 объекта (2 используемых, 1 нет), подменён размер одного; БД — 2 брошенных намерения (с объектом и без), 1 «идущая» загрузка. Grace в тесте 8 s (`--unsafe-short-grace`), «старые» строки сдвинуты на 30 минут, чтобы фоновый reconciler стенда (grace 1h) их не трогал.
**Стоимость обхода** ([reconcile_cost.py](student-tests/reconcile_cost.py)): досеиваем согласованные пары до N = 1 000 / 10 000 / 30 000 (строки — SQL, объекты по 1 KiB — `mc mirror`), три dry-run на каждый N, медиана; затем 1% расхождений (150 удалённых объектов + 150 сирот).
### Результаты
**Обнаружение и исправление** (evidence/track2/faults.json):
| Проход | Найдено | Исправлено | Пропущено (защита) |
| --- | --- | --- | --- |
| dry-run | stale_intent 2, orphan 1, missing 3, size_mismatch 1 | — (снимки БД и S3 до/после совпали) | fresh_intent 1, fresh_object 1 |
| apply | те же 7 | все 7 | fresh_intent 1, fresh_object 1 |
| повторный apply | 0 | 0 | + fresh_missing (карантин моложе grace) |
| объект «восстановлен из бэкапа» | restored 1 | 1 (скачивание снова отдаёт исходные байты) | — |
| после grace | purge_missing 2, orphan 1 (бывшая свежая), stale_intent 1 (бывшая «идущая») | все | **referenced_missing_kept 1** |
После apply через API: здоровые вложения скачиваются байт-в-байт; потерянные отвечают 503 на метаданные и байты; сообщение сохраняет `attachment_ids`; прикрепить вложение из карантина — 409.
**Стоимость обхода** (evidence/track2/cost.json, медиана 3 dry-run; runner 2 vCPU):
| Пар (строка+объект) | Время, ms | мкс на пару | LIST-страниц | Ожидание S3 LIST, ms | Ожидание БД, ms | Heap, MB |
| --- | --- | --- | --- | --- | --- | --- |
| 1 004 | 96 | 96 | 2 | 59–96 | 0–74 | 2.4 |
| 10 004 | 2 647 | 265 | 11 | 2 410–2 863 | 58–235 | 3.4 |
| 30 004 | 8 374 | 279 | 31 | 7 502–11 235 | 127–292 | 2.2 |
| 30 004 + 1% расхождений | 10 344 | — | 31 | — | — | — + 150 `Stat` |
- **Память постоянна**: heap 2–3.4 MB при росте N в 30 раз — merge-проход не держит множества в памяти. Гипотеза подтверждена.
- **Время определяется S3 LIST**: 96–98% времени reconciler ждёт листинга MinIO, менее 3% — PostgreSQL. Гипотеза подтверждена.
- **Линейность — с оговоркой**: от 10k к 30k время на пару почти постоянно (265 → 279 мкс, +5%), а 1k дешевле в 2.8 раза. Объяснение (не измерено отдельно): небольшой листинг MinIO отдаёт из кэша метаданных, большие требуют обхода диска. На 2 vCPU это ≈ 0.28 ms на объект, то есть ~4.6 минуты на миллион вложений — при интервале 10 минут приемлемо, дальше нужен обход по префиксам чатов или инкрементальная сверка по событиям S3.
- 1% расхождений добавляет ~2 s: 150 точечных `Stat` для перепроверки перед карантином (в dry-run сироты моложе grace только учтены как `fresh_object`).
### Ограничения трека
- Один узел MinIO на 2 vCPU; абсолютные цифры зависят от диска и CPU, вывод о доминировании LIST — нет.
- Объекты по 1 KiB: размер на обход не влияет (LIST не читает тела), но на время `mc mirror` при подготовке влияет.
- Сверка размера — по LIST, без пересчёта SHA-256 (это потребовало бы скачать все объекты); подмена содержимого с тем же размером не обнаруживается.
- Grace зависит от часов: время строк — из PostgreSQL, LastModified — из MinIO; на одном хосте расхождение пренебрежимо, на разных узлах grace должен покрывать skew.
- Ready-вложение, загруженное, но так и не прикреплённое к сообщению, reconciler не удаляет (контракт не задаёт срок жизни таких вложений).
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка реплики, загрузившей файл | скачивание через другую | тот же SHA-256 через другую реплику | 0 |
| Остановка S3 | 503 на вложениях, остальное работает | 503 за 0.38 s; текст, сессии, readiness — OK | после старта S3 — сразу; данные целы |
| Обрыв клиента посреди тела | ни строки, ни объекта | 0/0 | — |
| PostgreSQL замер между PUT и MarkReady | не 201; нет `ready` без объекта | 504 клиенту; `ready` + объект после разморозки | 0 потерь; дубль загрузки при повторе клиента возможен (см. ограничения) |
| Restart всего стенда | данные и файлы целы | PASS с прежним токеном | ≈14 s до healthy |
| Остановка каждой реплики под нагрузкой | 0 ошибок | 0 из 18 996 | возврат в LB за 6.4 s |
| Rolling update под нагрузкой | 0 ошибок | 0 из 34 743 | замена 29 s |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- SPOF: один узел MinIO (без erasure coding), PostgreSQL, Redis, LB, хост. Выдерживается отказ API-реплики и временная недоступность S3 (вложения недоступны, мессенджер работает).
- Загрузка не идемпотентна (контракт не требует ключа): если клиент не получил ответ (504 в `db-gap`) и повторит загрузку, появится второе вложение; первое останется неприкреплённым.
- Ограничение памяти на одновременные загрузки обеспечено косвенно (буферы O(1) на загрузку + `maxconn` LB + лимит контейнера); явного семафора нет.
- JPEG проверяется структурно (маркеры, SOF, EOI), без энтропийного декодирования: формально корректный JPEG с испорченными данными скана будет принят.
- Bitnami legacy-образы больше не обновляются; при смене образа достаточно поменять `image` в compose.yaml (MinIO API тот же) или перейти на SeaweedFS.
+166
View File
@@ -0,0 +1,166 @@
package main
import (
"context"
"errors"
"log/slog"
"net/http"
"os"
"os/signal"
"sync/atomic"
"syscall"
"time"
"github.com/charawein/mtusi2026lab4/internal/config"
"github.com/charawein/mtusi2026lab4/internal/repository/postgres"
redisrepo "github.com/charawein/mtusi2026lab4/internal/repository/redis"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/storage"
transporthttp "github.com/charawein/mtusi2026lab4/internal/transport/http"
)
func main() {
cfg := config.Load()
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: cfg.LogLevel}))
slog.SetDefault(logger)
if cfg.DatabaseURL == "" {
slog.Error("DATABASE_URL_FILE is not set or empty")
os.Exit(1)
}
if cfg.CacheURL == "" {
slog.Error("CACHE_URL_FILE is not set or empty")
os.Exit(1)
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
pool, err := postgres.NewPool(ctx, cfg.DatabaseURL, cfg.DBPoolMax)
cancel()
if err != nil {
slog.Error("connect to postgres", "err", err)
os.Exit(1)
}
defer pool.Close()
rctx, rcancel := context.WithTimeout(context.Background(), 10*time.Second)
redisClient, err := redisrepo.NewClient(rctx, cfg.CacheURL)
rcancel()
if err != nil {
slog.Error("connect to redis", "err", err)
os.Exit(1)
}
defer redisClient.Close()
if cfg.S3AccessKey == "" || cfg.S3SecretKey == "" {
slog.Error("S3_ACCESS_KEY_ID_FILE / S3_SECRET_ACCESS_KEY_FILE are not set or empty")
os.Exit(1)
}
store, err := storage.NewS3(cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, cfg.S3AccessKey, cfg.S3SecretKey)
if err != nil {
slog.Error("s3 client", "err", err)
os.Exit(1)
}
userRepo := postgres.NewUserRepository(pool)
chatRepo := postgres.NewChatRepository(pool)
msgRepo := postgres.NewMessageRepository(pool)
sessRepo := redisrepo.NewSessionRepository(redisClient)
userSvc := service.NewUserService(userRepo)
chatSvc := service.NewChatService(chatRepo, userRepo)
var msgCache *redisrepo.MessageCache
if cfg.CacheEnabled {
msgCache = redisrepo.NewMessageCache(redisClient, cfg.CacheInvalidation)
}
msgSvc := service.NewMessageService(msgRepo, chatRepo, msgCache, cfg.IdempotencyTTL)
attSvc := service.NewAttachmentService(postgres.NewAttachmentRepository(pool), chatRepo, store,
cfg.MaxUploadBytes, cfg.MaxImagePixels)
authSvc := service.NewAuthService(userRepo, sessRepo, cfg.SessionTTL())
// draining выставляется по SIGTERM: /health/ready начинает отвечать 503,
// LB исключает реплику, и только затем закрывается listener.
var draining atomic.Bool
router := transporthttp.NewRouter(userSvc, chatSvc, msgSvc, attSvc, authSvc, pool, redisClient, cfg.InstanceID, &draining)
// Очистка просроченных ключей идемпотентности. Запрос идемпотентен,
// поэтому параллельный запуск на всех репликах безопасен.
cleanupCtx, cleanupStop := context.WithCancel(context.Background())
defer cleanupStop()
go func() {
t := time.NewTicker(time.Hour)
defer t.Stop()
for {
select {
case <-cleanupCtx.Done():
return
case <-t.C:
ctx, cancel := context.WithTimeout(cleanupCtx, 30*time.Second)
if n, err := msgRepo.DeleteExpiredKeys(ctx, cfg.IdempotencyTTL); err != nil {
slog.Warn("idempotency cleanup failed", "err", err)
} else if n > 0 {
slog.Info("idempotency keys expired", "deleted", n)
}
cancel()
}
}
}()
srv := &http.Server{
Addr: cfg.Addr(),
Handler: router,
ReadHeaderTimeout: 5 * time.Second,
// Загрузка до 10 MiB должна уложиться в ReadTimeout; медленный клиент
// дольше не держит соединение и память.
ReadTimeout: 30 * time.Second,
WriteTimeout: 35 * time.Second,
IdleTimeout: 60 * time.Second,
}
// Внутренний endpoint метрик для экспериментов (трек 1). Порт не публикуется
// и не проксируется LB: читается только через docker exec внутри контейнера.
internalSrv := &http.Server{
Addr: cfg.InternalAddr,
Handler: transporthttp.NewInternalStatsHandler(pool, cfg),
ReadHeaderTimeout: 2 * time.Second,
}
go func() {
if err := internalSrv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
slog.Warn("internal stats server failed", "err", err)
}
}()
defer internalSrv.Close()
errCh := make(chan error, 1)
go func() {
slog.Info("server starting", "addr", cfg.Addr(), "instance_id", cfg.InstanceID)
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
errCh <- err
}
}()
sigCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
defer stop()
select {
case err := <-errCh:
slog.Error("server failed", "err", err)
os.Exit(1)
case <-sigCtx.Done():
slog.Info("shutdown signal received, draining", "delay", cfg.DrainDelay)
}
// Перестаём быть ready и даём LB время заметить это (inter*fall у HAProxy),
// продолжая обслуживать уже направленные к нам запросы.
draining.Store(true)
time.Sleep(cfg.DrainDelay)
shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
slog.Error("graceful shutdown failed", "err", err)
os.Exit(1)
}
slog.Info("server stopped")
}
+106
View File
@@ -0,0 +1,106 @@
// Command reconcile сверяет PostgreSQL и S3 и безопасно убирает расхождения.
//
// reconcile # dry-run, grace 1h, отчёт JSON в stdout
// reconcile --apply # исправить
// reconcile --apply --interval 10m # фоновый режим (сервис reconciler в compose)
//
// Grace period должен быть больше максимальной длительности загрузки
// (ReadTimeout 30 s + PUT) с запасом на расхождение часов; значения < 5m
// разрешены только с --unsafe-short-grace (для тестов).
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log/slog"
"os"
"os/signal"
"syscall"
"time"
"github.com/charawein/mtusi2026lab4/internal/config"
"github.com/charawein/mtusi2026lab4/internal/reconcile"
"github.com/charawein/mtusi2026lab4/internal/repository/postgres"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/storage"
)
func main() {
apply := flag.Bool("apply", false, "apply fixes (default: dry-run, report only)")
grace := flag.Duration("grace", time.Hour, "do not touch objects/intents/quarantine younger than this")
unsafe := flag.Bool("unsafe-short-grace", false, "allow grace < 5m (tests only)")
interval := flag.Duration("interval", 0, "repeat every interval (0 = run once)")
flag.Parse()
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stderr, nil)))
if *grace < 5*time.Minute && !*unsafe {
fmt.Fprintln(os.Stderr, "grace < 5m is unsafe: in-flight uploads could be deleted; pass --unsafe-short-grace for tests")
os.Exit(2)
}
cfg := config.Load()
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
defer stop()
pool, err := postgres.NewPool(ctx, cfg.DatabaseURL, 4)
if err != nil {
slog.Error("connect to postgres", "err", err)
os.Exit(1)
}
defer pool.Close()
store, err := storage.NewS3(cfg.S3Endpoint, cfg.S3Region, cfg.S3Bucket, cfg.S3AccessKey, cfg.S3SecretKey)
if err != nil {
slog.Error("s3 client", "err", err)
os.Exit(1)
}
repo := postgres.NewAttachmentRepository(pool)
runOnce := func() int {
unlock, ok, err := repo.TryLock(ctx)
if err != nil {
slog.Error("advisory lock", "err", err)
return 1
}
if !ok {
slog.Warn("another reconciler is running, skipping this pass")
return 3
}
defer unlock()
var now time.Time
if err := pool.QueryRow(ctx, `SELECT now()`).Scan(&now); err != nil {
slog.Error("db time", "err", err)
return 1
}
rep, err := reconcile.Run(ctx, repo, store, reconcile.Options{
Prefix: service.ObjectPrefix, Grace: *grace, Apply: *apply, Now: now,
})
out, _ := json.Marshal(rep)
fmt.Println(string(out))
if err != nil {
slog.Error("reconcile pass failed", "err", err)
return 1
}
slog.Info("reconcile pass done", "dry_run", rep.DryRun, "found", rep.Found, "fixed", rep.Fixed,
"rows", rep.RowsScanned, "objects", rep.ObjectsScanned, "ms", rep.DurationMS)
if len(rep.Errors) > 0 {
return 4
}
return 0
}
if *interval <= 0 {
os.Exit(runOnce())
}
t := time.NewTicker(*interval)
defer t.Stop()
for {
runOnce()
select {
case <-ctx.Done():
return
case <-t.C:
}
}
}
+222
View File
@@ -0,0 +1,222 @@
# Lab4: клиент → HAProxy → API × N → PostgreSQL (данные и метаданные вложений), Redis (сессии, кэш)
# и приватный S3 (MinIO) для байтов вложений.
# Запуск: scripts/init-secrets.sh && docker compose --env-file .env up -d --build --wait
name: mtusi2026lab4
x-api-env: &api-env
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: ${APP_PORT:-8080}
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: ${SESSION_STORE:-redis}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
DRAIN_DELAY: ${DRAIN_DELAY:-3s}
SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-8s}
DB_POOL_MAX: ${DB_POOL_MAX:-20}
CACHE_INVALIDATION: ${CACHE_INVALIDATION:-version}
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_access_key_id
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
services:
lb:
image: haproxy:3.0.5-alpine
ports:
- "127.0.0.1:${LB_PORT:-8080}:8080"
- "127.0.0.1:${LB_STATS_PORT:-8404}:8404"
environment:
LB_BALANCE: ${LB_BALANCE:-roundrobin}
volumes:
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
depends_on:
api:
condition: service_healthy
restart: unless-stopped
networks: [front]
deploy:
resources:
limits: { cpus: "${LB_CPUS:-0.50}", memory: 128M }
api:
build: .
image: mtusi2026lab4-api:local
# Без container_name и без ports: реплики доступны только через lb.
environment: *api-env
secrets: [database_url, cache_url, s3_access_key_id, s3_secret_access_key]
depends_on:
migrate:
condition: service_completed_successfully
s3-init:
condition: service_completed_successfully
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health/ready"]
interval: 5s
timeout: 2s
retries: 3
start_period: 5s
# DRAIN_DELAY + SHUTDOWN_TIMEOUT < stop_grace_period, иначе SIGKILL оборвёт запросы.
stop_grace_period: 15s
restart: unless-stopped
networks: [front, back]
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits: { cpus: "${API_CPUS:-0.50}", memory: "${API_MEMORY:-256M}" }
# Однократные миграции до старта API: реплики не гоняются за схему.
migrate:
image: migrate/migrate:v4.17.0
volumes:
- ./migrations:/migrations:ro
secrets: [database_url]
entrypoint: ["/bin/sh", "-c", "exec migrate -path /migrations -database \"$$(cat /run/secrets/database_url)\" up"]
depends_on:
postgres:
condition: service_healthy
restart: "no"
networks: [back]
postgres:
image: postgres:16.4-alpine
command: ["postgres", "-c", "max_connections=${PG_MAX_CONNECTIONS:-100}"]
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_DB: messenger
secrets: [postgres_password]
volumes:
- pg_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 5
restart: unless-stopped
networks: [back]
deploy:
resources:
limits: { cpus: "${PG_CPUS:-1.00}", memory: "${PG_MEMORY:-512M}" }
redis:
image: redis:7.4.1-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 5
restart: unless-stopped
networks: [back]
deploy:
resources:
limits: { cpus: "${REDIS_CPUS:-0.50}", memory: 256M }
# S3-совместимое хранилище байтов вложений: MinIO RELEASE.2025-04-22T22-12-26Z.
# Официальные образы minio/minio убраны из Docker Hub и quay.io (проверено в CI),
# поэтому используется сборка Bitnami того же релиза, закреплённая по digest.
# Порты не публикуются, консоль выключена (MINIO_BROWSER=off): доступ только из сети back.
s3:
image: bitnamilegacy/minio:2025.4.22@sha256:50cec18ac4184af4671a78aedd5554942c8ae105d51a465fa82037949046da01
entrypoint: ["/bin/bash", "-c"]
command:
- export MINIO_ROOT_USER="$$(cat /run/secrets/s3_root_user)" MINIO_ROOT_PASSWORD="$$(cat /run/secrets/s3_root_password)"; exec /opt/bitnami/minio/bin/minio server /bitnami/minio/data --address :9000
environment:
MINIO_BROWSER: "off"
secrets: [s3_root_user, s3_root_password]
volumes:
- s3_data:/bitnami/minio/data
healthcheck:
# Без curl в образе: HTTP/1.1-запрос к /minio/health/live через /dev/tcp и read (только bash).
test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/9000 && printf 'GET /minio/health/live HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n' >&3 && read -r line <&3 && [[ $$line == *' 200 '* ]]"]
interval: 5s
timeout: 3s
retries: 20
restart: unless-stopped
networks: [back]
deploy:
resources:
limits: { cpus: "${S3_CPUS:-0.50}", memory: 512M }
# Идемпотентный bootstrap: приватный bucket, политика и отдельный пользователь
# API с правами только на этот bucket. Root-учётка есть только у s3 и s3-init.
s3-init:
image: bitnamilegacy/minio-client:2025.4.16@sha256:8a86e441decf053093c5977d49290298295f850c7843652f93e970ab15871dd1
entrypoint: ["/bin/sh", "/init/init.sh"]
environment:
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
PATH: /opt/bitnami/minio-client/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
MC_CONFIG_DIR: /tmp/.mc
secrets: [s3_root_user, s3_root_password, s3_access_key_id, s3_secret_access_key]
volumes:
- ./infra/s3:/init:ro
depends_on:
s3:
condition: service_healthy
restart: "no"
networks: [back]
# Сверка PostgreSQL и S3: брошенные загрузки, сироты, потерянные объекты.
# Безопасный grace period 1h; одновременно работает один экземпляр (advisory lock).
reconciler:
image: mtusi2026lab4-api:local
entrypoint: ["/app/reconcile", "--apply", "--interval", "${RECONCILE_INTERVAL:-10m}", "--grace", "${RECONCILE_GRACE:-1h}"]
environment:
<<: *api-env
CACHE_URL_FILE: "" # Redis reconciler не нужен
secrets: [database_url, s3_access_key_id, s3_secret_access_key]
# HTTP не обслуживает, поэтому вместо HEALTHCHECK образа API — проверка, что
# процесс reconcile жив (нужна и для docker compose up --wait).
healthcheck:
test: ["CMD-SHELL", "pgrep -x reconcile >/dev/null || pidof reconcile >/dev/null"]
interval: 10s
timeout: 3s
retries: 3
start_period: 5s
depends_on:
migrate:
condition: service_completed_successfully
s3-init:
condition: service_completed_successfully
restart: unless-stopped
networks: [back]
deploy:
resources:
limits: { cpus: "0.25", memory: 128M }
networks:
# front: lb ↔ api; back: api ↔ хранилища. LB не видит БД и S3.
front:
back:
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
s3_root_user:
file: ./secrets/s3_root_user
s3_root_password:
file: ./secrets/s3_root_password
s3_access_key_id:
file: ./secrets/s3_access_key_id
s3_secret_access_key:
file: ./secrets/s3_secret_access_key
volumes:
s3_data:
pg_data:
redis_data:
+3
View File
@@ -0,0 +1,3 @@
source_commit=5119d0b5fdcf247c86a773f03ab6fe3adeee8ba0
run=https://github.com/CharaWein/2026_lab3/actions/runs/41881945345
stand=success
+10
View File
@@ -0,0 +1,10 @@
2026-11-04T17:59:52Z
Docker Compose version v2.38.2
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab4-api-1 mtusi2026lab4-api:local "/app/api" api 16 seconds ago Up 6 seconds (healthy) 8080/tcp
mtusi2026lab4-api-2 mtusi2026lab4-api:local "/app/api" api 16 seconds ago Up 7 seconds (healthy) 8080/tcp
mtusi2026lab4-lb-1 haproxy:3.0.5-alpine "docker-entrypoint.s…" lb 16 seconds ago Up 1 second 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp
mtusi2026lab4-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 16 seconds ago Up 15 seconds (healthy) 5432/tcp
mtusi2026lab4-reconciler-1 mtusi2026lab4-api:local "/app/reconcile --ap…" reconciler 16 seconds ago Up 7 seconds (healthy) 8080/tcp
mtusi2026lab4-redis-1 redis:7.4.1-alpine "docker-entrypoint.s…" redis 16 seconds ago Up 15 seconds (healthy) 6379/tcp
mtusi2026lab4-s3-1 bitnamilegacy/minio:2025.4.22@sha256:50cec18ac4184af4671a78aedd5554942c8ae105d51a465fa82037949046da01 "/bin/bash -c 'expor…" s3 16 seconds ago Up 15 seconds (healthy) 9000-9001/tcp
+10
View File
@@ -0,0 +1,10 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab4-api-3 mtusi2026lab4-api:local "/app/api" api About a minute ago Up About a minute (healthy) 8080/tcp
mtusi2026lab4-api-4 mtusi2026lab4-api:local "/app/api" api About a minute ago Up About a minute (healthy) 8080/tcp
mtusi2026lab4-lb-1 haproxy:3.0.5-alpine "docker-entrypoint.s…" lb 5 minutes ago Up 3 minutes 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp
mtusi2026lab4-migrate-1 migrate/migrate:v4.17.0 "/bin/sh -c 'exec mi…" migrate 5 minutes ago Exited (0) 3 minutes ago
mtusi2026lab4-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 5 minutes ago Up 3 minutes (healthy) 5432/tcp
mtusi2026lab4-reconciler-1 mtusi2026lab4-api:local "/app/reconcile --ap…" reconciler 5 minutes ago Up 3 minutes (healthy) 8080/tcp
mtusi2026lab4-redis-1 redis:7.4.1-alpine "docker-entrypoint.s…" redis 5 minutes ago Up 3 minutes (healthy) 6379/tcp
mtusi2026lab4-s3-1 bitnamilegacy/minio:2025.4.22@sha256:50cec18ac4184af4671a78aedd5554942c8ae105d51a465fa82037949046da01 "/bin/bash -c 'expor…" s3 5 minutes ago Up 3 minutes (healthy) 9000-9001/tcp
mtusi2026lab4-s3-init-1 bitnamilegacy/minio-client:2025.4.16@sha256:8a86e441decf053093c5977d49290298295f850c7843652f93e970ab15871dd1 "/bin/sh /init/init.…" s3-init 5 minutes ago Exited (0) 3 minutes ago
+7
View File
@@ -0,0 +1,7 @@
mtusi2026lab4-api-4 0.18% 8.203MiB / 256MiB
mtusi2026lab4-api-3 0.09% 8.07MiB / 256MiB
mtusi2026lab4-lb-1 0.13% 8.844MiB / 128MiB
mtusi2026lab4-reconciler-1 0.00% 3.941MiB / 128MiB
mtusi2026lab4-redis-1 0.48% 4.207MiB / 256MiB
mtusi2026lab4-postgres-1 0.07% 73.31MiB / 512MiB
mtusi2026lab4-s3-1 0.00% 335.9MiB / 512MiB
+8
View File
@@ -0,0 +1,8 @@
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 144, "failed_attempts": 0, "first_recovery_seconds": 3.486}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
-- контейнеры api после stop-one:
mtusi2026lab4-api-1 79e9bafcf0e6 Up 30 seconds (healthy)
mtusi2026lab4-api-2 f758f63bab9a Exited (0) 11 seconds ago
mtusi2026lab4-api-1 Up 38 seconds (healthy)
mtusi2026lab4-api-2 Up 6 seconds (healthy)
+8
View File
@@ -0,0 +1,8 @@
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 144, "failed_attempts": 0, "first_recovery_seconds": 3.353}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
-- контейнеры api после stop-one:
mtusi2026lab4-api-1 79e9bafcf0e6 Up 54 seconds (healthy)
mtusi2026lab4-api-2 f758f63bab9a Exited (0) 12 seconds ago
mtusi2026lab4-api-1 Up About a minute (healthy)
mtusi2026lab4-api-2 Up 6 seconds (healthy)
+64
View File
@@ -0,0 +1,64 @@
{
"concurrency": 4,
"replicas": 2,
"total": {
"seconds": 53.79,
"ok": 18996,
"errors": 0,
"ok_rps": 353.2
},
"confirmed_writes": 9499,
"stored_messages": 9501,
"duplicates": 0,
"lost_confirmed": 0,
"per_replica": [
{
"target_instance": "79e9bafcf0e6",
"docker_stop_seconds": 3.62,
"before": {
"seconds": 5.0,
"ok": 1787,
"errors": 0,
"ok_rps": 357.4
},
"during_stop_and_observe": {
"seconds": 15.0,
"ok": 5435,
"errors": 0,
"ok_rps": 362.3
},
"errors_after_stop": 0,
"recovery_seconds": 0.0,
"target_last_served_after_stop_seconds": 0.8,
"other_instances_after": [
"f758f63bab9a"
],
"restore_healthy_seconds": 6.37,
"restore_serving_via_lb_seconds": 6.37
},
{
"target_instance": "f758f63bab9a",
"docker_stop_seconds": 4.1,
"before": {
"seconds": 5.0,
"ok": 1738,
"errors": 0,
"ok_rps": 347.6
},
"during_stop_and_observe": {
"seconds": 15.0,
"ok": 5454,
"errors": 0,
"ok_rps": 363.6
},
"errors_after_stop": 0,
"recovery_seconds": 0.0,
"target_last_served_after_stop_seconds": 0.64,
"other_instances_after": [
"79e9bafcf0e6"
],
"restore_healthy_seconds": 6.45,
"restore_serving_via_lb_seconds": 6.45
}
]
}
+29
View File
@@ -0,0 +1,29 @@
ok.png image/png 106 -> 201
ok.jpg image/jpeg 900 -> 201
%D1%84%D0%BE%D1%82%D0%BE%20%F0%9F%98%80. image/png 106 -> 201
params.png image/png; charset=binary 106 -> 201
near-limit.png image/png 10288524 -> 201
too-big.png (Content-Length) image/png 10485761 -> 413
too-big-chunked.png (no Content-Length) image/png 11534336 -> 413
bomb.png image/png 66 -> 413
over-pixels.png image/png 66 -> 413
truncated.png image/png 53 -> 415
corrupt.png image/png 106 -> 415
truncated.jpg image/jpeg 898 -> 415
mime-swap.png image/jpeg 106 -> 415
mime-swap.jpg image/png 900 -> 415
text.png image/png 23 -> 415
gif.gif image/gif 14 -> 415
ctype-missing.png application/octet-stream 106 -> 415
empty.png image/png 0 -> 415
short-data.png image/png 68 -> 415
..%2Fetc%2Fpasswd image/png 106 -> 400
a%5Cb.png image/png 106 -> 400
nul%00.png image/png 106 -> 400
bell%07.png image/png 106 -> 400
%20%20%20 image/png 106 -> 400
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx image/png 106 -> 400
image/png 106 -> 400
eve.png image/png 106 -> 404
foreign.png image/png 106 -> 201
PASS: attachment negative suite (28 upload cases, no 5xx)
+8
View File
@@ -0,0 +1,8 @@
api-2 | {"time":"2026-11-04T17:59:08.618848913Z","level":"INFO","msg":"attachment upload compensated","attachment_id":"8376ff59-6e3b-434b-851f-c94203d9d4fb","cause":"unsupported media type"}
api-2 | {"time":"2026-11-04T17:59:08.649043939Z","level":"INFO","msg":"attachment upload compensated","attachment_id":"1dec380c-52c3-49ce-8eaa-d1c9b7010a28","cause":"unsupported media type"}
api-2 | {"time":"2026-11-04T17:59:21.56713159Z","level":"WARN","msg":"s3 get failed","attachment_id":"61eea43b-d38d-43ce-82f8-869e27973710","err":"s3 stat: Head \"http://s3:9000/messenger-attachments/a/4e3fa29e-8850-4823-ab42-fab04574a248/61eea43b-d38d-43ce-82f8-869e27973710\": dial tcp: lookup s3 on 127.0.0.11:53: no such host"}
api-1 | {"time":"2026-11-04T17:59:08.607887582Z","level":"INFO","msg":"attachment upload compensated","attachment_id":"3d005de4-f4dd-41db-8e29-a8af5d808c2b","cause":"unsupported media type"}
api-1 | {"time":"2026-11-04T17:59:08.626900518Z","level":"INFO","msg":"attachment upload compensated","attachment_id":"aca7c508-c906-46db-8830-afe0f0ec1917","cause":"unsupported media type"}
api-1 | {"time":"2026-11-04T17:59:21.278574756Z","level":"WARN","msg":"compensation: delete object failed, reconciler will retry","attachment_id":"cb3c808e-1d56-48a2-b1f4-928325f04c92","err":"s3 delete: Delete \"http://s3:9000/messenger-attachments/a/4e3fa29e-8850-4823-ab42-fab04574a248/cb3c808e-1d56-48a2-b1f4-928325f04c92\": dial tcp: lookup s3 on 127.0.0.11:53: no such host"}
api-1 | {"time":"2026-11-04T17:59:21.280005994Z","level":"INFO","msg":"attachment upload compensated","attachment_id":"cb3c808e-1d56-48a2-b1f4-928325f04c92","cause":"unavailable"}
api-1 | {"time":"2026-11-04T17:59:31.143854842Z","level":"INFO","msg":"attachment upload compensated","attachment_id":"9abeb5ec-bae5-4f6e-9616-5db53e004b34","cause":"unavailable"}
+7
View File
@@ -0,0 +1,7 @@
mtusi2026lab4-lb-1 0.12% 8.504MiB / 128MiB
mtusi2026lab4-api-2 2.99% 13.17MiB / 256MiB
mtusi2026lab4-api-1 2.96% 14.02MiB / 256MiB
mtusi2026lab4-reconciler-1 0.00% 4.086MiB / 128MiB
mtusi2026lab4-redis-1 0.49% 3.648MiB / 256MiB
mtusi2026lab4-s3-1 0.00% 438.5MiB / 512MiB
mtusi2026lab4-postgres-1 0.05% 67.9MiB / 512MiB
+16
View File
@@ -0,0 +1,16 @@
{
"scenario": "db-gap",
"result": {
"client_status": 504,
"seconds": 53.2,
"after_gap": {
"row_status": "ready",
"objects": 1
},
"reconciler_fixed": {},
"after_reconcile": {
"row_status": "ready",
"objects": 1
}
}
}
+11
View File
@@ -0,0 +1,11 @@
{
"scenario": "failover",
"result": {
"uploaded_by": "5c22e6c38769",
"downloaded_by": [
"cd9621e01c62"
],
"sha256": "9cd8ae086706327908419e4e9782e8ed003310802f9381e4f8776a81079460e5",
"stopped_container": "5c22e6c38769"
}
}
+9
View File
@@ -0,0 +1,9 @@
{
"scenario": "interrupt",
"result": {
"sent_bytes": 1048576,
"declared_bytes": 4192910,
"rows_after": 0,
"objects_after": 0
}
}
+40
View File
@@ -0,0 +1,40 @@
{
"scenario": "memory",
"result": {
"file_bytes": 10187085,
"runs": [
{
"parallel": 10,
"ok": 10,
"failed": [],
"max_seconds": 0.88,
"baseline_peak_mib": {
"cd9621e01c62": 7.9,
"5c22e6c38769": 7.3
},
"peak_mib": {
"cd9621e01c62": 17.3,
"5c22e6c38769": 25.0
},
"payload_total_mib": 97.2,
"max_peak_growth_mib": 17.7
},
{
"parallel": 20,
"ok": 20,
"failed": [],
"max_seconds": 2.22,
"baseline_peak_mib": {
"cd9621e01c62": 8.1,
"5c22e6c38769": 7.4
},
"peak_mib": {
"cd9621e01c62": 47.8,
"5c22e6c38769": 42.7
},
"payload_total_mib": 194.3,
"max_peak_growth_mib": 39.7
}
]
}
}
+13
View File
@@ -0,0 +1,13 @@
{
"scenario": "s3-outage",
"result": {
"upload_status_during_outage": 503,
"upload_error_seconds": 0.38,
"download_status_during_outage": 503,
"metadata_during_outage": "ready",
"text_message_during_outage": 201,
"readiness_during_outage": 200,
"intents_left": 0,
"upload_after_recovery": "ready"
}
}
+22
View File
@@ -0,0 +1,22 @@
{
"scenario": "security",
"result": {
"anonymous_get": "403",
"anonymous_list": "403",
"api_key_own_bucket": "allowed",
"api_key_make_bucket": "denied",
"api_key_admin": "denied",
"api_key_visible_buckets": [
"messenger-attachments"
],
"bootstrap_runs": [
0,
0
],
"objects_before_after": [
10,
10
],
"s3_published_ports": "9000-9001/tcp"
}
}
+41
View File
@@ -0,0 +1,41 @@
go: downloading github.com/jackc/pgx/v5 v5.11.0
go: downloading github.com/redis/go-redis/v9 v9.23.0
go: downloading github.com/google/uuid v1.6.0
go: downloading golang.org/x/crypto v0.58.0
go: downloading github.com/minio/minio-go/v7 v7.4.1
go: downloading github.com/jackc/puddle/v2 v2.2.2
go: downloading github.com/jackc/pgpassfile v1.0.0
go: downloading github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761
go: downloading golang.org/x/text v0.43.0
go: downloading golang.org/x/sys v0.49.0
go: downloading github.com/cespare/xxhash/v2 v2.3.0
go: downloading github.com/dustin/go-humanize v1.0.1
go: downloading github.com/klauspost/compress v1.19.2
go: downloading github.com/klauspost/crc32 v1.3.0
go: downloading github.com/minio/crc64nvme v1.1.1
go: downloading github.com/minio/md5-simd v1.1.2
go: downloading github.com/zeebo/xxh3 v1.1.0
go: downloading go.yaml.in/yaml/v3 v3.0.5
go: downloading golang.org/x/net v0.60.0
go: downloading gopkg.in/ini.v1 v1.67.3
go: downloading golang.org/x/sync v0.24.0
go: downloading go.uber.org/atomic v1.12.0
go: downloading github.com/klauspost/cpuid/v2 v2.4.0
go: downloading github.com/rs/xid v1.6.0
go: downloading github.com/tinylib/msgp v1.6.4
go: downloading github.com/philhofer/fwd v1.2.0
? github.com/charawein/mtusi2026lab4/cmd/api [no test files]
? github.com/charawein/mtusi2026lab4/cmd/reconcile [no test files]
? github.com/charawein/mtusi2026lab4/internal/config [no test files]
? github.com/charawein/mtusi2026lab4/internal/domain [no test files]
ok github.com/charawein/mtusi2026lab4/internal/imagecheck 0.026s
ok github.com/charawein/mtusi2026lab4/internal/reconcile 0.009s
? github.com/charawein/mtusi2026lab4/internal/repository [no test files]
? github.com/charawein/mtusi2026lab4/internal/repository/postgres [no test files]
? github.com/charawein/mtusi2026lab4/internal/repository/redis [no test files]
ok github.com/charawein/mtusi2026lab4/internal/service 0.009s
? github.com/charawein/mtusi2026lab4/internal/storage [no test files]
? github.com/charawein/mtusi2026lab4/internal/transport/http [no test files]
? github.com/charawein/mtusi2026lab4/internal/transport/http/middleware [no test files]
? github.com/charawein/mtusi2026lab4/internal/transport/httputil [no test files]
? github.com/charawein/mtusi2026lab4/student-tests/genfixtures [no test files]
+88
View File
@@ -0,0 +1,88 @@
{
"rounds": 10,
"parallel_per_round": 16,
"distinct_instances_seen": 2,
"duplicates_found": 0,
"per_round": [
{
"round": 0,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 1,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 2,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 3,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 4,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 5,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 6,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 7,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 8,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
},
{
"round": 9,
"requests": 16,
"status_201": 16,
"distinct_messages": 1,
"stored": 1,
"instances": 2
}
]
}
+8
View File
@@ -0,0 +1,8 @@
bitnamilegacy/minio-client:2025.4.16@sha256:8a86e441decf053093c5977d49290298295f850c7843652f93e970ab15871dd1 bitnamilegacy/minio-client@sha256:8a86e441decf053093c5977d49290298295f850c7843652f93e970ab15871dd1
bitnamilegacy/minio:2025.4.22@sha256:50cec18ac4184af4671a78aedd5554942c8ae105d51a465fa82037949046da01 bitnamilegacy/minio@sha256:50cec18ac4184af4671a78aedd5554942c8ae105d51a465fa82037949046da01
haproxy:3.0.5-alpine haproxy@sha256:43a2591a6a62a41dd22edb4452880e9c70de489fbd7c54ffb52d035cccbfe949
migrate/migrate:v4.17.0 migrate/migrate@sha256:4d017c6fb5997127093648cab09e63d377997125c3d3dcca18e5d1c847da49fa
mtusi2026lab4-api:local
local-build
postgres:16.4-alpine postgres@sha256:5660c2cbfea50c7a9127d17dc4e48543eedd3d7a41a595a2dfa572471e37e64c
redis:7.4.1-alpine redis@sha256:c1e88455c85225310bbea54816e9c3f4b5295815e6dbf80c34d40afc6df28275
+2
View File
@@ -0,0 +1,2 @@
79e9bafcf0e6 10
f758f63bab9a 10
+18
View File
@@ -0,0 +1,18 @@
-- до:
mtusi2026lab4-api-1 Up About a minute (healthy)
mtusi2026lab4-api-2 Up 6 seconds (healthy)
mtusi2026lab4-lb-1 Up 57 seconds
mtusi2026lab4-postgres-1 Up About a minute (healthy)
mtusi2026lab4-reconciler-1 Up About a minute (healthy)
mtusi2026lab4-redis-1 Up About a minute (healthy)
mtusi2026lab4-s3-1 Up About a minute (healthy)
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
-- после:
mtusi2026lab4-api-1 Up 6 seconds (healthy)
mtusi2026lab4-api-2 Up 6 seconds (healthy)
mtusi2026lab4-lb-1 Up Less than a second
mtusi2026lab4-postgres-1 Up 14 seconds (healthy)
mtusi2026lab4-reconciler-1 Up 6 seconds (healthy)
mtusi2026lab4-redis-1 Up 14 seconds (healthy)
mtusi2026lab4-s3-1 Up 14 seconds (healthy)
+3
View File
@@ -0,0 +1,3 @@
PASS: whitespace-only password rejected with 400 (3 variants)
PASS: Redis ACL -incr: message visible on every next read (3 in history)
PASS: Redis ACL -incr -del -unlink -scan: message visible on every next read (4 in history)
+89
View File
@@ -0,0 +1,89 @@
-- до:
mtusi2026lab4-api-1 79e9bafcf0e6 Up About a minute (healthy)
mtusi2026lab4-api-2 f758f63bab9a Up About a minute (healthy)
#1 [internal] load local bake definitions
#1 reading from stdin 380B done
#1 DONE 0.0s
#2 [internal] load build definition from Dockerfile
#2 transferring dockerfile: 2.55kB done
#2 DONE 0.0s
#3 [internal] load metadata for docker.io/library/golang:1.26-alpine@sha256:27f2d3b83cfc5803c8078f8e730af0f7c431bf067afaec8f60a36fb763187cba
#3 DONE 0.0s
#4 [internal] load metadata for docker.io/library/alpine:3.20@sha256:d9e853e87e55526f6b2917df91a2115c36dd7c696a35be12163d44e6e2a4b6bc
#4 DONE 0.0s
#5 [internal] load .dockerignore
#5 transferring context: 212B 0.0s done
#5 DONE 0.0s
#6 [builder 1/6] FROM docker.io/library/golang:1.26-alpine@sha256:27f2d3b83cfc5803c8078f8e730af0f7c431bf067afaec8f60a36fb763187cba
#6 DONE 0.0s
#7 [stage-1 1/6] FROM docker.io/library/alpine:3.20@sha256:d9e853e87e55526f6b2917df91a2115c36dd7c696a35be12163d44e6e2a4b6bc
#7 DONE 0.0s
#8 [internal] load build context
#8 transferring context: 6.52kB 0.0s done
#8 DONE 0.0s
#9 [builder 4/6] RUN go mod download
#9 CACHED
#10 [builder 3/6] COPY go.mod go.sum ./
#10 CACHED
#11 [stage-1 4/6] WORKDIR /app
#11 CACHED
#12 [builder 5/6] COPY . .
#12 CACHED
#13 [stage-1 3/6] RUN addgroup -g 1001 -S appgroup && adduser -u 1001 -S appuser -G appgroup
#13 CACHED
#14 [stage-1 5/6] COPY --from=builder --chown=appuser:appgroup /out/api /app/api
#14 CACHED
#15 [builder 2/6] WORKDIR /src
#15 CACHED
#16 [builder 6/6] RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -trimpath -o /out/ ./cmd/api ./cmd/reconcile
#16 CACHED
#17 [stage-1 2/6] RUN apk --no-cache add ca-certificates tzdata
#17 CACHED
#18 [stage-1 6/6] COPY --from=builder --chown=appuser:appgroup /out/reconcile /app/reconcile
#18 CACHED
#19 exporting to image
#19 exporting layers done
#19 writing image sha256:be1f1cecb516f3b198bff5b90f6ed74a70e03b3fe35d0737d784f04fa8b66025 done
#19 naming to docker.io/library/mtusi2026lab4-api:local done
#19 DONE 0.0s
#20 resolving provenance for metadata file
#20 DONE 0.0s
api Built
Container mtusi2026lab4-postgres-1 Running
no change
Container mtusi2026lab4-api-1 Running
Container mtusi2026lab4-api-2 Running
Container mtusi2026lab4-api-3 Creating
Container mtusi2026lab4-api-3 Created
Container mtusi2026lab4-api-3 Starting
Container mtusi2026lab4-api-3 Started
replaced /mtusi2026lab4-api-1
Container mtusi2026lab4-api-2 Running
Container mtusi2026lab4-api-3 Running
Container mtusi2026lab4-api-4 Creating
Container mtusi2026lab4-api-4 Created
Container mtusi2026lab4-api-4 Starting
Container mtusi2026lab4-api-4 Started
replaced /mtusi2026lab4-api-2
mtusi2026lab4-api-3 916a2f8f2e08 mtusi2026lab4-api:local Up 23 seconds (healthy)
mtusi2026lab4-api-4 446b3ece9b45 mtusi2026lab4-api:local Up 11 seconds (healthy)
-- замена заняла 29 s (внутри 90 s нагрузки)
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 4,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 90.0,
"elapsed_seconds": 90.071,
"concurrency": 4,
"successful_requests": 34743,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 385.729,
"successful_latency_ms": {
"p50": 9.536,
"p95": 17.293,
"p99": 25.27
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+6
View File
@@ -0,0 +1,6 @@
2
total used free shared buff/cache available
Mem: 7932 1454 2206 90 4676 6478
Swap: 3071 0 3071
28.0.4
Docker Compose version v2.38.2
+1
View File
@@ -0,0 +1 @@
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
+119
View File
@@ -0,0 +1,119 @@
{
"preexisting_rows": 4,
"object_size_bytes": 1024,
"runs": [
{
"bench_pairs": 1000,
"rows_scanned": 1004,
"objects_scanned": 1004,
"duration_ms_runs": [
96,
134,
77
],
"duration_ms_median": 96,
"us_per_pair": 95.6,
"calls": {
"s3_list_pages": 2
},
"heap_alloc_mb": 2.3624496459960938,
"found": {},
"wait_ms_runs": [
{
"db_stream": 0,
"s3_list": 96
},
{
"db_stream": 74,
"s3_list": 59
},
{
"db_stream": 0,
"s3_list": 76
}
],
"seed_seconds": 4.6
},
{
"bench_pairs": 10000,
"rows_scanned": 10004,
"objects_scanned": 10004,
"duration_ms_runs": [
2642,
2959,
2647
],
"duration_ms_median": 2647,
"us_per_pair": 264.6,
"calls": {
"s3_list_pages": 11
},
"heap_alloc_mb": 3.414703369140625,
"found": {},
"wait_ms_runs": [
{
"db_stream": 58,
"s3_list": 2582
},
{
"db_stream": 92,
"s3_list": 2863
},
{
"db_stream": 235,
"s3_list": 2410
}
],
"seed_seconds": 36.3
},
{
"bench_pairs": 30000,
"rows_scanned": 30004,
"objects_scanned": 30004,
"duration_ms_runs": [
11483,
8374,
7803
],
"duration_ms_median": 8374,
"us_per_pair": 279.1,
"calls": {
"s3_list_pages": 31
},
"heap_alloc_mb": 2.1787872314453125,
"found": {},
"wait_ms_runs": [
{
"db_stream": 157,
"s3_list": 11235
},
{
"db_stream": 127,
"s3_list": 8238
},
{
"db_stream": 292,
"s3_list": 7502
}
],
"seed_seconds": 81.8
}
],
"with_1pct_faults": {
"injected_missing": 150,
"injected_orphans": 150,
"duration_ms": 10344,
"found": {
"missing_object": 150
},
"skipped": {
"fresh_missing": 1,
"fresh_object": 151
},
"calls": {
"s3_list_pages": 31,
"s3_stat": 150
}
},
"note": "dry-run, grace 1h: свежие сироты учитываются как skipped.fresh_object, а не удаляются"
}
+327
View File
@@ -0,0 +1,327 @@
{
"injected": {
"orphan_old": 1,
"orphan_fresh": 1,
"deleted_objects": 3,
"resized_object": 1,
"stale_intents": 2,
"inflight_intent": 1
},
"dry_run_found": {
"orphan_object": 1,
"stale_intent": 2,
"missing_object": 3,
"size_mismatch": 1
},
"dry_run_state_changed": false,
"apply_found": {
"orphan_object": 1,
"stale_intent": 2,
"missing_object": 3,
"size_mismatch": 1
},
"second_apply_actions": 0,
"restored": 1,
"after_grace": {
"purge_missing": 2,
"orphan_object": 1
},
"never_deleted": [
"fresh orphan (until grace)",
"in-flight intent",
"referenced quarantined row",
"healthy rows"
],
"reports": {
"dry_run": {
"dry_run": true,
"grace_seconds": 8,
"cutoff": "2026-11-04T17:58:32.353041Z",
"duration_ms": 9,
"rows_scanned": 9,
"objects_scanned": 7,
"consistent": 2,
"found": {
"missing_object": 3,
"orphan_object": 1,
"size_mismatch": 1,
"stale_intent": 2
},
"fixed": {},
"skipped": {
"fresh_intent": 1,
"fresh_object": 1
},
"calls": {
"db_haskey": 1,
"s3_list_pages": 1,
"s3_stat": 3
},
"heap_alloc_mb": 1.617706298828125,
"wait_ms": {
"db_stream": 1,
"s3_list": 4
},
"errors": [],
"items": [
{
"kind": "missing_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/487d3da8-a285-4ce5-9899-6e38a7cd6fe1",
"attachment_id": "487d3da8-a285-4ce5-9899-6e38a7cd6fe1",
"action": "would_quarantine"
},
{
"kind": "missing_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/53cd96c6-d5c3-47ab-a43a-816dda2374a0",
"attachment_id": "53cd96c6-d5c3-47ab-a43a-816dda2374a0",
"action": "would_quarantine"
},
{
"kind": "missing_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/6a0aafce-13bd-4f7b-8c9d-0b69eff7f0bf",
"attachment_id": "6a0aafce-13bd-4f7b-8c9d-0b69eff7f0bf",
"action": "would_quarantine"
},
{
"kind": "size_mismatch",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/8c99927b-f99a-4385-901e-68284f99c598",
"attachment_id": "8c99927b-f99a-4385-901e-68284f99c598",
"action": "would_quarantine",
"detail": "db=21584 s3=777"
},
{
"kind": "orphan_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/a6d04b87-c491-4ed5-81fa-ea96e5d08ee9",
"action": "would_delete_object",
"detail": "size=5000 modified=2026-11-04T17:58:29Z"
},
{
"kind": "stale_intent",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/d0063925-daca-4082-ac3a-a10efd6a1444",
"attachment_id": "d0063925-daca-4082-ac3a-a10efd6a1444",
"action": "would_delete_object_and_intent",
"detail": "updated_at=2026-11-04T17:28:29Z"
},
{
"kind": "stale_intent",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/eb82fd74-7aab-43af-b9a5-4e1f40e78112",
"attachment_id": "eb82fd74-7aab-43af-b9a5-4e1f40e78112",
"action": "would_delete_intent",
"detail": "updated_at=2026-11-04T17:28:29Z"
}
]
},
"apply": {
"dry_run": false,
"grace_seconds": 8,
"cutoff": "2026-11-04T17:58:33.32222Z",
"duration_ms": 21,
"rows_scanned": 9,
"objects_scanned": 7,
"consistent": 2,
"found": {
"missing_object": 3,
"orphan_object": 1,
"size_mismatch": 1,
"stale_intent": 2
},
"fixed": {
"missing_object": 3,
"orphan_object": 1,
"size_mismatch": 1,
"stale_intent": 2
},
"skipped": {
"fresh_intent": 1,
"fresh_object": 1
},
"calls": {
"db_delete": 2,
"db_haskey": 1,
"db_update": 4,
"s3_delete": 2,
"s3_list_pages": 1,
"s3_stat": 3
},
"heap_alloc_mb": 1.6486282348632812,
"wait_ms": {
"db_stream": 2,
"s3_list": 8
},
"errors": [],
"items": [
{
"kind": "missing_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/487d3da8-a285-4ce5-9899-6e38a7cd6fe1",
"attachment_id": "487d3da8-a285-4ce5-9899-6e38a7cd6fe1",
"action": "quarantine"
},
{
"kind": "missing_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/53cd96c6-d5c3-47ab-a43a-816dda2374a0",
"attachment_id": "53cd96c6-d5c3-47ab-a43a-816dda2374a0",
"action": "quarantine"
},
{
"kind": "missing_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/6a0aafce-13bd-4f7b-8c9d-0b69eff7f0bf",
"attachment_id": "6a0aafce-13bd-4f7b-8c9d-0b69eff7f0bf",
"action": "quarantine"
},
{
"kind": "size_mismatch",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/8c99927b-f99a-4385-901e-68284f99c598",
"attachment_id": "8c99927b-f99a-4385-901e-68284f99c598",
"action": "quarantine",
"detail": "db=21584 s3=777"
},
{
"kind": "orphan_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/a6d04b87-c491-4ed5-81fa-ea96e5d08ee9",
"action": "delete_object",
"detail": "size=5000 modified=2026-11-04T17:58:29Z"
},
{
"kind": "stale_intent",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/d0063925-daca-4082-ac3a-a10efd6a1444",
"attachment_id": "d0063925-daca-4082-ac3a-a10efd6a1444",
"action": "delete_object_and_intent",
"detail": "updated_at=2026-11-04T17:28:29Z"
},
{
"kind": "stale_intent",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/eb82fd74-7aab-43af-b9a5-4e1f40e78112",
"attachment_id": "eb82fd74-7aab-43af-b9a5-4e1f40e78112",
"action": "delete_intent",
"detail": "updated_at=2026-11-04T17:28:29Z"
}
]
},
"second_apply": {
"dry_run": false,
"grace_seconds": 8,
"cutoff": "2026-11-04T17:58:34.437947Z",
"duration_ms": 7,
"rows_scanned": 7,
"objects_scanned": 5,
"consistent": 2,
"found": {},
"fixed": {},
"skipped": {
"fresh_intent": 1,
"fresh_missing": 4,
"fresh_object": 1
},
"calls": {
"s3_list_pages": 1
},
"heap_alloc_mb": 1.5324172973632812,
"wait_ms": {
"db_stream": 1,
"s3_list": 5
},
"errors": [],
"items": []
},
"restore": {
"dry_run": false,
"grace_seconds": 8,
"cutoff": "2026-11-04T17:58:35.409159Z",
"duration_ms": 9,
"rows_scanned": 7,
"objects_scanned": 6,
"consistent": 2,
"found": {
"restored": 1
},
"fixed": {
"restored": 1
},
"skipped": {
"fresh_intent": 1,
"fresh_missing": 3,
"fresh_object": 1
},
"calls": {
"db_update": 1,
"s3_list_pages": 1
},
"heap_alloc_mb": 1.5385284423828125,
"wait_ms": {
"db_stream": 2,
"s3_list": 4
},
"errors": [],
"items": [
{
"kind": "restored",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/53cd96c6-d5c3-47ab-a43a-816dda2374a0",
"attachment_id": "53cd96c6-d5c3-47ab-a43a-816dda2374a0",
"action": "set_ready"
}
]
},
"after_grace": {
"dry_run": false,
"grace_seconds": 8,
"cutoff": "2026-11-04T17:58:44.831107Z",
"duration_ms": 15,
"rows_scanned": 7,
"objects_scanned": 6,
"consistent": 3,
"found": {
"orphan_object": 1,
"purge_missing": 2,
"stale_intent": 1
},
"fixed": {
"orphan_object": 1,
"purge_missing": 2,
"stale_intent": 1
},
"skipped": {
"referenced_missing_kept": 1
},
"calls": {
"db_delete": 3,
"db_haskey": 1,
"db_referenced": 3,
"s3_delete": 2,
"s3_list_pages": 1
},
"heap_alloc_mb": 1.608062744140625,
"wait_ms": {
"db_stream": 1,
"s3_list": 5
},
"errors": [],
"items": [
{
"kind": "orphan_object",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/09c263a0-158e-47eb-8695-f5e9317b103a",
"action": "delete_object",
"detail": "size=3000 modified=2026-11-04T17:58:39Z"
},
{
"kind": "purge_missing",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/6a0aafce-13bd-4f7b-8c9d-0b69eff7f0bf",
"attachment_id": "6a0aafce-13bd-4f7b-8c9d-0b69eff7f0bf",
"action": "delete_row"
},
{
"kind": "stale_intent",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/8c948a33-b8e3-4e5c-bfe9-4331b1772d0e",
"attachment_id": "8c948a33-b8e3-4e5c-bfe9-4331b1772d0e",
"action": "delete_object_and_intent",
"detail": "updated_at=2026-11-04T17:58:39Z"
},
{
"kind": "purge_missing",
"key": "a/556b5ec5-fe99-4946-bcdb-7e7ed5e60f06/8c99927b-f99a-4385-901e-68284f99c598",
"attachment_id": "8c99927b-f99a-4385-901e-68284f99c598",
"action": "delete_row"
}
]
}
}
}
+6
View File
@@ -0,0 +1,6 @@
2
total used free shared buff/cache available
Mem: 7932 1628 2851 80 3848 6304
Swap: 3071 58 3013
28.0.4
Docker Compose version v2.38.2
+35
View File
@@ -0,0 +1,35 @@
module github.com/charawein/mtusi2026lab4
go 1.26.0
require (
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.11.0
github.com/redis/go-redis/v9 v9.23.0
golang.org/x/crypto v0.58.0
)
require (
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/klauspost/compress v1.19.2 // indirect
github.com/klauspost/cpuid/v2 v2.4.0 // indirect
github.com/klauspost/crc32 v1.3.0 // indirect
github.com/minio/crc64nvme v1.1.1 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/minio/minio-go/v7 v7.4.1 // indirect
github.com/philhofer/fwd v1.2.0 // indirect
github.com/rs/xid v1.6.0 // indirect
github.com/tinylib/msgp v1.6.4 // indirect
github.com/zeebo/xxh3 v1.1.0 // indirect
go.uber.org/atomic v1.12.0 // indirect
go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/net v0.60.0 // indirect
golang.org/x/sync v0.24.0 // indirect
golang.org/x/sys v0.49.0 // indirect
golang.org/x/text v0.43.0 // indirect
gopkg.in/ini.v1 v1.67.3 // indirect
)
+75
View File
@@ -0,0 +1,75 @@
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg=
github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/klauspost/compress v1.19.2 h1:hMRETovs/pu/dVWN7zIT1PGG8t509MwT6bO7XSi26R8=
github.com/klauspost/compress v1.19.2/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
github.com/klauspost/crc32 v1.3.0 h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM=
github.com/klauspost/crc32 v1.3.0/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw=
github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI=
github.com/minio/crc64nvme v1.1.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg=
github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
github.com/minio/minio-go/v7 v7.4.1 h1:PtU/zIOfQRWZ+QydXAZysc+xZYHdG+BBR4Z6TUvy73w=
github.com/minio/minio-go/v7 v7.4.1/go.mod h1:nQnQi7zTfXR4lREtYXZQWqo5aw0Rqv+ZqCGrTORygRk=
github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM=
github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s=
github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0=
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
github.com/tinylib/msgp v1.6.4 h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ=
github.com/tinylib/msgp v1.6.4/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA=
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE=
go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk=
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
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.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/ini.v1 v1.67.3 h1:iM9Lhz5MRSGhHVGGwCuzG9KO8PoirCXj/m/qTmOJJQw=
gopkg.in/ini.v1 v1.67.3/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+59
View File
@@ -0,0 +1,59 @@
# HAProxy — единственная публичная точка входа (lab3).
# Backend-адреса берутся из встроенного DNS Docker (service name "api"),
# поэтому масштабирование/пересоздание реплик не требует перезапуска LB.
global
log stdout format raw local0 info
maxconn 2048
defaults
mode http
log global
option httplog
option dontlognull
timeout connect 2s
timeout client 30s
timeout server 15s
timeout http-request 10s
timeout queue 5s
# Повтор только при ошибке установки соединения (запрос ещё не отправлен),
# поэтому неидемпотентные POST /users, /chats не дублируются.
retries 2
retry-on conn-failure
option redispatch 1
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
# Как долго держать последний ответ DNS при ошибке/пропаже записи.
hold valid 5s
hold other 5s
hold refused 5s
hold nx 2s
hold timeout 5s
hold obsolete 2s
accepted_payload_size 8192
frontend public
bind :8080
default_backend api
backend api
# roundrobin по умолчанию; leastconn — вариант для эксперимента трека 1 (env LB_BALANCE).
balance "${LB_BALANCE}"
# Активная проверка готовности: 503 во время drain или без БД/Redis.
option httpchk
http-check send meth GET uri /health/ready
http-check expect status 200
# Период проверки 1s, исключение после 2 неудач (~2s), возврат после 2 успехов.
default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none
# До 8 слотов под реплики сервиса api; лишние слоты остаются в MAINT.
server-template api 8 api:8080
frontend stats
bind :8404
stats enable
stats uri /stats
stats refresh 2s
+35
View File
@@ -0,0 +1,35 @@
#!/bin/sh
# Идемпотентный bootstrap MinIO: повторный запуск ничего не ломает и не стирает данные.
# 1. приватный bucket (anonymous access: none);
# 2. политика messenger-api: только Get/Put/Delete объектов и List этого bucket;
# 3. отдельный пользователь API с этой политикой (root-ключ API не получает).
# Секреты читаются из /run/secrets и не печатаются.
set -eu
: "${S3_BUCKET:?}"
ROOT_USER=$(cat /run/secrets/s3_root_user)
ROOT_PASS=$(cat /run/secrets/s3_root_password)
API_KEY=$(cat /run/secrets/s3_access_key_id)
API_SECRET=$(cat /run/secrets/s3_secret_access_key)
mc alias set local http://s3:9000 "$ROOT_USER" "$ROOT_PASS" >/dev/null
mc mb --ignore-existing "local/$S3_BUCKET"
mc anonymous set none "local/$S3_BUCKET" >/dev/null
cat > /tmp/messenger-api.json <<EOF
{
"Version": "2012-10-17",
"Statement": [
{"Effect": "Allow", "Action": ["s3:GetBucketLocation", "s3:ListBucket"],
"Resource": ["arn:aws:s3:::$S3_BUCKET"]},
{"Effect": "Allow", "Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
"Resource": ["arn:aws:s3:::$S3_BUCKET/*"]}
]
}
EOF
mc admin policy create local messenger-api /tmp/messenger-api.json >/dev/null
# user add для существующего пользователя обновляет секрет — повтор безопасен.
mc admin user add local "$API_KEY" "$API_SECRET" >/dev/null
if ! mc admin policy entities local --user "$API_KEY" 2>/dev/null | grep -q messenger-api; then
mc admin policy attach local messenger-api --user "$API_KEY" >/dev/null
fi
echo "s3 bootstrap ok: bucket=$S3_BUCKET private, api user with messenger-api policy"
+127
View File
@@ -0,0 +1,127 @@
package config
import (
"log/slog"
"os"
"strconv"
"strings"
"time"
)
type Config struct {
Host string
Port string
Env string
SessionTTLSeconds int
DatabaseURL string
CacheURL string
SessionStore string
LogLevel slog.Level
ShutdownTimeout time.Duration
CacheEnabled bool
InstanceID string
IdempotencyTTL time.Duration
DrainDelay time.Duration
DBPoolMax int32
CacheInvalidation string
InternalAddr string
S3Endpoint string
S3Region string
S3Bucket string
S3AccessKey string
S3SecretKey string
MaxUploadBytes int64
MaxImagePixels int64
}
func Load() Config {
return Config{
Host: getEnv("APP_HOST", "0.0.0.0"),
Port: getEnv("APP_PORT", "8080"),
Env: getEnv("APP_ENV", "lab"),
SessionTTLSeconds: getInt("SESSION_TTL_SECONDS", 3600),
DatabaseURL: readSecretFile("DATABASE_URL_FILE"),
CacheURL: readSecretFile("CACHE_URL_FILE"),
SessionStore: getEnv("SESSION_STORE", "postgres"),
LogLevel: parseLevel(getEnv("LOG_LEVEL", "info")),
ShutdownTimeout: parseDuration(getEnv("SHUTDOWN_TIMEOUT", "8s")),
CacheEnabled: getEnv("CACHE_ENABLED", "true") == "true",
InstanceID: instanceID(),
IdempotencyTTL: time.Duration(getInt("IDEMPOTENCY_TTL_SECONDS", 86400)) * time.Second,
DrainDelay: parseDuration(getEnv("DRAIN_DELAY", "3s")),
DBPoolMax: int32(max(1, getInt("DB_POOL_MAX", 20))),
CacheInvalidation: getEnv("CACHE_INVALIDATION", "version"),
InternalAddr: getEnv("INTERNAL_ADDR", ":9090"),
S3Endpoint: getEnv("S3_ENDPOINT", "http://s3:9000"),
S3Region: getEnv("S3_REGION", "us-east-1"),
S3Bucket: getEnv("S3_BUCKET", "messenger-attachments"),
S3AccessKey: readSecretFile("S3_ACCESS_KEY_ID_FILE"),
S3SecretKey: readSecretFile("S3_SECRET_ACCESS_KEY_FILE"),
MaxUploadBytes: int64(getInt("MAX_UPLOAD_BYTES", 10*1024*1024)),
MaxImagePixels: int64(getInt("MAX_IMAGE_PIXELS", 40_000_000)),
}
}
// instanceID — идентификатор реплики для X-Instance-Id. По умолчанию hostname,
// который в Docker равен короткому ID контейнера: так stop-one.sh однозначно
// находит контейнер. В lab7 его заменит непрозрачный alias.
func instanceID() string {
if v := os.Getenv("INSTANCE_ID"); v != "" {
return v
}
if h, err := os.Hostname(); err == nil && h != "" {
return h
}
return "unknown"
}
func (c Config) SessionTTL() time.Duration {
return time.Duration(c.SessionTTLSeconds) * time.Second
}
func (c Config) Addr() string { return c.Host + ":" + c.Port }
func getEnv(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
func getInt(key string, def int) int {
if v := os.Getenv(key); v != "" {
if n, err := strconv.Atoi(v); err == nil {
return n
}
}
return def
}
func readSecretFile(envKey string) string {
path := os.Getenv(envKey)
if path == "" {
return ""
}
b, err := os.ReadFile(path)
if err != nil {
slog.Warn("secret file not readable", "path", path, "err", err)
return ""
}
return strings.TrimSpace(string(b))
}
func parseLevel(s string) slog.Level {
var l slog.Level
if err := l.UnmarshalText([]byte(s)); err != nil {
return slog.LevelInfo
}
return l
}
func parseDuration(s string) time.Duration {
d, err := time.ParseDuration(s)
if err != nil {
return 8 * time.Second
}
return d
}
+51
View File
@@ -0,0 +1,51 @@
package domain
import (
"encoding/json"
"time"
)
const (
AttachmentUploading = "uploading"
AttachmentReady = "ready"
AttachmentMissing = "missing"
)
// Attachment — метаданные вложения. ObjectKey никогда не уходит клиенту.
type Attachment struct {
ID string
ChatID string
OwnerID string
Filename string
ObjectKey string
Status string
ContentType string
SizeBytes int64
SHA256 string
CreatedAt time.Time
UpdatedAt time.Time
}
// MarshalJSON — представление по контракту lab4: только ready, вариантов нет.
func (a Attachment) MarshalJSON() ([]byte, error) {
return json.Marshal(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 []string `json:"variants"`
ErrorCode *string `json:"error_code"`
CreatedAt string `json:"created_at"`
UpdatedAt string `json:"updated_at"`
}{
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: []string{}, ErrorCode: nil,
CreatedAt: a.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339),
UpdatedAt: a.UpdatedAt.UTC().Truncate(time.Second).Format(time.RFC3339),
})
}
+30
View File
@@ -0,0 +1,30 @@
package domain
import (
"encoding/json"
"time"
)
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt time.Time `json:"created_at"`
}
func (c Chat) MarshalJSON() ([]byte, error) {
type Alias Chat
members := c.MemberIDs
if members == nil {
members = []string{}
}
return json.Marshal(&struct {
Alias
MemberIDs []string `json:"member_ids"`
CreatedAt string `json:"created_at"`
}{
Alias: Alias(c),
MemberIDs: members,
CreatedAt: c.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339),
})
}
+30
View File
@@ -0,0 +1,30 @@
package domain
import (
"encoding/json"
"time"
)
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt time.Time `json:"created_at"`
// AttachmentIDs — в порядке отправки; всегда массив (пустой, если вложений нет).
AttachmentIDs []string `json:"attachment_ids"`
}
func (m Message) MarshalJSON() ([]byte, error) {
type Alias Message
if m.AttachmentIDs == nil {
m.AttachmentIDs = []string{}
}
return json.Marshal(&struct {
Alias
CreatedAt string `json:"created_at"`
}{
Alias: Alias(m),
CreatedAt: m.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339),
})
}
+10
View File
@@ -0,0 +1,10 @@
package domain
import "time"
type Session struct {
Token string `json:"token"`
UserID string `json:"-"`
ExpiresAt time.Time `json:"expires_at"`
CreatedAt time.Time `json:"-"`
}
+25
View File
@@ -0,0 +1,25 @@
package domain
import (
"encoding/json"
"time"
)
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt time.Time `json:"created_at"`
}
// MarshalJSON форматирует CreatedAt в RFC3339 без микросекунд.
func (u User) MarshalJSON() ([]byte, error) {
type Alias User
return json.Marshal(&struct {
Alias
CreatedAt string `json:"created_at"`
}{
Alias: Alias(u),
CreatedAt: u.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339),
})
}
+590
View File
@@ -0,0 +1,590 @@
// Package imagecheck потоково проверяет PNG/JPEG без декодирования пикселей.
//
// Проверка идёт по мере чтения (используется параллельно с PUT в S3), память
// O(1) от размера изображения: размеры берутся из заголовка (IHDR/SOF) и
// сравниваются с лимитом до чтения тела; PNG — CRC каждого chunk, длина
// распакованного IDAT-потока (zlib → io.Discard) и байт фильтра каждой строки,
// JPEG — структура сегментов и маркер EOI. «Заведомо повреждённые» файлы
// (обрыв, битый CRC, мусор вместо данных, чужой формат) дают ErrInvalid,
// слишком большие по пикселям — ErrTooLarge.
package imagecheck
import (
"bufio"
"bytes"
"compress/zlib"
"encoding/binary"
"errors"
"fmt"
"hash/crc32"
"io"
)
const (
PNG = "image/png"
JPEG = "image/jpeg"
)
var (
ErrInvalid = errors.New("invalid or unsupported image")
ErrTooLarge = errors.New("image dimensions exceed limit")
)
var pngSignature = []byte("\x89PNG\r\n\x1a\n")
// Sniff определяет формат по первым байтам (не по заголовку Content-Type клиента).
func Sniff(head []byte) (string, bool) {
switch {
case bytes.HasPrefix(head, pngSignature):
return PNG, true
case len(head) >= 3 && head[0] == 0xFF && head[1] == 0xD8 && head[2] == 0xFF:
return JPEG, true
}
return "", false
}
// Result — что удалось узнать при проверке.
type Result struct {
Format string
Width int
Height int
}
// Validate читает r до конца и проверяет изображение формата format.
// maxPixels ограничивает width*height. Хвост после конца изображения
// дочитывается и игнорируется, чтобы не блокировать писателя.
func Validate(r io.Reader, format string, maxPixels int64) (Result, error) {
br := bufio.NewReaderSize(r, 32*1024)
var res Result
var err error
switch format {
case PNG:
res, err = validatePNG(br, maxPixels)
case JPEG:
res, err = validateJPEG(br, maxPixels)
default:
return Result{}, ErrInvalid
}
if err != nil {
return res, err
}
_, _ = io.Copy(io.Discard, br)
return res, nil
}
func invalid(format string, args ...any) error {
return fmt.Errorf("%w: %s", ErrInvalid, fmt.Sprintf(format, args...))
}
// --- PNG ---
func channels(colorType byte) (int, bool) {
switch colorType {
case 0:
return 1, true // grayscale
case 2:
return 3, true // RGB
case 3:
return 1, true // palette
case 4:
return 2, true // gray + alpha
case 6:
return 4, true // RGBA
}
return 0, false
}
func validBitDepth(colorType, depth byte) bool {
switch colorType {
case 0:
return depth == 1 || depth == 2 || depth == 4 || depth == 8 || depth == 16
case 3:
return depth == 1 || depth == 2 || depth == 4 || depth == 8
case 2, 4, 6:
return depth == 8 || depth == 16
}
return false
}
// pngRowLen — длина одной отсканированной строки прохода: 1 байт фильтра +
// данные пикселей.
func pngRowLen(pw, bitsPerPixel int64) int64 {
return 1 + (pw*bitsPerPixel+7)/8
}
// expectedRaw — длина распакованного потока IDAT: строки с байтом фильтра.
func expectedRaw(w, h int64, bitsPerPixel int64, interlaced bool) int64 {
if !interlaced {
return h * pngRowLen(w, bitsPerPixel)
}
passes := [7][4]int64{{0, 0, 8, 8}, {4, 0, 8, 8}, {0, 4, 4, 8}, {2, 0, 4, 4}, {0, 2, 2, 4}, {1, 0, 2, 2}, {0, 1, 1, 2}}
var total int64
for _, p := range passes {
if w <= p[0] || h <= p[1] {
continue
}
pw := (w - p[0] + p[2] - 1) / p[2]
ph := (h - p[1] + p[3] - 1) / p[3]
total += ph * pngRowLen(pw, bitsPerPixel)
}
return total
}
// pngRows — итератор по (pw, ph) проходов Adam7 или единственного прохода.
// Используется, чтобы валидировать байт фильтра каждой строки, не зная
// заранее, как разбивается распакованный поток на проходы.
type pngPass struct {
pw, ph int64
}
func pngPasses(w, h int64, interlaced bool) []pngPass {
if !interlaced {
return []pngPass{{w, h}}
}
coords := [7][4]int64{{0, 0, 8, 8}, {4, 0, 8, 8}, {0, 4, 4, 8}, {2, 0, 4, 4}, {0, 2, 2, 4}, {1, 0, 2, 2}, {0, 1, 1, 2}}
out := make([]pngPass, 0, len(coords))
for _, p := range coords {
if w <= p[0] || h <= p[1] {
continue
}
pw := (w - p[0] + p[2] - 1) / p[2]
ph := (h - p[1] + p[3] - 1) / p[3]
out = append(out, pngPass{pw, ph})
}
return out
}
type pngChunk struct {
length uint32
typ [4]byte
}
func readChunkHeader(br *bufio.Reader) (pngChunk, error) {
var hdr [8]byte
if _, err := io.ReadFull(br, hdr[:]); err != nil {
return pngChunk{}, invalid("truncated chunk header")
}
c := pngChunk{length: binary.BigEndian.Uint32(hdr[:4])}
copy(c.typ[:], hdr[4:])
if c.length > 1<<31-1 {
return c, invalid("chunk too long")
}
for _, b := range c.typ {
if !((b >= 'A' && b <= 'Z') || (b >= 'a' && b <= 'z')) {
return c, invalid("bad chunk type")
}
}
return c, nil
}
// readChunkData читает тело chunk в dst (если не nil) и проверяет CRC.
func readChunkData(br *bufio.Reader, c pngChunk, dst io.Writer) error {
h := crc32.NewIEEE()
h.Write(c.typ[:])
w := io.Writer(h)
if dst != nil {
w = io.MultiWriter(h, dst)
}
if _, err := io.CopyN(w, br, int64(c.length)); err != nil {
return invalid("truncated %s chunk", c.typ[:])
}
var crc [4]byte
if _, err := io.ReadFull(br, crc[:]); err != nil {
return invalid("truncated CRC")
}
if binary.BigEndian.Uint32(crc[:]) != h.Sum32() {
return invalid("CRC mismatch in %s", c.typ[:])
}
return nil
}
// idatStream отдаёт данные подряд идущих IDAT-chunk как один поток.
type idatStream struct {
br *bufio.Reader
remaining uint32
crc uint32
next *pngChunk // первый chunk после последнего IDAT
err error
}
func (s *idatStream) Read(p []byte) (int, error) {
for s.remaining == 0 {
if s.err != nil || s.next != nil {
if s.err != nil {
return 0, s.err
}
return 0, io.EOF
}
if err := s.finishChunk(); err != nil {
s.err = err
return 0, err
}
c, err := readChunkHeader(s.br)
if err != nil {
s.err = err
return 0, err
}
if string(c.typ[:]) != "IDAT" {
s.next = &c
return 0, io.EOF
}
s.startChunk(c)
}
if uint32(len(p)) > s.remaining {
p = p[:s.remaining]
}
n, err := s.br.Read(p)
s.crc = crc32.Update(s.crc, crc32.IEEETable, p[:n])
s.remaining -= uint32(n)
if err != nil && err != io.EOF {
s.err = err
return n, err
}
if n == 0 && err == io.EOF {
s.err = invalid("truncated IDAT")
return 0, s.err
}
return n, nil
}
func (s *idatStream) startChunk(c pngChunk) {
s.remaining = c.length
s.crc = crc32.Update(0, crc32.IEEETable, c.typ[:])
}
func (s *idatStream) finishChunk() error {
var crc [4]byte
if _, err := io.ReadFull(s.br, crc[:]); err != nil {
return invalid("truncated CRC")
}
if binary.BigEndian.Uint32(crc[:]) != s.crc {
return invalid("CRC mismatch in IDAT")
}
return nil
}
// validatePNGStream проверяет распакованный поток: длину, кратность строкам
// и байты фильтра (0..4) в начале каждой строки каждого прохода.
func validatePNGStream(zr io.Reader, passes []pngPass, bitsPerPixel, want int64) error {
total := int64(0)
buf := make([]byte, 32*1024)
for _, pass := range passes {
rowLen := pngRowLen(pass.pw, bitsPerPixel)
for y := int64(0); y < pass.ph; y++ {
// читаем ровно одну строку, но чанками, чтобы не аллоцировать
// rowLen (может быть большой для широких изображений)
left := rowLen
first := true
for left > 0 {
chunk := int64(len(buf))
if left < chunk {
chunk = left
}
n, err := io.ReadFull(zr, buf[:chunk])
if err != nil {
if errors.Is(err, io.ErrUnexpectedEOF) || errors.Is(err, io.EOF) {
return invalid("truncated IDAT (got %d of %d)", total, want)
}
return invalid("corrupt image data")
}
if first {
if buf[0] > 4 {
return invalid("bad row filter %d", buf[0])
}
first = false
}
total += int64(n)
left -= int64(n)
}
}
}
// Проверяем, что распакованный поток ровно want байт (ни больше, ни меньше).
var extra [1]byte
n, err := zr.Read(extra[:])
if n != 0 {
return invalid("image data longer than expected")
}
if err != nil && !errors.Is(err, io.EOF) {
return invalid("corrupt image data")
}
if total != want {
return invalid("image data length %d, want %d", total, want)
}
return nil
}
func validatePNG(br *bufio.Reader, maxPixels int64) (Result, error) {
res := Result{Format: PNG}
sig := make([]byte, 8)
if _, err := io.ReadFull(br, sig); err != nil || !bytes.Equal(sig, pngSignature) {
return res, invalid("not a PNG")
}
c, err := readChunkHeader(br)
if err != nil {
return res, err
}
if string(c.typ[:]) != "IHDR" || c.length != 13 {
return res, invalid("IHDR must be first")
}
var ihdr bytes.Buffer
if err := readChunkData(br, c, &ihdr); err != nil {
return res, err
}
b := ihdr.Bytes()
w := int64(binary.BigEndian.Uint32(b[0:4]))
h := int64(binary.BigEndian.Uint32(b[4:8]))
depth, colorType, compression, filter, interlace := b[8], b[9], b[10], b[11], b[12]
res.Width, res.Height = int(w), int(h)
if w < 1 || h < 1 || w > 1<<31-1 || h > 1<<31-1 {
return res, invalid("bad dimensions")
}
// Лимит пикселей — до чтения и распаковки данных изображения.
if w*h > maxPixels {
return res, ErrTooLarge
}
ch, ok := channels(colorType)
if !ok || !validBitDepth(colorType, depth) || compression != 0 || filter != 0 || interlace > 1 {
return res, invalid("unsupported IHDR")
}
bpp := int64(ch) * int64(depth)
want := expectedRaw(w, h, bpp, interlace == 1)
passes := pngPasses(w, h, interlace == 1)
sawIDAT := false
for {
c, err := readChunkHeader(br)
if err != nil {
return res, err
}
switch string(c.typ[:]) {
case "IDAT":
if sawIDAT {
return res, invalid("non-consecutive IDAT")
}
sawIDAT = true
s := &idatStream{br: br}
s.startChunk(c)
zr, err := zlib.NewReader(s)
if err != nil {
return res, invalid("bad zlib header")
}
// Распаковка и проверка фильтров строк — без хранения пикселей.
if err := validatePNGStream(zr, passes, bpp, want); err != nil {
// Закрываем zlib, чтобы дочитать хвост CRC в idatStream, но
// игнорируем ошибку закрытия: она не важна для результата.
_ = zr.Close()
return res, err
}
if err := zr.Close(); err != nil && !errors.Is(err, io.EOF) {
return res, invalid("bad zlib trailer")
}
// Остаток IDAT (например, пустые chunk) дочитываем с проверкой CRC.
if _, err := io.Copy(io.Discard, s); err != nil {
return res, err
}
if s.next == nil {
return res, invalid("missing IEND")
}
c = *s.next
if string(c.typ[:]) == "IEND" {
if err := readChunkData(br, c, nil); err != nil {
return res, err
}
return res, nil
}
if err := readChunkData(br, c, nil); err != nil {
return res, err
}
case "IEND":
if !sawIDAT {
return res, invalid("no image data")
}
if err := readChunkData(br, c, nil); err != nil {
return res, err
}
return res, nil
case "IHDR":
return res, invalid("duplicate IHDR")
default:
if err := readChunkData(br, c, nil); err != nil {
return res, err
}
}
}
}
// --- JPEG ---
func isSOF(m byte) bool {
switch m {
case 0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF:
return true
}
return false
}
// readMarker читает 0xFF (с заполнителями) и код маркера.
func readMarker(br *bufio.Reader) (byte, error) {
b, err := br.ReadByte()
if err != nil {
return 0, invalid("truncated JPEG")
}
if b != 0xFF {
return 0, invalid("expected JPEG marker")
}
for b == 0xFF {
if b, err = br.ReadByte(); err != nil {
return 0, invalid("truncated JPEG")
}
}
return b, nil
}
func segmentLength(br *bufio.Reader) (int, error) {
var l [2]byte
if _, err := io.ReadFull(br, l[:]); err != nil {
return 0, invalid("truncated JPEG segment")
}
n := int(binary.BigEndian.Uint16(l[:]))
if n < 2 {
return 0, invalid("bad JPEG segment length")
}
return n - 2, nil
}
// skipEntropy пропускает сжатые данные скана и возвращает следующий маркер.
func skipEntropy(br *bufio.Reader) (byte, error) {
for {
b, err := br.ReadByte()
if err != nil {
return 0, invalid("truncated JPEG scan")
}
if b != 0xFF {
continue
}
for b == 0xFF {
if b, err = br.ReadByte(); err != nil {
return 0, invalid("truncated JPEG scan")
}
}
if b == 0x00 || (b >= 0xD0 && b <= 0xD7) {
continue // байт-заполнитель или RSTn внутри скана
}
return b, nil
}
}
// readSOF читает сегмент SOF и проверяет его структуру: Nf компонент и ровно
// 3 байта на компоненту. Возвращает (width, height, ok).
func readSOF(br *bufio.Reader, n int) (int64, int64, error) {
if n < 6 {
return 0, 0, invalid("short SOF")
}
hdr := make([]byte, 5)
if _, err := io.ReadFull(br, hdr); err != nil {
return 0, 0, invalid("truncated SOF")
}
nf := int(hdr[0])
h := int64(binary.BigEndian.Uint16(hdr[1:3]))
w := int64(binary.BigEndian.Uint16(hdr[3:5]))
if nf == 0 {
return 0, 0, invalid("SOF without components")
}
if n != 5+3*nf {
return 0, 0, invalid("SOF length %d, want %d", n, 5+3*nf)
}
if _, err := br.Discard(3 * nf); err != nil {
return 0, 0, invalid("truncated SOF")
}
return w, h, nil
}
func validateJPEG(br *bufio.Reader, maxPixels int64) (Result, error) {
res := Result{Format: JPEG}
var soi [2]byte
if _, err := io.ReadFull(br, soi[:]); err != nil || soi != [2]byte{0xFF, 0xD8} {
return res, invalid("not a JPEG")
}
sawSOF, sawSOS := false, false
marker, err := readMarker(br)
if err != nil {
return res, err
}
for {
switch {
case marker == 0xD9: // EOI
if !sawSOF || !sawSOS {
return res, invalid("JPEG without frame or scan")
}
return res, nil
case marker == 0xD8:
return res, invalid("unexpected SOI")
case marker == 0x01 || (marker >= 0xD0 && marker <= 0xD7):
// маркеры без длины
case isSOF(marker):
n, err := segmentLength(br)
if err != nil {
return res, err
}
if sawSOF {
// читаем сегмент, но так и так вернём ошибку
_, _, _ = readSOF(br, n)
return res, invalid("multiple frames")
}
w, h, err := readSOF(br, n)
if err != nil {
return res, err
}
res.Width, res.Height = int(w), int(h)
if w < 1 || h < 1 {
return res, invalid("bad JPEG dimensions")
}
if w*h > maxPixels {
return res, ErrTooLarge
}
sawSOF = true
case marker == 0xDA: // SOS
if !sawSOF {
return res, invalid("scan before frame")
}
n, err := segmentLength(br)
if err != nil {
return res, err
}
// SOS: Ns + Ss + Se + Ah/Al + 2*Ns = 1 + 3 + 2*Ns = 4 + 2*Ns
if n < 4 {
return res, invalid("short SOS")
}
nsBuf := make([]byte, 1)
if _, err := io.ReadFull(br, nsBuf); err != nil {
return res, invalid("truncated SOS")
}
ns := int(nsBuf[0])
if ns < 1 {
return res, invalid("SOS without components")
}
if n != 4+2*ns {
return res, invalid("SOS length %d, want %d", n, 4+2*ns)
}
if _, err := br.Discard(n - 1); err != nil {
return res, invalid("truncated SOS")
}
sawSOS = true
if marker, err = skipEntropy(br); err != nil {
return res, err
}
continue
default:
n, err := segmentLength(br)
if err != nil {
return res, err
}
if _, err := br.Discard(n); err != nil {
return res, invalid("truncated JPEG segment")
}
}
if marker, err = readMarker(br); err != nil {
return res, err
}
}
}
+168
View File
@@ -0,0 +1,168 @@
package imagecheck
import (
"bytes"
"compress/zlib"
"encoding/binary"
"errors"
"hash/crc32"
"image"
"image/color"
"image/jpeg"
"image/png"
"os"
"testing"
)
const limit = 40_000_000
func testImage(w, h int) *image.RGBA {
img := image.NewRGBA(image.Rect(0, 0, w, h))
for y := 0; y < h; y++ {
for x := 0; x < w; x++ {
img.Set(x, y, color.RGBA{uint8(x * 7), uint8(y * 3), uint8(x ^ y), 255})
}
}
return img
}
func encodePNG(t *testing.T, w, h int) []byte {
var b bytes.Buffer
if err := png.Encode(&b, testImage(w, h)); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
func encodeJPEG(t *testing.T, w, h int, progressive bool) []byte {
var b bytes.Buffer
if err := jpeg.Encode(&b, testImage(w, h), &jpeg.Options{Quality: 80}); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
func chunk(typ string, data []byte) []byte {
var b bytes.Buffer
binary.Write(&b, binary.BigEndian, uint32(len(data)))
b.WriteString(typ)
b.Write(data)
crc := crc32.NewIEEE()
crc.Write([]byte(typ))
crc.Write(data)
binary.Write(&b, binary.BigEndian, crc.Sum32())
return b.Bytes()
}
// craftPNG собирает PNG вручную: так можно задать любые IHDR и поток данных.
func craftPNG(w, h uint32, colorType, depth, interlace byte, raw []byte) []byte {
var b bytes.Buffer
b.Write(pngSignature)
ihdr := make([]byte, 13)
binary.BigEndian.PutUint32(ihdr[0:], w)
binary.BigEndian.PutUint32(ihdr[4:], h)
ihdr[8], ihdr[9], ihdr[12] = depth, colorType, interlace
b.Write(chunk("IHDR", ihdr))
var z bytes.Buffer
zw := zlib.NewWriter(&z)
zw.Write(raw)
zw.Close()
b.Write(chunk("IDAT", z.Bytes()))
b.Write(chunk("IEND", nil))
return b.Bytes()
}
func check(t *testing.T, name string, data []byte, format string, want error) {
t.Helper()
_, err := Validate(bytes.NewReader(data), format, limit)
if want == nil && err != nil {
t.Errorf("%s: unexpected error %v", name, err)
}
if want != nil && !errors.Is(err, want) {
t.Errorf("%s: got %v, want %v", name, err, want)
}
}
func TestValidPNGAndJPEG(t *testing.T) {
p := encodePNG(t, 320, 200)
res, err := Validate(bytes.NewReader(p), PNG, limit)
if err != nil || res.Width != 320 || res.Height != 200 {
t.Fatalf("png: %+v %v", res, err)
}
j := encodeJPEG(t, 321, 199, false)
res, err = Validate(bytes.NewReader(j), JPEG, limit)
if err != nil || res.Width != 321 || res.Height != 199 {
t.Fatalf("jpeg: %+v %v", res, err)
}
check(t, "png with trailing bytes", append(p, []byte("trailer")...), PNG, nil)
}
func TestCourseFixture(t *testing.T) {
data, err := os.ReadFile("../../tests/fixtures/sample.png")
if err != nil {
t.Skip("fixture not found")
}
res, err := Validate(bytes.NewReader(data), PNG, limit)
if err != nil || res.Width != 320 || res.Height != 200 {
t.Fatalf("fixture: %+v %v", res, err)
}
}
func TestInterlacedPNG(t *testing.T) {
// 10×7 RGB, Adam7: длина сырых данных по семи проходам.
w, h := int64(10), int64(7)
raw := make([]byte, expectedRaw(w, h, 24, true))
check(t, "interlaced", craftPNG(uint32(w), uint32(h), 2, 8, 1, raw), PNG, nil)
check(t, "interlaced short data", craftPNG(uint32(w), uint32(h), 2, 8, 1, raw[:len(raw)-1]), PNG, ErrInvalid)
}
func TestBrokenImages(t *testing.T) {
p := encodePNG(t, 64, 64)
j := encodeJPEG(t, 64, 64, false)
check(t, "png truncated", p[:len(p)/2], PNG, ErrInvalid)
check(t, "png without IEND", p[:len(p)-12], PNG, ErrInvalid)
bad := bytes.Clone(p)
bad[len(bad)/2] ^= 0xFF
check(t, "png corrupted byte", bad, PNG, ErrInvalid)
check(t, "jpeg truncated", j[:len(j)/2], JPEG, ErrInvalid)
check(t, "jpeg without EOI", j[:len(j)-2], JPEG, ErrInvalid)
check(t, "png declared as jpeg", p, JPEG, ErrInvalid)
check(t, "text as png", []byte("hello, not an image at all"), PNG, ErrInvalid)
check(t, "empty", nil, PNG, ErrInvalid)
check(t, "png short raw data", craftPNG(8, 8, 2, 8, 0, make([]byte, 8*(1+24)-1)), PNG, ErrInvalid)
check(t, "png bad bit depth", craftPNG(8, 8, 2, 4, 0, make([]byte, 8*(1+12))), PNG, ErrInvalid)
}
func TestPixelLimitBeforeData(t *testing.T) {
// «Бомба»: IHDR на 100000×100000, данных почти нет. Должно быть ErrTooLarge,
// а не попытка распаковать 30 ГБ.
bomb := craftPNG(100000, 100000, 2, 8, 0, []byte{0})
check(t, "png bomb", bomb, PNG, ErrTooLarge)
// Ровно на границе лимита — допустимо по пикселям (данных не хватает → invalid).
check(t, "png at limit", craftPNG(8000, 5000, 0, 1, 0, nil), PNG, ErrInvalid)
check(t, "png over limit", craftPNG(8000, 5001, 0, 1, 0, nil), PNG, ErrTooLarge)
// JPEG: подменяем размеры в SOF0 на 60000×60000.
j := encodeJPEG(t, 16, 16, false)
i := bytes.Index(j, []byte{0xFF, 0xC0})
if i < 0 {
t.Fatal("no SOF0")
}
big := bytes.Clone(j)
binary.BigEndian.PutUint16(big[i+5:], 60000)
binary.BigEndian.PutUint16(big[i+7:], 60000)
check(t, "jpeg bomb", big, JPEG, ErrTooLarge)
}
func TestSniff(t *testing.T) {
if f, ok := Sniff(encodePNG(t, 2, 2)); !ok || f != PNG {
t.Error("png sniff")
}
if f, ok := Sniff(encodeJPEG(t, 2, 2, false)); !ok || f != JPEG {
t.Error("jpeg sniff")
}
if _, ok := Sniff([]byte("GIF89a")); ok {
t.Error("gif must not be accepted")
}
}
+381
View File
@@ -0,0 +1,381 @@
// Package reconcile сверяет метаданные вложений (PostgreSQL) и объекты (S3).
//
// Обход — один merge-проход по двум потокам, отсортированным одинаково
// (object_key COLLATE "C" и лексикографический листинг S3), поэтому память
// O(1) от числа вложений, а стоимость — O(N) строк + ceil(N/1000) LIST-запросов.
//
// Расхождения и безопасные действия:
//
// stale_intent строка uploading старше grace (брошенная загрузка) → удалить объект, затем строку
// orphan_object объект без строки, старше grace → удалить объект (после перепроверки строки)
// missing_object строка ready без объекта → карантин: status=missing (после перепроверки Stat)
// size_mismatch строка ready, размер объекта другой → карантин: status=missing
// restored строка missing, объект снова есть и размер совпадает → status=ready
// purge_missing строка missing старше grace, ни одно сообщение не ссылается → удалить строку
//
// Свежие объекты и намерения (моложе grace) и вложения, на которые ссылаются
// сообщения, не удаляются никогда. Режим по умолчанию — dry-run (только отчёт).
package reconcile
import (
"context"
"errors"
"fmt"
"runtime"
"time"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/storage"
)
// Repo — нужные reconciler операции над метаданными.
type Repo interface {
StreamByKey(ctx context.Context, prefix string, fn func(*domain.Attachment) error) error
HasKey(ctx context.Context, key string) (bool, error)
DeleteStaleIntent(ctx context.Context, id string, cutoff time.Time) (bool, error)
SetStatus(ctx context.Context, id, from, to string) (bool, error)
DeleteUnreferencedMissing(ctx context.Context, id string, cutoff time.Time) (bool, error)
IsReferenced(ctx context.Context, id string) (bool, error)
}
type Options struct {
Prefix string
Grace time.Duration
Apply bool
Now time.Time // общий «сейчас» для строк и объектов (время БД)
// MaxItems ограничивает список примеров в отчёте на каждый вид расхождения.
MaxItems int
}
type Item struct {
Kind string `json:"kind"`
Key string `json:"key"`
AttachmentID string `json:"attachment_id,omitempty"`
Action string `json:"action"`
Detail string `json:"detail,omitempty"`
}
type Report struct {
DryRun bool `json:"dry_run"`
GraceSeconds float64 `json:"grace_seconds"`
Cutoff time.Time `json:"cutoff"`
DurationMS int64 `json:"duration_ms"`
RowsScanned int `json:"rows_scanned"`
ObjectsScanned int `json:"objects_scanned"`
Consistent int `json:"consistent"`
Found map[string]int `json:"found"`
Fixed map[string]int `json:"fixed"`
Skipped map[string]int `json:"skipped"`
Calls map[string]int `json:"calls"`
HeapAllocMB float64 `json:"heap_alloc_mb"`
// WaitMS — сколько merge-цикл простоял в ожидании очередного элемента каждого
// потока: показывает, кто (S3-листинг или запрос к БД) задаёт время обхода.
WaitMS map[string]int64 `json:"wait_ms"`
Errors []string `json:"errors"`
Items []Item `json:"items"`
}
type reconciler struct {
repo Repo
store storage.Store
opt Options
rep *Report
items map[string]int
}
func (r *reconciler) note(kind string, it Item) {
r.rep.Found[kind]++
if r.items[kind] < r.opt.MaxItems {
r.items[kind]++
r.rep.Items = append(r.rep.Items, it)
}
}
func (r *reconciler) fail(format string, args ...any) {
if len(r.rep.Errors) < 100 {
r.rep.Errors = append(r.rep.Errors, fmt.Sprintf(format, args...))
}
}
// Run выполняет один проход. Ошибки отдельных действий попадают в отчёт и не
// прерывают обход; ошибка листинга/запроса прерывает проход целиком.
func Run(ctx context.Context, repo Repo, store storage.Store, opt Options) (*Report, error) {
start := time.Now()
if opt.MaxItems == 0 {
opt.MaxItems = 50
}
cutoff := opt.Now.Add(-opt.Grace)
rep := &Report{
DryRun: !opt.Apply, GraceSeconds: opt.Grace.Seconds(), Cutoff: cutoff,
Found: map[string]int{}, Fixed: map[string]int{}, Skipped: map[string]int{}, Calls: map[string]int{},
Errors: []string{}, Items: []Item{}, WaitMS: map[string]int64{},
}
rc := &reconciler{repo: repo, store: store, opt: opt, rep: rep, items: map[string]int{}}
ctx, cancel := context.WithCancel(ctx)
defer cancel()
objs := make(chan storage.Object, 512)
objErr := make(chan error, 1)
go func() {
defer close(objs)
objErr <- store.List(ctx, opt.Prefix, func(o storage.Object) error {
select {
case objs <- o:
return nil
case <-ctx.Done():
return ctx.Err()
}
})
}()
rows := make(chan *domain.Attachment, 512)
rowErr := make(chan error, 1)
go func() {
defer close(rows)
rowErr <- repo.StreamByKey(ctx, opt.Prefix, func(a *domain.Attachment) error {
select {
case rows <- a:
return nil
case <-ctx.Done():
return ctx.Err()
}
})
}()
var waitS3, waitDB time.Duration
nextObj := func() (storage.Object, bool) {
t := time.Now()
o, ok := <-objs
waitS3 += time.Since(t)
return o, ok
}
nextRow := func() (*domain.Attachment, bool) {
t := time.Now()
a, ok := <-rows
waitDB += time.Since(t)
return a, ok
}
o, okO := nextObj()
a, okA := nextRow()
for okO || okA {
switch {
case okA && (!okO || a.ObjectKey < o.Key):
rep.RowsScanned++
rc.rowWithoutObject(ctx, a, cutoff)
a, okA = nextRow()
case okO && (!okA || o.Key < a.ObjectKey):
rep.ObjectsScanned++
rc.objectWithoutRow(ctx, o, cutoff)
o, okO = nextObj()
default:
rep.RowsScanned++
rep.ObjectsScanned++
rc.both(ctx, a, o, cutoff)
a, okA = nextRow()
o, okO = nextObj()
}
}
rep.WaitMS["s3_list"] = waitS3.Milliseconds()
rep.WaitMS["db_stream"] = waitDB.Milliseconds()
if err := <-objErr; err != nil {
return rep, fmt.Errorf("list objects: %w", err)
}
if err := <-rowErr; err != nil {
return rep, fmt.Errorf("stream rows: %w", err)
}
rep.Calls["s3_list_pages"] = (rep.ObjectsScanned + 999) / 1000
var ms runtime.MemStats
runtime.ReadMemStats(&ms)
rep.HeapAllocMB = float64(ms.HeapAlloc) / (1 << 20)
rep.DurationMS = time.Since(start).Milliseconds()
return rep, nil
}
func (r *reconciler) rowWithoutObject(ctx context.Context, a *domain.Attachment, cutoff time.Time) {
switch a.Status {
case domain.AttachmentUploading:
if !a.UpdatedAt.Before(cutoff) {
r.rep.Skipped["fresh_intent"]++ // загрузка может быть в процессе
return
}
r.staleIntent(ctx, a, false)
case domain.AttachmentReady:
// Листинг мог начаться раньше, чем объект записан: перепроверяем точечно.
if r.objectExists(ctx, a.ObjectKey) {
r.rep.Skipped["recheck_object_present"]++
return
}
r.quarantine(ctx, a, "missing_object", "")
case domain.AttachmentMissing:
r.purgeMissing(ctx, a, cutoff)
}
}
func (r *reconciler) objectWithoutRow(ctx context.Context, o storage.Object, cutoff time.Time) {
if !o.LastModified.Before(cutoff) {
r.rep.Skipped["fresh_object"]++
return
}
// Строка могла появиться после начала обхода — перепроверяем перед удалением.
r.rep.Calls["db_haskey"]++
has, err := r.repo.HasKey(ctx, o.Key)
if err != nil {
r.fail("haskey %s: %v", o.Key, err)
return
}
if has {
r.rep.Skipped["recheck_row_present"]++
return
}
it := Item{Kind: "orphan_object", Key: o.Key, Action: "delete_object",
Detail: fmt.Sprintf("size=%d modified=%s", o.Size, o.LastModified.UTC().Format(time.RFC3339))}
if !r.opt.Apply {
it.Action = "would_delete_object"
r.note("orphan_object", it)
return
}
r.rep.Calls["s3_delete"]++
if err := r.store.Delete(ctx, o.Key); err != nil {
r.fail("delete orphan %s: %v", o.Key, err)
return
}
r.note("orphan_object", it)
r.rep.Fixed["orphan_object"]++
}
func (r *reconciler) both(ctx context.Context, a *domain.Attachment, o storage.Object, cutoff time.Time) {
switch a.Status {
case domain.AttachmentUploading:
if !a.UpdatedAt.Before(cutoff) {
r.rep.Skipped["fresh_intent"]++
return
}
r.staleIntent(ctx, a, true)
case domain.AttachmentReady:
if o.Size != a.SizeBytes {
r.quarantine(ctx, a, "size_mismatch", fmt.Sprintf("db=%d s3=%d", a.SizeBytes, o.Size))
return
}
r.rep.Consistent++
case domain.AttachmentMissing:
if o.Size != a.SizeBytes {
r.purgeMissing(ctx, a, cutoff)
return
}
it := Item{Kind: "restored", Key: a.ObjectKey, AttachmentID: a.ID, Action: "set_ready"}
if !r.opt.Apply {
it.Action = "would_set_ready"
r.note("restored", it)
return
}
r.rep.Calls["db_update"]++
ok, err := r.repo.SetStatus(ctx, a.ID, domain.AttachmentMissing, domain.AttachmentReady)
if err != nil {
r.fail("restore %s: %v", a.ID, err)
return
}
r.note("restored", it)
if ok {
r.rep.Fixed["restored"]++
}
}
}
func (r *reconciler) objectExists(ctx context.Context, key string) bool {
r.rep.Calls["s3_stat"]++
_, err := r.store.Stat(ctx, key)
if err == nil {
return true
}
if !errors.Is(err, storage.ErrNotFound) {
r.fail("stat %s: %v", key, err)
return true // при ошибке хранилища ничего не трогаем
}
return false
}
func (r *reconciler) staleIntent(ctx context.Context, a *domain.Attachment, hasObject bool) {
it := Item{Kind: "stale_intent", Key: a.ObjectKey, AttachmentID: a.ID, Action: "delete_intent",
Detail: "updated_at=" + a.UpdatedAt.UTC().Format(time.RFC3339)}
if hasObject {
it.Action = "delete_object_and_intent"
}
if !r.opt.Apply {
it.Action = "would_" + it.Action
r.note("stale_intent", it)
return
}
// Сначала объект: если упадём между шагами, останется намерение без объекта,
// и следующий проход его доберёт (обратный порядок оставил бы сироту без учёта).
if hasObject {
r.rep.Calls["s3_delete"]++
if err := r.store.Delete(ctx, a.ObjectKey); err != nil {
r.fail("delete intent object %s: %v", a.ObjectKey, err)
return
}
}
r.rep.Calls["db_delete"]++
ok, err := r.repo.DeleteStaleIntent(ctx, a.ID, r.opt.Now.Add(-r.opt.Grace))
if err != nil {
r.fail("delete intent %s: %v", a.ID, err)
return
}
r.note("stale_intent", it)
if ok {
r.rep.Fixed["stale_intent"]++
}
}
func (r *reconciler) quarantine(ctx context.Context, a *domain.Attachment, kind, detail string) {
it := Item{Kind: kind, Key: a.ObjectKey, AttachmentID: a.ID, Action: "quarantine", Detail: detail}
if !r.opt.Apply {
it.Action = "would_quarantine"
r.note(kind, it)
return
}
r.rep.Calls["db_update"]++
ok, err := r.repo.SetStatus(ctx, a.ID, domain.AttachmentReady, domain.AttachmentMissing)
if err != nil {
r.fail("quarantine %s: %v", a.ID, err)
return
}
r.note(kind, it)
if ok {
r.rep.Fixed[kind]++
}
}
// purgeMissing удаляет запись карантина, только если она старше grace и на неё
// не ссылается ни одно сообщение. Используемые вложения остаются (их история цела).
func (r *reconciler) purgeMissing(ctx context.Context, a *domain.Attachment, cutoff time.Time) {
if !a.UpdatedAt.Before(cutoff) {
r.rep.Skipped["fresh_missing"]++
return
}
r.rep.Calls["db_referenced"]++
ref, err := r.repo.IsReferenced(ctx, a.ID)
if err != nil {
r.fail("referenced %s: %v", a.ID, err)
return
}
if ref {
r.rep.Skipped["referenced_missing_kept"]++
return
}
it := Item{Kind: "purge_missing", Key: a.ObjectKey, AttachmentID: a.ID, Action: "delete_row"}
if !r.opt.Apply {
it.Action = "would_delete_row"
r.note("purge_missing", it)
return
}
r.rep.Calls["db_delete"]++
ok, err := r.repo.DeleteUnreferencedMissing(ctx, a.ID, cutoff)
if err != nil {
r.fail("purge %s: %v", a.ID, err)
return
}
r.note("purge_missing", it)
if ok {
r.rep.Fixed["purge_missing"]++
}
}
+232
View File
@@ -0,0 +1,232 @@
package reconcile
import (
"bytes"
"context"
"io"
"sort"
"testing"
"time"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/storage"
)
type fakeStore struct{ objs map[string]storage.Object }
func (f *fakeStore) Put(_ context.Context, key string, r io.Reader, size int64, _ string) error {
f.objs[key] = storage.Object{Key: key, Size: size, LastModified: time.Now()}
return nil
}
func (f *fakeStore) Get(context.Context, string) (io.ReadCloser, int64, error) {
return io.NopCloser(bytes.NewReader(nil)), 0, nil
}
func (f *fakeStore) Stat(_ context.Context, key string) (storage.Object, error) {
o, ok := f.objs[key]
if !ok {
return o, storage.ErrNotFound
}
return o, nil
}
func (f *fakeStore) Delete(_ context.Context, key string) error { delete(f.objs, key); return nil }
func (f *fakeStore) List(_ context.Context, prefix string, fn func(storage.Object) error) error {
keys := make([]string, 0, len(f.objs))
for k := range f.objs {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
if err := fn(f.objs[k]); err != nil {
return err
}
}
return nil
}
type fakeRepo struct {
rows map[string]*domain.Attachment // by id
refs map[string]bool
}
func (f *fakeRepo) StreamByKey(_ context.Context, _ string, fn func(*domain.Attachment) error) error {
list := make([]*domain.Attachment, 0, len(f.rows))
for _, a := range f.rows {
c := *a
list = append(list, &c)
}
sort.Slice(list, func(i, j int) bool { return list[i].ObjectKey < list[j].ObjectKey })
for _, a := range list {
if err := fn(a); err != nil {
return err
}
}
return nil
}
func (f *fakeRepo) HasKey(_ context.Context, key string) (bool, error) {
for _, a := range f.rows {
if a.ObjectKey == key {
return true, nil
}
}
return false, nil
}
func (f *fakeRepo) DeleteStaleIntent(_ context.Context, id string, cutoff time.Time) (bool, error) {
a, ok := f.rows[id]
if !ok || a.Status != domain.AttachmentUploading || !a.UpdatedAt.Before(cutoff) {
return false, nil
}
delete(f.rows, id)
return true, nil
}
func (f *fakeRepo) SetStatus(_ context.Context, id, from, to string) (bool, error) {
a, ok := f.rows[id]
if !ok || a.Status != from {
return false, nil
}
a.Status = to
a.UpdatedAt = now
return true, nil
}
func (f *fakeRepo) DeleteUnreferencedMissing(_ context.Context, id string, cutoff time.Time) (bool, error) {
a, ok := f.rows[id]
if !ok || a.Status != domain.AttachmentMissing || !a.UpdatedAt.Before(cutoff) || f.refs[id] {
return false, nil
}
delete(f.rows, id)
return true, nil
}
func (f *fakeRepo) IsReferenced(_ context.Context, id string) (bool, error) { return f.refs[id], nil }
var now = time.Date(2026, 10, 30, 12, 0, 0, 0, time.UTC)
const grace = time.Hour
func old() time.Time { return now.Add(-2 * grace) }
func fresh() time.Time { return now.Add(-time.Minute) }
func setup() (*fakeRepo, *fakeStore) {
r := &fakeRepo{rows: map[string]*domain.Attachment{}, refs: map[string]bool{}}
s := &fakeStore{objs: map[string]storage.Object{}}
row := func(id, status string, size int64, at time.Time) {
r.rows[id] = &domain.Attachment{ID: id, ObjectKey: "a/c/" + id, Status: status, SizeBytes: size, UpdatedAt: at}
}
obj := func(id string, size int64, at time.Time) {
s.objs["a/c/"+id] = storage.Object{Key: "a/c/" + id, Size: size, LastModified: at}
}
// согласованное
row("ok", domain.AttachmentReady, 10, old())
obj("ok", 10, old())
// брошенная загрузка с объектом и без
row("stale1", domain.AttachmentUploading, 0, old())
obj("stale1", 7, old())
row("stale2", domain.AttachmentUploading, 0, old())
// загрузка в процессе — не трогать
row("inflight", domain.AttachmentUploading, 0, fresh())
obj("inflight", 5, fresh())
// сирота старая и свежая
obj("orphan", 3, old())
obj("orphan-fresh", 3, fresh())
// ready без объекта: используемое и нет
row("lost-used", domain.AttachmentReady, 9, old())
r.refs["lost-used"] = true
row("lost-free", domain.AttachmentReady, 9, old())
// подменённый размер
row("resized", domain.AttachmentReady, 10, old())
obj("resized", 11, old())
return r, s
}
func run(t *testing.T, r *fakeRepo, s *fakeStore, apply bool, at time.Time) *Report {
t.Helper()
rep, err := Run(context.Background(), r, s, Options{Prefix: "a/", Grace: grace, Apply: apply, Now: at})
if err != nil {
t.Fatal(err)
}
if len(rep.Errors) > 0 {
t.Fatalf("errors: %v", rep.Errors)
}
return rep
}
func TestDryRunChangesNothing(t *testing.T) {
r, s := setup()
nRows, nObjs := len(r.rows), len(s.objs)
rep := run(t, r, s, false, now)
if len(r.rows) != nRows || len(s.objs) != nObjs || r.rows["lost-free"].Status != domain.AttachmentReady {
t.Fatal("dry-run mutated state")
}
want := map[string]int{"stale_intent": 2, "orphan_object": 1, "missing_object": 2, "size_mismatch": 1}
for k, v := range want {
if rep.Found[k] != v {
t.Errorf("found[%s]=%d want %d (%v)", k, rep.Found[k], v, rep.Found)
}
}
if len(rep.Fixed) != 0 {
t.Errorf("dry-run fixed %v", rep.Fixed)
}
}
func TestApplyFixesAndIsIdempotent(t *testing.T) {
r, s := setup()
run(t, r, s, true, now)
for _, id := range []string{"stale1", "stale2"} {
if _, ok := r.rows[id]; ok {
t.Errorf("stale intent %s not removed", id)
}
}
if _, ok := s.objs["a/c/stale1"]; ok {
t.Error("stale intent object not removed")
}
if _, ok := s.objs["a/c/orphan"]; ok {
t.Error("old orphan not removed")
}
// Свежие — никогда.
if _, ok := s.objs["a/c/orphan-fresh"]; !ok {
t.Error("fresh orphan deleted")
}
if _, ok := r.rows["inflight"]; !ok {
t.Error("in-flight intent deleted")
}
if _, ok := s.objs["a/c/inflight"]; !ok {
t.Error("in-flight object deleted")
}
for _, id := range []string{"lost-used", "lost-free", "resized"} {
if r.rows[id].Status != domain.AttachmentMissing {
t.Errorf("%s not quarantined", id)
}
}
if r.rows["ok"].Status != domain.AttachmentReady {
t.Error("consistent row touched")
}
// Повтор сразу: исправлять нечего, карантин ещё моложе grace.
rep := run(t, r, s, true, now)
if len(rep.Fixed) != 0 {
t.Errorf("second pass fixed %v", rep.Fixed)
}
// Через grace: неиспользуемая запись карантина удаляется, используемая остаётся.
later := now.Add(2 * grace)
run(t, r, s, true, later)
if _, ok := r.rows["lost-free"]; ok {
t.Error("unreferenced missing row not purged")
}
if _, ok := r.rows["lost-used"]; !ok {
t.Error("referenced missing row deleted")
}
if _, ok := s.objs["a/c/orphan-fresh"]; ok {
t.Error("orphan not removed after grace")
}
}
func TestRestoredObjectLeavesQuarantine(t *testing.T) {
r, s := setup()
run(t, r, s, true, now)
// Объект вернули (например, из бэкапа) с правильным размером.
s.objs["a/c/lost-used"] = storage.Object{Key: "a/c/lost-used", Size: 9, LastModified: now}
rep := run(t, r, s, true, now)
if rep.Fixed["restored"] != 1 || r.rows["lost-used"].Status != domain.AttachmentReady {
t.Errorf("restore failed: %v %s", rep.Fixed, r.rows["lost-used"].Status)
}
}
+191
View File
@@ -0,0 +1,191 @@
package postgres
import (
"context"
"errors"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
)
type AttachmentRepository struct {
pool *pgxpool.Pool
}
func NewAttachmentRepository(pool *pgxpool.Pool) *AttachmentRepository {
return &AttachmentRepository{pool: pool}
}
const attachmentColumns = `id, chat_id, owner_id, filename, object_key, status,
COALESCE(content_type, ''), COALESCE(size_bytes, 0), COALESCE(sha256, ''), created_at, updated_at`
func scanAttachment(row pgx.Row) (*domain.Attachment, error) {
var a domain.Attachment
err := row.Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ObjectKey, &a.Status,
&a.ContentType, &a.SizeBytes, &a.SHA256, &a.CreatedAt, &a.UpdatedAt)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, repository.ErrNotFound
}
return nil, err
}
return &a, nil
}
// CreateIntent записывает намерение загрузки (status=uploading) ДО записи в S3.
func (r *AttachmentRepository) CreateIntent(ctx context.Context, a *domain.Attachment) error {
const q = `
INSERT INTO attachments (id, chat_id, owner_id, filename, object_key, status, created_at, updated_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5, 'uploading', $6, $6)
`
if _, err := r.pool.Exec(ctx, q, a.ID, a.ChatID, a.OwnerID, a.Filename, a.ObjectKey, a.CreatedAt); err != nil {
return fmt.Errorf("insert attachment intent: %w", err)
}
return nil
}
// MarkReady переводит намерение в ready после успешного и проверенного PUT.
// Если строки uploading уже нет (её убрал reconciler) — ErrNotFound.
func (r *AttachmentRepository) MarkReady(ctx context.Context, a *domain.Attachment) error {
const q = `
UPDATE attachments
SET status = 'ready', content_type = $2, size_bytes = $3, sha256 = $4, updated_at = $5
WHERE id = $1::uuid AND status = 'uploading'
`
tag, err := r.pool.Exec(ctx, q, a.ID, a.ContentType, a.SizeBytes, a.SHA256, a.UpdatedAt)
if err != nil {
return fmt.Errorf("mark attachment ready: %w", err)
}
if tag.RowsAffected() != 1 {
return repository.ErrNotFound
}
return nil
}
// DeleteIntent убирает намерение, если загрузка не удалась (компенсация).
func (r *AttachmentRepository) DeleteIntent(ctx context.Context, id string) error {
const q = `DELETE FROM attachments WHERE id = $1::uuid AND status = 'uploading'`
if _, err := r.pool.Exec(ctx, q, id); err != nil {
return fmt.Errorf("delete attachment intent: %w", err)
}
return nil
}
// GetForMember возвращает вложение, если пользователь — участник его чата.
// Чужое и несуществующее вложение неразличимы (ErrNotFound).
func (r *AttachmentRepository) GetForMember(ctx context.Context, id, userID string) (*domain.Attachment, error) {
q := `SELECT ` + attachmentColumns + `
FROM attachments a
WHERE a.id = $1::uuid
AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = a.chat_id AND m.user_id = $2::uuid)`
a, err := scanAttachment(r.pool.QueryRow(ctx, q, id, userID))
if err != nil && !errors.Is(err, repository.ErrNotFound) {
return nil, fmt.Errorf("select attachment: %w", err)
}
return a, err
}
// --- для reconciler ---
// StreamByKey отдаёт все строки в байтовом порядке object_key (как ListObjectsV2).
func (r *AttachmentRepository) StreamByKey(ctx context.Context, prefix string, fn func(*domain.Attachment) error) error {
q := `SELECT ` + attachmentColumns + `
FROM attachments
WHERE starts_with(object_key, $1)
ORDER BY object_key COLLATE "C"`
rows, err := r.pool.Query(ctx, q, prefix)
if err != nil {
return fmt.Errorf("stream attachments: %w", err)
}
defer rows.Close()
for rows.Next() {
a, err := scanAttachment(rows)
if err != nil {
return fmt.Errorf("scan attachment: %w", err)
}
if err := fn(a); err != nil {
return err
}
}
return rows.Err()
}
// HasKey — есть ли строка с этим object_key (повторная проверка перед удалением объекта).
func (r *AttachmentRepository) HasKey(ctx context.Context, key string) (bool, error) {
var ok bool
err := r.pool.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM attachments WHERE object_key = $1)`, key).Scan(&ok)
return ok, err
}
// DeleteStaleIntent удаляет намерение, только если оно всё ещё uploading и старше cutoff.
func (r *AttachmentRepository) DeleteStaleIntent(ctx context.Context, id string, cutoff time.Time) (bool, error) {
const q = `DELETE FROM attachments WHERE id = $1::uuid AND status = 'uploading' AND updated_at < $2`
tag, err := r.pool.Exec(ctx, q, id, cutoff)
return tag.RowsAffected() == 1, err
}
// SetStatus меняет статус ready↔missing (карантин и восстановление).
func (r *AttachmentRepository) SetStatus(ctx context.Context, id, from, to string) (bool, error) {
const q = `UPDATE attachments SET status = $3, updated_at = now() WHERE id = $1::uuid AND status = $2`
tag, err := r.pool.Exec(ctx, q, id, from, to)
return tag.RowsAffected() == 1, err
}
// DeleteUnreferencedMissing удаляет запись карантина старше cutoff, если на неё
// не ссылается ни одно сообщение. Блокировка строки (FOR UPDATE) конфликтует с
// FOR SHARE при создании сообщения, поэтому гонки «удалили, пока прикрепляли» нет.
func (r *AttachmentRepository) DeleteUnreferencedMissing(ctx context.Context, id string, cutoff time.Time) (bool, error) {
tx, err := r.pool.Begin(ctx)
if err != nil {
return false, err
}
defer func() { _ = tx.Rollback(ctx) }()
var locked string
err = tx.QueryRow(ctx, `SELECT id FROM attachments WHERE id = $1::uuid AND status = 'missing' AND updated_at < $2 FOR UPDATE`, id, cutoff).Scan(&locked)
if errors.Is(err, pgx.ErrNoRows) {
return false, nil
}
if err != nil {
return false, err
}
var referenced bool
if err := tx.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM message_attachments WHERE attachment_id = $1::uuid)`, id).Scan(&referenced); err != nil {
return false, err
}
if referenced {
return false, nil
}
if _, err := tx.Exec(ctx, `DELETE FROM attachments WHERE id = $1::uuid`, id); err != nil {
return false, err
}
return true, tx.Commit(ctx)
}
// IsReferenced — используется ли вложение каким-либо сообщением.
func (r *AttachmentRepository) IsReferenced(ctx context.Context, id string) (bool, error) {
var ok bool
err := r.pool.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM message_attachments WHERE attachment_id = $1::uuid)`, id).Scan(&ok)
return ok, err
}
// TryLock — advisory lock, чтобы одновременно работал один reconciler.
func (r *AttachmentRepository) TryLock(ctx context.Context) (func(), bool, error) {
conn, err := r.pool.Acquire(ctx)
if err != nil {
return nil, false, err
}
var ok bool
if err := conn.QueryRow(ctx, `SELECT pg_try_advisory_lock(4242004)`).Scan(&ok); err != nil || !ok {
conn.Release()
return nil, false, err
}
return func() {
_, _ = conn.Exec(context.Background(), `SELECT pg_advisory_unlock(4242004)`)
conn.Release()
}, true, nil
}
+180
View File
@@ -0,0 +1,180 @@
package postgres
import (
"context"
"errors"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
)
type ChatRepository struct {
pool *pgxpool.Pool
}
func NewChatRepository(pool *pgxpool.Pool) *ChatRepository {
return &ChatRepository{pool: pool}
}
func (r *ChatRepository) Create(ctx context.Context, chat *domain.Chat) error {
tx, err := r.pool.Begin(ctx)
if err != nil {
return fmt.Errorf("begin tx: %w", err)
}
defer func() { _ = tx.Rollback(ctx) }()
const insertChat = `INSERT INTO chats (id, title, created_at) VALUES ($1::uuid, $2, $3)`
if _, err := tx.Exec(ctx, insertChat, chat.ID, chat.Title, chat.CreatedAt); err != nil {
return fmt.Errorf("insert chat: %w", err)
}
const insertMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1::uuid, $2::uuid)`
for _, uid := range chat.MemberIDs {
if _, err := tx.Exec(ctx, insertMember, chat.ID, uid); err != nil {
return fmt.Errorf("insert member %s: %w", uid, err)
}
}
if err := tx.Commit(ctx); err != nil {
return fmt.Errorf("commit tx: %w", err)
}
return nil
}
func (r *ChatRepository) GetByID(ctx context.Context, id string) (*domain.Chat, error) {
const q = `SELECT id, title, created_at FROM chats WHERE id = $1::uuid`
var c domain.Chat
err := r.pool.QueryRow(ctx, q, id).Scan(&c.ID, &c.Title, &c.CreatedAt)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, repository.ErrNotFound
}
return nil, fmt.Errorf("select chat: %w", err)
}
const qMembers = `SELECT user_id FROM chat_members WHERE chat_id = $1::uuid ORDER BY user_id`
rows, err := r.pool.Query(ctx, qMembers, id)
if err != nil {
return nil, fmt.Errorf("select members: %w", err)
}
defer rows.Close()
c.MemberIDs = []string{}
for rows.Next() {
var uid string
if err := rows.Scan(&uid); err != nil {
return nil, fmt.Errorf("scan member: %w", err)
}
c.MemberIDs = append(c.MemberIDs, uid)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("iterate members: %w", err)
}
return &c, nil
}
func (r *ChatRepository) IsMember(ctx context.Context, chatID, userID string) (bool, error) {
const q = `SELECT 1 FROM chat_members WHERE chat_id = $1::uuid AND user_id = $2::uuid`
var one int
err := r.pool.QueryRow(ctx, q, chatID, userID).Scan(&one)
if err == nil {
return true, nil
}
if !errors.Is(err, pgx.ErrNoRows) {
return false, fmt.Errorf("check membership: %w", err)
}
const qChat = `SELECT 1 FROM chats WHERE id = $1::uuid`
err = r.pool.QueryRow(ctx, qChat, chatID).Scan(&one)
if err == nil {
return false, nil
}
if errors.Is(err, pgx.ErrNoRows) {
return false, repository.ErrNotFound
}
return false, fmt.Errorf("check chat exists: %w", err)
}
// MemberVersion одним запросом возвращает версию истории чата и признак членства.
// Несуществующий чат — ErrNotFound.
func (r *ChatRepository) MemberVersion(ctx context.Context, chatID, userID string) (int64, bool, error) {
const q = `
SELECT c.version,
EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2::uuid)
FROM chats c
WHERE c.id = $1::uuid
`
var version int64
var member bool
err := r.pool.QueryRow(ctx, q, chatID, userID).Scan(&version, &member)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return 0, false, repository.ErrNotFound
}
return 0, false, fmt.Errorf("select chat version: %w", err)
}
return version, member, nil
}
func (r *ChatRepository) ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) {
const qChats = `
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = $1::uuid
AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid)
ORDER BY c.created_at, c.id
LIMIT $4
`
rows, err := r.pool.Query(ctx, qChats, userID, cursor, cursorID, limit)
if err != nil {
return nil, fmt.Errorf("list chats: %w", err)
}
defer rows.Close()
chats := []*domain.Chat{}
var chatIDs []string
for rows.Next() {
var c domain.Chat
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
return nil, fmt.Errorf("scan chat: %w", err)
}
c.MemberIDs = []string{}
chats = append(chats, &c)
chatIDs = append(chatIDs, c.ID)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("iterate chats: %w", err)
}
if len(chats) == 0 {
return chats, nil
}
const qMembers = `SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[]) ORDER BY chat_id, user_id`
memberRows, err := r.pool.Query(ctx, qMembers, chatIDs)
if err != nil {
return nil, fmt.Errorf("list members: %w", err)
}
defer memberRows.Close()
byChat := make(map[string][]string)
for memberRows.Next() {
var chatID, uid string
if err := memberRows.Scan(&chatID, &uid); err != nil {
return nil, fmt.Errorf("scan member: %w", err)
}
byChat[chatID] = append(byChat[chatID], uid)
}
if err := memberRows.Err(); err != nil {
return nil, fmt.Errorf("iterate members: %w", err)
}
for _, c := range chats {
if members, ok := byChat[c.ID]; ok {
c.MemberIDs = members
}
}
return chats, nil
}
+200
View File
@@ -0,0 +1,200 @@
package postgres
import (
"context"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
)
type MessageRepository struct {
pool *pgxpool.Pool
}
func NewMessageRepository(pool *pgxpool.Pool) *MessageRepository {
return &MessageRepository{pool: pool}
}
func (r *MessageRepository) Create(ctx context.Context, msg *domain.Message) error {
const q = `
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5)
`
if _, err := r.pool.Exec(ctx, q, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil {
return fmt.Errorf("insert message: %w", err)
}
return nil
}
// CreateIdempotent вставляет сообщение и ключ в одной транзакции.
// Конкурентные запросы с одним ключом сериализуются уникальным индексом
// idempotency_keys: второй INSERT ждёт завершения первой транзакции, после
// COMMIT получает конфликт (DO NOTHING), откатывает своё сообщение и читает
// уже сохранённое. Если первая транзакция откатилась (транзиентная ошибка),
// вторая просто продолжает — неуспешный результат не фиксируется.
func (r *MessageRepository) CreateIdempotent(ctx context.Context, msg *domain.Message, key, requestHash string, ttl time.Duration) (*domain.Message, bool, error) {
tx, err := r.pool.Begin(ctx)
if err != nil {
return nil, false, fmt.Errorf("begin tx: %w", err)
}
defer func() { _ = tx.Rollback(ctx) }()
// Ключ старше TTL больше не защищает от повтора — освобождаем его.
const deleteExpired = `
DELETE FROM idempotency_keys
WHERE user_id = $1::uuid AND chat_id = $2::uuid AND key = $3
AND created_at < now() - make_interval(secs => $4)
`
if _, err := tx.Exec(ctx, deleteExpired, msg.SenderID, msg.ChatID, key, ttl.Seconds()); err != nil {
return nil, false, fmt.Errorf("delete expired key: %w", err)
}
const insertMsg = `
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5)
`
if _, err := tx.Exec(ctx, insertMsg, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil {
return nil, false, fmt.Errorf("insert message: %w", err)
}
if len(msg.AttachmentIDs) > 0 {
if err := attachToMessage(ctx, tx, msg); err != nil {
return nil, false, err
}
}
const insertKey = `
INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, message_id)
VALUES ($1::uuid, $2::uuid, $3, $4, $5::uuid)
ON CONFLICT (user_id, chat_id, key) DO NOTHING
`
tag, err := tx.Exec(ctx, insertKey, msg.SenderID, msg.ChatID, key, requestHash, msg.ID)
if err != nil {
return nil, false, fmt.Errorf("insert idempotency key: %w", err)
}
if tag.RowsAffected() == 1 {
// Версия истории растёт атомарно с сообщением: после COMMIT любое чтение
// увидит новую версию и не попадёт в кэш, записанный до этого сообщения.
const bumpVersion = `UPDATE chats SET version = version + 1 WHERE id = $1::uuid`
if _, err := tx.Exec(ctx, bumpVersion, msg.ChatID); err != nil {
return nil, false, fmt.Errorf("bump chat version: %w", err)
}
if err := tx.Commit(ctx); err != nil {
return nil, false, fmt.Errorf("commit tx: %w", err)
}
return msg, true, nil
}
// Ключ уже занят подтверждённой записью: наше сообщение не сохраняем.
_ = tx.Rollback(ctx)
const selectStored = `
SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at,
` + attachmentIDsExpr + `
FROM idempotency_keys k
JOIN messages m ON m.id = k.message_id
WHERE k.user_id = $1::uuid AND k.chat_id = $2::uuid AND k.key = $3
`
var storedHash string
var m domain.Message
err = r.pool.QueryRow(ctx, selectStored, msg.SenderID, msg.ChatID, key).
Scan(&storedHash, &m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt, &m.AttachmentIDs)
if err != nil {
return nil, false, fmt.Errorf("select stored message: %w", err)
}
if storedHash != requestHash {
return nil, false, repository.ErrConflict
}
return &m, false, nil
}
// DeleteExpiredKeys удаляет ключи старше TTL. Безопасно выполнять с любой реплики.
func (r *MessageRepository) DeleteExpiredKeys(ctx context.Context, ttl time.Duration) (int64, error) {
const q = `DELETE FROM idempotency_keys WHERE created_at < now() - make_interval(secs => $1)`
tag, err := r.pool.Exec(ctx, q, ttl.Seconds())
if err != nil {
return 0, fmt.Errorf("delete expired keys: %w", err)
}
return tag.RowsAffected(), nil
}
func (r *MessageRepository) ListByChat(ctx context.Context, chatID string, cursor time.Time, cursorID string, limit int) ([]*domain.Message, error) {
q := `
SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, ` + attachmentIDsExpr + `
FROM messages m
WHERE m.chat_id = $1::uuid
AND (m.created_at, m.id) > ($2::timestamptz, $3::uuid)
ORDER BY m.created_at, m.id
LIMIT $4
`
rows, err := r.pool.Query(ctx, q, chatID, cursor, cursorID, limit)
if err != nil {
return nil, fmt.Errorf("list messages: %w", err)
}
defer rows.Close()
msgs := []*domain.Message{}
for rows.Next() {
var m domain.Message
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt, &m.AttachmentIDs); err != nil {
return nil, fmt.Errorf("scan message: %w", err)
}
msgs = append(msgs, &m)
}
return msgs, rows.Err()
}
// attachmentIDsExpr — id вложений сообщения m в порядке отправки (всегда массив).
const attachmentIDsExpr = `ARRAY(SELECT ma.attachment_id::text FROM message_attachments ma
WHERE ma.message_id = m.id ORDER BY ma.position)`
// attachToMessage проверяет и привязывает вложения в транзакции сообщения.
// FOR SHARE блокирует строки вложений до COMMIT: reconciler (FOR UPDATE) не
// удалит вложение, которое сейчас прикрепляют. Вложение должно быть из того же
// чата и в статусе ready; чужое, неизвестное и незавершённое — ErrNotFound.
func attachToMessage(ctx context.Context, tx pgx.Tx, msg *domain.Message) error {
const q = `
SELECT id::text, status FROM attachments
WHERE id = ANY($1::uuid[]) AND chat_id = $2::uuid
FOR SHARE
`
rows, err := tx.Query(ctx, q, msg.AttachmentIDs, msg.ChatID)
if err != nil {
return fmt.Errorf("select attachments: %w", err)
}
status := map[string]string{}
for rows.Next() {
var id, st string
if err := rows.Scan(&id, &st); err != nil {
rows.Close()
return fmt.Errorf("scan attachment: %w", err)
}
status[id] = st
}
rows.Close()
if err := rows.Err(); err != nil {
return fmt.Errorf("select attachments: %w", err)
}
for _, id := range msg.AttachmentIDs {
switch status[id] {
case domain.AttachmentReady:
case domain.AttachmentMissing:
return repository.ErrConflict
default:
return repository.ErrNotFound
}
}
batch := &pgx.Batch{}
for i, id := range msg.AttachmentIDs {
batch.Queue(`INSERT INTO message_attachments (message_id, attachment_id, position) VALUES ($1::uuid, $2::uuid, $3)`,
msg.ID, id, i)
}
if err := tx.SendBatch(ctx, batch).Close(); err != nil {
return fmt.Errorf("insert message attachments: %w", err)
}
return nil
}
+39
View File
@@ -0,0 +1,39 @@
package postgres
import (
"context"
"fmt"
"time"
"github.com/jackc/pgx/v5/pgxpool"
)
// NewPool создаёт пул соединений с PostgreSQL.
// Параметры ограничены, чтобы не перегрузить БД.
func NewPool(ctx context.Context, dsn string, maxConns int32) (*pgxpool.Pool, error) {
cfg, err := pgxpool.ParseConfig(dsn)
if err != nil {
return nil, fmt.Errorf("parse dsn: %w", err)
}
cfg.MaxConns = maxConns
cfg.MinConns = min(2, maxConns)
cfg.MaxConnIdleTime = 5 * time.Minute
cfg.MaxConnLifetime = 30 * time.Minute
cfg.HealthCheckPeriod = 30 * time.Second
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, fmt.Errorf("create pool: %w", err)
}
// Проверяем, что соединение работает.
pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, fmt.Errorf("ping: %w", err)
}
return pool, nil
}
+77
View File
@@ -0,0 +1,77 @@
package postgres
import (
"context"
"errors"
"fmt"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
)
type UserRepository struct {
pool *pgxpool.Pool
}
func NewUserRepository(pool *pgxpool.Pool) *UserRepository {
return &UserRepository{pool: pool}
}
func (r *UserRepository) Create(ctx context.Context, user *domain.User, passwordHash string) error {
const q = `
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1::uuid, $2, $3, $4, $5)
`
_, err := r.pool.Exec(ctx, q, user.ID, user.Username, user.DisplayName, passwordHash, user.CreatedAt)
if err != nil {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) && pgErr.Code == "23505" {
return repository.ErrConflict
}
return fmt.Errorf("insert user: %w", err)
}
return nil
}
func (r *UserRepository) GetByID(ctx context.Context, id string) (*domain.User, error) {
const q = `SELECT id, username, display_name, created_at FROM users WHERE id = $1::uuid`
var u domain.User
err := r.pool.QueryRow(ctx, q, id).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, repository.ErrNotFound
}
return nil, fmt.Errorf("select user by id: %w", err)
}
return &u, nil
}
func (r *UserRepository) GetByUsername(ctx context.Context, username string) (*domain.User, error) {
const q = `SELECT id, username, display_name, created_at FROM users WHERE username = $1`
var u domain.User
err := r.pool.QueryRow(ctx, q, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, repository.ErrNotFound
}
return nil, fmt.Errorf("select user by username: %w", err)
}
return &u, nil
}
func (r *UserRepository) GetPasswordHash(ctx context.Context, userID string) (string, error) {
const q = `SELECT password_hash FROM users WHERE id = $1::uuid`
var hash string
err := r.pool.QueryRow(ctx, q, userID).Scan(&hash)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return "", repository.ErrNotFound
}
return "", fmt.Errorf("select password hash: %w", err)
}
return hash, nil
}
@@ -0,0 +1,93 @@
package redis
import (
"context"
"encoding/json"
"fmt"
"log/slog"
"time"
"github.com/redis/go-redis/v9"
"github.com/charawein/mtusi2026lab4/internal/domain"
)
// Ключ кэша истории всегда содержит версию чата из PostgreSQL (chats.version),
// которая растёт в одной транзакции с сообщением. Поэтому после подтверждённой
// записи следующее чтение идёт по новому ключу, даже если Redis отказал в
// любой команде: устаревшие ключи просто истекают по TTL.
//
// CACHE_INVALIDATION влияет только на стоимость записи (эксперимент трека 1):
// - "version": запись не обращается к Redis;
// - "scan": дополнительно удаляет ключи чата через SCAN, как в lab2 —
// O(размер keyspace/100) запросов к Redis на запись. На корректность не влияет.
const (
InvalidationScan = "scan"
InvalidationVersion = "version"
)
type MessageCache struct {
client *redis.Client
scanOnSet bool
}
func NewMessageCache(client *redis.Client, mode string) *MessageCache {
return &MessageCache{client: client, scanOnSet: mode == InvalidationScan}
}
type cacheEntry struct {
Items []*domain.Message `json:"items"`
NextCursor string `json:"next_cursor"`
}
func cacheKey(chatID string, version int64, cursor string, limit int) string {
return fmt.Sprintf("messages:%s:v%d:%s:%d", chatID, version, cursor, limit)
}
func (c *MessageCache) Get(ctx context.Context, chatID string, version int64, cursor string, limit int) ([]*domain.Message, string, bool) {
raw, err := c.client.Get(ctx, cacheKey(chatID, version, cursor, limit)).Bytes()
if err != nil {
return nil, "", false
}
var e cacheEntry
if err := json.Unmarshal(raw, &e); err != nil {
return nil, "", false
}
return e.Items, e.NextCursor, true
}
func (c *MessageCache) Set(ctx context.Context, chatID string, version int64, cursor string, limit int, items []*domain.Message, next string) {
e := cacheEntry{Items: items, NextCursor: next}
raw, err := json.Marshal(e)
if err != nil {
slog.Warn("marshal cache entry failed", "err", err)
return
}
if err := c.client.Set(ctx, cacheKey(chatID, version, cursor, limit), raw, 30*time.Second).Err(); err != nil {
// Redis недоступен — не падаем, работаем без кэша.
slog.Warn("redis set failed", "chat_id", chatID, "err", err)
}
}
// OnWrite вызывается после успешной записи сообщения. Свежесть чтения уже
// обеспечена ростом chats.version в транзакции записи; в режиме scan здесь
// только воспроизводится стоимость удаления старых ключей (lab2), и ошибка
// Redis не может сделать историю устаревшей.
func (c *MessageCache) OnWrite(ctx context.Context, chatID string) {
if !c.scanOnSet {
return
}
if err := c.Invalidate(ctx, chatID); err != nil {
slog.Warn("redis scan invalidation failed", "chat_id", chatID, "err", err)
}
}
// Invalidate удаляет все ключи messages:{chatID}:* через SCAN.
func (c *MessageCache) Invalidate(ctx context.Context, chatID string) error {
pattern := fmt.Sprintf("messages:%s:*", chatID)
iter := c.client.Scan(ctx, 0, pattern, 100).Iterator()
for iter.Next(ctx) {
_ = c.client.Del(ctx, iter.Val()).Err()
}
return iter.Err()
}
+73
View File
@@ -0,0 +1,73 @@
package redis
import (
"context"
"errors"
"fmt"
"time"
"github.com/redis/go-redis/v9"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
)
type SessionRepository struct {
client *redis.Client
}
func NewSessionRepository(client *redis.Client) *SessionRepository {
return &SessionRepository{client: client}
}
func (r *SessionRepository) Create(ctx context.Context, s *domain.Session) error {
key := "session:" + s.Token
ttl := time.Until(s.ExpiresAt)
if ttl <= 0 {
return fmt.Errorf("session already expired")
}
if err := r.client.Set(ctx, key, s.UserID, ttl).Err(); err != nil {
return fmt.Errorf("set session: %w", err)
}
return nil
}
func (r *SessionRepository) GetByToken(ctx context.Context, token string) (*domain.Session, error) {
key := "session:" + token
userID, err := r.client.Get(ctx, key).Result()
if err != nil {
if errors.Is(err, redis.Nil) {
return nil, repository.ErrNotFound
}
return nil, fmt.Errorf("get session: %w", err)
}
ttl, err := r.client.TTL(ctx, key).Result()
if err != nil {
return nil, fmt.Errorf("ttl: %w", err)
}
return &domain.Session{
Token: token,
UserID: userID,
ExpiresAt: time.Now().UTC().Add(ttl),
}, nil
}
func (r *SessionRepository) Delete(ctx context.Context, token string) error {
return r.client.Del(ctx, "session:"+token).Err()
}
func (r *SessionRepository) DeleteExpired(ctx context.Context) error {
return nil
}
func NewClient(ctx context.Context, url string) (*redis.Client, error) {
opts, err := redis.ParseURL(url)
if err != nil {
return nil, fmt.Errorf("parse redis url: %w", err)
}
client := redis.NewClient(opts)
if err := client.Ping(ctx).Err(); err != nil {
return nil, fmt.Errorf("ping redis: %w", err)
}
return client, nil
}
+57
View File
@@ -0,0 +1,57 @@
package repository
import (
"context"
"time"
"github.com/charawein/mtusi2026lab4/internal/domain"
)
var ErrNotFound = errNotFound{}
type errNotFound struct{}
func (errNotFound) Error() string { return "not found" }
var ErrConflict = errConflict{}
type errConflict struct{}
func (errConflict) Error() string { return "conflict" }
// UserRepository
type UserRepository interface {
Create(ctx context.Context, user *domain.User, passwordHash string) error
GetByID(ctx context.Context, id string) (*domain.User, error)
GetByUsername(ctx context.Context, username string) (*domain.User, error)
GetPasswordHash(ctx context.Context, userID string) (string, error)
}
// ChatRepository
type ChatRepository interface {
Create(ctx context.Context, chat *domain.Chat) error
GetByID(ctx context.Context, id string) (*domain.Chat, error)
IsMember(ctx context.Context, chatID, userID string) (bool, error)
// MemberVersion — версия истории чата (растёт с каждым сообщением) и членство.
MemberVersion(ctx context.Context, chatID, userID string) (version int64, member bool, err error)
ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error)
}
// MessageRepository
type MessageRepository interface {
Create(ctx context.Context, msg *domain.Message) error
// CreateIdempotent атомарно создаёт сообщение и запись ключа идемпотентности.
// Если ключ уже есть с тем же requestHash — возвращает ранее созданное сообщение
// и created=false; с другим requestHash — ErrConflict.
CreateIdempotent(ctx context.Context, msg *domain.Message, key, requestHash string, ttl time.Duration) (stored *domain.Message, created bool, err error)
DeleteExpiredKeys(ctx context.Context, ttl time.Duration) (int64, error)
ListByChat(ctx context.Context, chatID string, cursor time.Time, cursorID string, limit int) ([]*domain.Message, error)
}
// SessionRepository
type SessionRepository interface {
Create(ctx context.Context, s *domain.Session) error
GetByToken(ctx context.Context, token string) (*domain.Session, error)
Delete(ctx context.Context, token string) error
DeleteExpired(ctx context.Context) error
}
+323
View File
@@ -0,0 +1,323 @@
package service
import (
"bufio"
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"image"
_ "image/jpeg" // DecodeConfig для раннего отказа по размерам
_ "image/png"
"io"
"log/slog"
"mime"
"strings"
"time"
"unicode"
"unicode/utf8"
"github.com/google/uuid"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/imagecheck"
"github.com/charawein/mtusi2026lab4/internal/repository"
"github.com/charawein/mtusi2026lab4/internal/storage"
)
// ObjectPrefix — все объекты вложений лежат под этим префиксом bucket.
const ObjectPrefix = "a/"
type AttachmentRepository interface {
CreateIntent(ctx context.Context, a *domain.Attachment) error
MarkReady(ctx context.Context, a *domain.Attachment) error
DeleteIntent(ctx context.Context, id string) error
GetForMember(ctx context.Context, id, userID string) (*domain.Attachment, error)
}
type AttachmentService struct {
repo AttachmentRepository
chats repository.ChatRepository
store storage.Store
maxBytes int64
maxPixels int64
}
func NewAttachmentService(repo AttachmentRepository, chats repository.ChatRepository, store storage.Store, maxBytes, maxPixels int64) *AttachmentService {
return &AttachmentService{repo: repo, chats: chats, store: store, maxBytes: maxBytes, maxPixels: maxPixels}
}
// validateFilename: 1–255 code points, не только пробелы, без / \ NUL и управляющих.
func validateFilename(s string) bool {
if !utf8.ValidString(s) || strings.TrimSpace(s) == "" {
return false
}
if n := utf8.RuneCountInString(s); n < 1 || n > 255 {
return false
}
for _, r := range s {
if r == '/' || r == '\\' || r == 0 || unicode.IsControl(r) {
return false
}
}
return true
}
// declaredType нормализует Content-Type запроса; допустимы только PNG/JPEG.
func declaredType(h string) (string, bool) {
mt, _, err := mime.ParseMediaType(h)
if err != nil {
return "", false
}
mt = strings.ToLower(mt)
return mt, mt == imagecheck.PNG || mt == imagecheck.JPEG
}
// Upload принимает сырые байты одного изображения и возвращает ready-вложение.
//
// Порядок: намерение в PostgreSQL (uploading) → потоковый PUT в S3, параллельно
// SHA-256 и структурная проверка изображения → status=ready. 201 возвращается
// только после того, как и объект, и метаданные сохранены.
//
// Ошибка до MarkReady (проверка, PUT, обрыв клиента) компенсируется сразу:
// удаляются объект и намерение. Ошибка самого MarkReady — неопределённый исход:
// UPDATE мог дойти до PostgreSQL и закоммититься позже (так и было в тесте с
// паузой БД). Поэтому объект НЕ удаляется: остаётся либо ready+объект
// (согласовано), либо uploading+объект — это reconciler уберёт после grace.
// Состояние «ready без объекта» таким образом исключено.
func (s *AttachmentService) Upload(ctx context.Context, ownerID, chatID, filename, contentType string, body io.Reader, contentLength int64) (*domain.Attachment, error) {
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, ErrInvalidInput
}
chatID = parsed.String()
ok, err := s.chats.IsMember(ctx, chatID, ownerID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrNotFound
}
return nil, err
}
if !ok {
return nil, ErrNotFound
}
if !validateFilename(filename) {
return nil, ErrInvalidInput
}
declared, ok := declaredType(contentType)
if !ok {
return nil, ErrUnsupportedMedia
}
// Лимит размера — до чтения тела.
if contentLength > s.maxBytes {
return nil, ErrPayloadTooLarge
}
size := contentLength
if size < 0 {
// Без Content-Length (chunked): буфер не больше лимита + 1 байт.
buf, err := io.ReadAll(io.LimitReader(body, s.maxBytes+1))
if err != nil {
return nil, ErrInvalidInput
}
if int64(len(buf)) > s.maxBytes {
return nil, ErrPayloadTooLarge
}
body, size = bytes.NewReader(buf), int64(len(buf))
}
if size == 0 {
return nil, ErrUnsupportedMedia
}
// Формат — по содержимому; подмена Content-Type → 415.
br := bufio.NewReaderSize(body, 64*1024)
head, _ := br.Peek(int(min(size, 64*1024)))
format, ok := imagecheck.Sniff(head)
if !ok || format != declared {
return nil, ErrUnsupportedMedia
}
// Ранний отказ по пикселям, если заголовок уместился в первые 64 KiB.
if cfg, _, err := image.DecodeConfig(bytes.NewReader(head)); err == nil {
if int64(cfg.Width)*int64(cfg.Height) > s.maxPixels {
return nil, ErrPayloadTooLarge
}
}
now := nowUTC()
id := newID()
a := &domain.Attachment{
ID: id, ChatID: chatID, OwnerID: ownerID, Filename: filename,
ObjectKey: ObjectPrefix + chatID + "/" + id,
Status: domain.AttachmentUploading, CreatedAt: now, UpdatedAt: now,
}
if err := s.repo.CreateIntent(ctx, a); err != nil {
return nil, err
}
sum, putErr := s.putValidated(ctx, a.ObjectKey, br, size, format)
if putErr != nil {
s.compensate(ctx, a, putErr)
return nil, putErr
}
a.Status = domain.AttachmentReady
a.ContentType = format
a.SizeBytes = size
a.SHA256 = sum
a.UpdatedAt = nowUTC()
// Байты уже сохранены: доводим учёт до конца, даже если клиент отвалился.
mctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
defer cancel()
if err := s.repo.MarkReady(mctx, a); err != nil {
s.markReadyFailed(ctx, a, err)
return nil, ErrUnavailable
}
return a, nil
}
var errClientBody = errors.New("request body read failed")
// trackingReader запоминает ошибку чтения, отличную от EOF.
type trackingReader struct {
r io.Reader
err error
}
func (t *trackingReader) Read(p []byte) (int, error) {
n, err := t.r.Read(p)
if err != nil && err != io.EOF {
t.err = err
}
return n, err
}
type bodyReader struct{ r io.Reader }
func (b bodyReader) Read(p []byte) (int, error) {
n, err := b.r.Read(p)
if err != nil && err != io.EOF {
return n, errors.Join(errClientBody, err)
}
return n, err
}
// putValidated пишет объект в S3 и одновременно проверяет изображение и считает
// SHA-256. Байты проходят потоком (pipe), в памяти — только буферы чтения.
func (s *AttachmentService) putValidated(ctx context.Context, key string, body io.Reader, size int64, format string) (string, error) {
pr, pw := io.Pipe()
valErr := make(chan error, 1)
go func() {
tr := &trackingReader{r: pr}
_, err := imagecheck.Validate(tr, format, s.maxPixels)
if tr.err != nil {
// Поток оборвали снаружи (PUT в S3 упал или клиент отвалился):
// изображение тут ни при чём, причину определит putErr.
valErr <- nil
return
}
if err != nil {
pr.CloseWithError(err) // прерывает PUT: дальше писать некуда
}
valErr <- err
}()
h := sha256.New()
src := io.TeeReader(io.TeeReader(bodyReader{body}, h), pw)
putErr := s.store.Put(ctx, key, src, size, format)
if putErr != nil {
pw.CloseWithError(putErr)
} else {
pw.Close()
}
vErr := <-valErr
switch {
case errors.Is(vErr, imagecheck.ErrTooLarge):
return "", ErrPayloadTooLarge
case errors.Is(vErr, imagecheck.ErrInvalid):
return "", ErrUnsupportedMedia
case errors.Is(putErr, errClientBody):
return "", ErrInvalidInput
case putErr != nil:
slog.Warn("attachment upload to s3 failed", "err", putErr)
return "", ErrUnavailable
case vErr != nil:
return "", ErrUnsupportedMedia
}
return hex.EncodeToString(h.Sum(nil)), nil
}
// markReadyFailed: исход UPDATE неизвестен — объект оставляем. Пробуем убрать
// намерение (DELETE ... WHERE status='uploading' безопасен при любом исходе:
// если UPDATE уже закоммичен, он ничего не удалит). Если и это не удалось —
// uploading+объект уберёт reconciler после grace period.
func (s *AttachmentService) markReadyFailed(ctx context.Context, a *domain.Attachment, cause error) {
cctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
defer cancel()
if err := s.repo.DeleteIntent(cctx, a.ID); err != nil {
slog.Warn("mark ready failed, intent left for reconciler", "attachment_id", a.ID, "cause", cause.Error(), "err", err)
return
}
slog.Warn("mark ready failed, object left for reconciler", "attachment_id", a.ID, "cause", cause.Error())
}
// compensate убирает следы неудачной загрузки. Работает и после обрыва клиента
// (контекст запроса отменён), поэтому использует отдельный контекст.
func (s *AttachmentService) compensate(ctx context.Context, a *domain.Attachment, cause error) {
cctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
defer cancel()
if err := s.store.Delete(cctx, a.ObjectKey); err != nil {
slog.Warn("compensation: delete object failed, reconciler will retry", "attachment_id", a.ID, "err", err)
}
if err := s.repo.DeleteIntent(cctx, a.ID); err != nil {
slog.Warn("compensation: delete intent failed, reconciler will retry", "attachment_id", a.ID, "err", err)
}
slog.Info("attachment upload compensated", "attachment_id", a.ID, "cause", cause.Error())
}
// Get возвращает метаданные ready-вложения участнику его чата.
func (s *AttachmentService) Get(ctx context.Context, userID, id string) (*domain.Attachment, error) {
parsed, err := uuid.Parse(id)
if err != nil {
return nil, ErrInvalidInput
}
a, err := s.repo.GetForMember(ctx, parsed.String(), userID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrNotFound
}
return nil, err
}
switch a.Status {
case domain.AttachmentReady:
return a, nil
case domain.AttachmentMissing:
// Метаданные есть, байтов нет (обнаружил reconciler): ошибка сервера, не клиента.
return nil, ErrUnavailable
default:
return nil, ErrNotFound // загрузка не завершена — объекта для клиента ещё нет
}
}
// Open открывает оригинал на чтение. Вызывающий закрывает ReadCloser.
func (s *AttachmentService) Open(ctx context.Context, userID, id string) (*domain.Attachment, io.ReadCloser, error) {
a, err := s.Get(ctx, userID, id)
if err != nil {
return nil, nil, err
}
rc, size, err := s.store.Get(ctx, a.ObjectKey)
if err != nil {
if errors.Is(err, storage.ErrNotFound) {
slog.Error("attachment object missing in s3", "attachment_id", a.ID)
} else {
slog.Warn("s3 get failed", "attachment_id", a.ID, "err", err)
}
return nil, nil, ErrUnavailable
}
if size != a.SizeBytes {
rc.Close()
slog.Error("attachment size mismatch", "attachment_id", a.ID, "s3", size, "db", a.SizeBytes)
return nil, nil, ErrUnavailable
}
return a, rc, nil
}
+96
View File
@@ -0,0 +1,96 @@
package service
import (
"bytes"
"context"
"errors"
"image"
"image/color"
"image/png"
"io"
"testing"
"github.com/charawein/mtusi2026lab4/internal/storage"
)
// failingStore читает failAfter байт и падает — как PUT в недоступный S3.
type failingStore struct {
storage.Store
failAfter int64
got []byte
}
func (f *failingStore) Put(_ context.Context, _ string, r io.Reader, size int64, _ string) error {
if f.failAfter < 0 {
b, err := io.ReadAll(r)
f.got = b
return err
}
b, err := io.ReadAll(io.LimitReader(r, f.failAfter))
f.got = b
if err != nil {
return err
}
return errors.New("s3 put: connection refused")
}
type errReader struct{ data []byte }
func (e *errReader) Read(p []byte) (int, error) {
if len(e.data) == 0 {
return 0, errors.New("connection reset by peer")
}
n := copy(p, e.data)
e.data = e.data[n:]
return n, nil
}
func samplePNG(t *testing.T) []byte {
img := image.NewRGBA(image.Rect(0, 0, 200, 150))
for y := 0; y < 150; y++ {
for x := 0; x < 200; x++ {
img.Set(x, y, color.RGBA{uint8(x), uint8(y), uint8(x ^ y), 255})
}
}
var b bytes.Buffer
if err := png.Encode(&b, img); err != nil {
t.Fatal(err)
}
return b.Bytes()
}
func TestPutValidatedClassifiesCause(t *testing.T) {
data := samplePNG(t)
size := int64(len(data))
svc := &AttachmentService{maxBytes: 10 << 20, maxPixels: 40_000_000}
// S3 падает посреди потока: это 503, а не «битое изображение».
svc.store = &failingStore{failAfter: size / 3}
if _, err := svc.putValidated(context.Background(), "k", bytes.NewReader(data), size, "image/png"); !errors.Is(err, ErrUnavailable) {
t.Errorf("s3 failure mid-stream: got %v, want ErrUnavailable", err)
}
// S3 падает сразу.
svc.store = &failingStore{failAfter: 0}
if _, err := svc.putValidated(context.Background(), "k", bytes.NewReader(data), size, "image/png"); !errors.Is(err, ErrUnavailable) {
t.Errorf("s3 failure at start: got %v, want ErrUnavailable", err)
}
// Клиент оборвал тело: 400, не 415 и не 503.
svc.store = &failingStore{failAfter: -1}
if _, err := svc.putValidated(context.Background(), "k", &errReader{data: data[:len(data)/2]}, size, "image/png"); !errors.Is(err, ErrInvalidInput) {
t.Errorf("client body error: got %v, want ErrInvalidInput", err)
}
// Битое изображение при исправном S3: 415.
bad := bytes.Clone(data)
bad[len(bad)/2] ^= 0xFF
svc.store = &failingStore{failAfter: -1}
if _, err := svc.putValidated(context.Background(), "k", bytes.NewReader(bad), size, "image/png"); !errors.Is(err, ErrUnsupportedMedia) {
t.Errorf("corrupt image: got %v, want ErrUnsupportedMedia", err)
}
// Всё хорошо: SHA-256 и байты целиком дошли до S3.
ok := &failingStore{failAfter: -1}
svc.store = ok
sum, err := svc.putValidated(context.Background(), "k", bytes.NewReader(data), size, "image/png")
if err != nil || len(sum) != 64 || !bytes.Equal(ok.got, data) {
t.Errorf("valid upload: sum=%q err=%v bytes_equal=%v", sum, err, bytes.Equal(ok.got, data))
}
}
+99
View File
@@ -0,0 +1,99 @@
package service
import (
"context"
"crypto/rand"
"encoding/base64"
"errors"
"fmt"
"time"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
)
type AuthService struct {
users repository.UserRepository
sessions repository.SessionRepository
ttl time.Duration
}
func NewAuthService(users repository.UserRepository, sessions repository.SessionRepository, ttl time.Duration) *AuthService {
return &AuthService{users: users, sessions: sessions, ttl: ttl}
}
func (s *AuthService) Login(ctx context.Context, username, password string) (*domain.Session, *domain.User, error) {
u, err := s.users.GetByUsername(ctx, username)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
_, _ = hashPassword("dummy-password-for-timing")
return nil, nil, ErrUnauthorized
}
return nil, nil, err
}
hash, err := s.users.GetPasswordHash(ctx, u.ID)
if err != nil {
return nil, nil, err
}
if err := verifyPassword(password, hash); err != nil {
if errors.Is(err, ErrPasswordMismatch) {
return nil, nil, ErrUnauthorized
}
return nil, nil, fmt.Errorf("verify password: %w", err)
}
token, err := generateToken()
if err != nil {
return nil, nil, fmt.Errorf("generate token: %w", err)
}
now := nowUTC()
sess := &domain.Session{
Token: token,
UserID: u.ID,
ExpiresAt: now.Add(s.ttl),
CreatedAt: now,
}
if err := s.sessions.Create(ctx, sess); err != nil {
return nil, nil, err
}
return sess, u, nil
}
func (s *AuthService) ValidateSession(ctx context.Context, token string) (*domain.User, error) {
sess, err := s.sessions.GetByToken(ctx, token)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrUnauthorized
}
// Redis недоступен — возвращаем 401, чтобы клиент перелогинился,
// либо 503, если хотим явно показать проблему зависимости.
return nil, ErrUnauthorized // ← было: return nil, err
}
if nowUTC().After(sess.ExpiresAt) {
_ = s.sessions.Delete(ctx, token)
return nil, ErrUnauthorized
}
u, err := s.users.GetByID(ctx, sess.UserID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrUnauthorized
}
return nil, err
}
return u, nil
}
func (s *AuthService) Logout(ctx context.Context, token string) error {
return s.sessions.Delete(ctx, token)
}
func generateToken() (string, error) {
b := make([]byte, 32)
if _, err := rand.Read(b); err != nil {
return "", err
}
return base64.RawURLEncoding.EncodeToString(b), nil
}
+138
View File
@@ -0,0 +1,138 @@
package service
import (
"context"
"errors"
"time"
"github.com/google/uuid"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
)
type ChatService struct {
chats repository.ChatRepository
users repository.UserRepository
}
func NewChatService(chats repository.ChatRepository, users repository.UserRepository) *ChatService {
return &ChatService{chats: chats, users: users}
}
func (s *ChatService) Create(ctx context.Context, callerID, title string, memberIDs []string) (*domain.Chat, error) {
if !validateTitle(title) {
return nil, ErrInvalidInput
}
if len(memberIDs) == 0 || len(memberIDs) > 100 {
return nil, ErrInvalidInput
}
// Нормализация UUID: убираем разницу регистра.
normalized := make([]string, 0, len(memberIDs))
seen := make(map[string]struct{}, len(memberIDs))
callerFound := false
callerParsed, err := uuid.Parse(callerID)
if err != nil {
return nil, ErrInvalidInput
}
callerID = callerParsed.String()
for _, id := range memberIDs {
parsed, err := uuid.Parse(id)
if err != nil {
return nil, ErrInvalidInput
}
id = parsed.String()
if _, dup := seen[id]; dup {
return nil, ErrInvalidInput
}
seen[id] = struct{}{}
normalized = append(normalized, id)
if id == callerID {
callerFound = true
}
}
if !callerFound {
return nil, ErrInvalidInput
}
for id := range seen {
if _, err := s.users.GetByID(ctx, id); err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrInvalidInput
}
return nil, err
}
}
c := &domain.Chat{
ID: newID(),
Title: title,
MemberIDs: normalized,
CreatedAt: nowUTC(),
}
if err := s.chats.Create(ctx, c); err != nil {
return nil, err
}
return c, nil
}
func (s *ChatService) Get(ctx context.Context, callerID, chatID string) (*domain.Chat, error) {
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, ErrInvalidInput
}
chatID = parsed.String()
ok, err := s.chats.IsMember(ctx, chatID, callerID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrNotFound
}
return nil, err
}
if !ok {
return nil, ErrNotFound
}
c, err := s.chats.GetByID(ctx, chatID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrNotFound
}
return nil, err
}
return c, nil
}
func (s *ChatService) List(ctx context.Context, callerID, cursor string, limit int) ([]*domain.Chat, string, error) {
if limit < 1 || limit > 100 {
return nil, "", ErrInvalidInput
}
cursorTime := time.Unix(0, 0).UTC()
cursorID := "00000000-0000-0000-0000-000000000000"
if cursor != "" {
t, id, err := decodeCursor(cursor, callerID)
if err != nil {
return nil, "", err
}
cursorTime, cursorID = t, id
}
items, err := s.chats.ListByMember(ctx, callerID, cursorTime, cursorID, limit+1)
if err != nil {
return nil, "", err
}
if items == nil {
items = []*domain.Chat{}
}
var next string
if len(items) > limit {
items = items[:limit]
last := items[limit-1]
next = encodeCursor(callerID, last.CreatedAt, last.ID)
}
return items, next, nil
}
+39
View File
@@ -0,0 +1,39 @@
package service
import (
"encoding/base64"
"strings"
"time"
"github.com/google/uuid"
)
func encodeCursor(scope string, createdAt time.Time, id string) string {
raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
func decodeCursor(cursor, expectedScope string) (time.Time, string, error) {
raw, err := base64.RawURLEncoding.DecodeString(cursor)
if err != nil {
return time.Time{}, "", ErrInvalidInput
}
parts := strings.SplitN(string(raw), "|", 3)
if len(parts) != 3 {
return time.Time{}, "", ErrInvalidInput
}
if _, err := uuid.Parse(parts[0]); err != nil {
return time.Time{}, "", ErrInvalidInput
}
if parts[0] != expectedScope {
return time.Time{}, "", ErrInvalidInput
}
t, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return time.Time{}, "", ErrInvalidInput
}
if _, err := uuid.Parse(parts[2]); err != nil {
return time.Time{}, "", ErrInvalidInput
}
return t, parts[2], nil
}
+14
View File
@@ -0,0 +1,14 @@
package service
import "errors"
var (
ErrInvalidInput = errors.New("invalid input")
ErrUnauthorized = errors.New("unauthorized")
ErrNotFound = errors.New("not found")
ErrConflict = errors.New("conflict")
ErrUnavailable = errors.New("unavailable")
ErrPasswordMismatch = errors.New("password mismatch")
ErrPayloadTooLarge = errors.New("payload too large")
ErrUnsupportedMedia = errors.New("unsupported media type")
)
+23
View File
@@ -0,0 +1,23 @@
package service
import (
"crypto/rand"
"fmt"
"time"
)
func newID() string {
var b [16]byte
if _, err := rand.Read(b[:]); err != nil {
panic(fmt.Sprintf("crypto/rand failed: %v", err))
}
b[6] = (b[6] & 0x0f) | 0x40
b[8] = (b[8] & 0x3f) | 0x80
return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16])
}
// nowUTC возвращает время UTC с точностью до секунд.
// PostgreSQL и Python-клиент тестов ожидают формат без наносекунд.
func nowUTC() time.Time {
return time.Now().UTC().Truncate(time.Second)
}
+190
View File
@@ -0,0 +1,190 @@
package service
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"regexp"
"time"
"github.com/google/uuid"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
redisrepo "github.com/charawein/mtusi2026lab4/internal/repository/redis"
)
type MessageService struct {
messages repository.MessageRepository
chats repository.ChatRepository
cache *redisrepo.MessageCache
idempotencyTTL time.Duration
}
func NewMessageService(messages repository.MessageRepository, chats repository.ChatRepository, cache *redisrepo.MessageCache, idempotencyTTL time.Duration) *MessageService {
return &MessageService{messages: messages, chats: chats, cache: cache, idempotencyTTL: idempotencyTTL}
}
var idempotencyKeyRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
// requestHash — отпечаток семантики тела запроса. Хешируем уже разобранные поля,
// а не сырые байты: порядок ключей JSON не важен, отсутствующий attachment_ids
// равен [], порядок самих вложений значим.
func requestHash(text string, attachmentIDs []string) string {
if attachmentIDs == nil {
attachmentIDs = []string{}
}
raw, _ := json.Marshal(struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}{Text: text, AttachmentIDs: attachmentIDs})
sum := sha256.Sum256(raw)
return hex.EncodeToString(sum[:])
}
// Send создаёт сообщение с обязательным Idempotency-Key. Повтор с тем же ключом
// и телом возвращает исходное сообщение, с другим телом — ErrConflict.
// Доступ к чату проверяется при каждом повторе.
func (s *MessageService) Send(ctx context.Context, senderID, chatID, text string, attachmentIDs []string, idempotencyKey string) (*domain.Message, error) {
if !idempotencyKeyRe.MatchString(idempotencyKey) {
return nil, ErrInvalidInput
}
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, ErrInvalidInput
}
chatID = parsed.String()
ids, ok := normalizeAttachmentIDs(attachmentIDs)
if !ok {
return nil, ErrInvalidInput
}
// С вложениями допустим пустой text; иначе — обычные правила текста.
if !(len(ids) > 0 && text == "") && !validateText(text) {
return nil, ErrInvalidInput
}
ok, err = s.chats.IsMember(ctx, chatID, senderID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrNotFound
}
return nil, err
}
if !ok {
return nil, ErrNotFound
}
m := &domain.Message{
ID: newID(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: nowUTC(),
AttachmentIDs: ids,
}
stored, created, err := s.messages.CreateIdempotent(ctx, m, idempotencyKey, requestHash(text, ids), s.idempotencyTTL)
if err != nil {
switch {
case errors.Is(err, repository.ErrConflict):
return nil, ErrConflict
case errors.Is(err, repository.ErrNotFound):
return nil, ErrNotFound // чужое/неизвестное/незавершённое вложение
}
return nil, err
}
if !created {
return stored, nil
}
// Версия чата уже увеличена в транзакции записи; здесь только режим scan.
if s.cache != nil {
s.cache.OnWrite(ctx, chatID)
}
return m, nil
}
func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor string, limit int) ([]*domain.Message, string, error) {
parsed, err := uuid.Parse(chatID)
if err != nil {
return nil, "", ErrInvalidInput
}
chatID = parsed.String()
if limit < 1 || limit > 100 {
return nil, "", ErrInvalidInput
}
// Членство и версия истории — одним запросом к PostgreSQL. Версия читается
// до истории, поэтому под ключом версии v лежат данные не старее v.
version, ok, err := s.chats.MemberVersion(ctx, chatID, callerID)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, "", ErrNotFound
}
return nil, "", err
}
if !ok {
return nil, "", ErrNotFound
}
if s.cache != nil {
if items, next, hit := s.cache.Get(ctx, chatID, version, cursor, limit); hit {
return items, next, nil
}
}
cursorTime := time.Unix(0, 0).UTC()
cursorID := "00000000-0000-0000-0000-000000000000"
if cursor != "" {
t, id, err := decodeCursor(cursor, chatID)
if err != nil {
return nil, "", err
}
cursorTime, cursorID = t, id
}
items, err := s.messages.ListByChat(ctx, chatID, cursorTime, cursorID, limit+1)
if err != nil {
return nil, "", err
}
if items == nil {
items = []*domain.Message{}
}
var next string
if len(items) > limit {
items = items[:limit]
last := items[limit-1]
next = encodeCursor(chatID, last.CreatedAt, last.ID)
}
if s.cache != nil {
s.cache.Set(ctx, chatID, version, cursor, limit, items, next)
}
return items, next, nil
}
// normalizeAttachmentIDs: 0–10 уникальных UUID; приводит к каноническому виду.
func normalizeAttachmentIDs(in []string) ([]string, bool) {
if len(in) > 10 {
return nil, false
}
out := make([]string, 0, len(in))
seen := make(map[string]bool, len(in))
for _, raw := range in {
u, err := uuid.Parse(raw)
if err != nil {
return nil, false
}
id := u.String()
if seen[id] {
return nil, false
}
seen[id] = true
out = append(out, id)
}
return out, true
}
+66
View File
@@ -0,0 +1,66 @@
package service
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
const (
argonTime = 1
argonMemory = 64 * 1024
argonThreads = 4
argonKeyLen = 32
argonSaltLen = 16
)
func hashPassword(password string) (string, error) {
salt := make([]byte, argonSaltLen)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("generate salt: %w", err)
}
hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
return fmt.Sprintf(
"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version, argonMemory, argonTime, argonThreads,
base64.RawStdEncoding.EncodeToString(salt),
base64.RawStdEncoding.EncodeToString(hash),
), nil
}
func verifyPassword(password, encoded string) error {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return fmt.Errorf("invalid hash format")
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil {
return fmt.Errorf("parse version: %w", err)
}
if version != argon2.Version {
return fmt.Errorf("incompatible version: %d", version)
}
var mem uint32
var iters uint32
var threads uint8
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &mem, &iters, &threads); err != nil {
return fmt.Errorf("parse params: %w", err)
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return fmt.Errorf("decode salt: %w", err)
}
want, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return fmt.Errorf("decode hash: %w", err)
}
got := argon2.IDKey([]byte(password), salt, iters, mem, threads, uint32(len(want)))
if subtle.ConstantTimeCompare(got, want) != 1 {
return ErrPasswordMismatch
}
return nil
}
+64
View File
@@ -0,0 +1,64 @@
package service
import (
"context"
"errors"
"fmt"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/repository"
)
type UserService struct {
users repository.UserRepository
}
func NewUserService(users repository.UserRepository) *UserService {
return &UserService{users: users}
}
// Register создаёт нового пользователя. Возвращает ErrInvalidInput при невалидных
// данных и ErrConflict, если username занят.
func (s *UserService) Register(ctx context.Context, username, displayName, password string) (*domain.User, error) {
if !validateUsername(username) {
return nil, ErrInvalidInput
}
if !validateDisplayName(displayName) {
return nil, ErrInvalidInput
}
if !validatePassword(password) {
return nil, ErrInvalidInput
}
hash, err := hashPassword(password)
if err != nil {
return nil, fmt.Errorf("hash password: %w", err)
}
u := &domain.User{
ID: newID(),
Username: username,
DisplayName: displayName,
CreatedAt: nowUTC(),
}
if err := s.users.Create(ctx, u, hash); err != nil {
if errors.Is(err, repository.ErrConflict) {
return nil, ErrConflict
}
return nil, err
}
return u, nil
}
// GetByID возвращает пользователя. Возвращает ErrNotFound, если такого нет.
// Используется middleware аутентификации для проверки X-User-Id.
func (s *UserService) GetByID(ctx context.Context, id string) (*domain.User, error) {
u, err := s.users.GetByID(ctx, id)
if err != nil {
if errors.Is(err, repository.ErrNotFound) {
return nil, ErrNotFound
}
return nil, err
}
return u, nil
}
+53
View File
@@ -0,0 +1,53 @@
package service
import (
"regexp"
"strings"
"unicode/utf8"
)
var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
// validatePassword: 12–128 code points и не только пробельные символы
// (обязательная строка по контракту не может состоять из одних пробелов).
func validatePassword(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
n := utf8.RuneCountInString(s)
return n >= 12 && n <= 128
}
// validateUsername проверяет формат username по README: строго [a-z0-9_]{3,32}.
func validateUsername(s string) bool {
return usernameRe.MatchString(s)
}
// validateDisplayName проверяет display_name: 1–100 Unicode code points,
// не состоит только из пробельных символов.
func validateDisplayName(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
n := utf8.RuneCountInString(s)
return n >= 1 && n <= 100
}
// validateTitle проверяет title чата: 1–100 code points, не только пробелы.
func validateTitle(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
n := utf8.RuneCountInString(s)
return n >= 1 && n <= 100
}
// validateText проверяет text сообщения: 1–4000 code points, не только пробелы.
// В lab4 появится возможность отправить пустой text, если есть attachment_ids.
func validateText(s string) bool {
if strings.TrimSpace(s) == "" {
return false
}
n := utf8.RuneCountInString(s)
return n >= 1 && n <= 4000
}
+39
View File
@@ -0,0 +1,39 @@
package service
import (
"strings"
"testing"
)
func TestValidatePassword(t *testing.T) {
cases := []struct {
name string
in string
want bool
}{
{"обычный", "correct-horse-12", true},
{"ровно 12", strings.Repeat("a", 12), true},
{"128 code points", strings.Repeat("я", 128), true},
{"двоеточие допустимо", "pass:word:1234", true},
{"пробелы внутри допустимы", " pass word ", true},
{"короче 12", strings.Repeat("a", 11), false},
{"длиннее 128", strings.Repeat("a", 129), false},
{"12 пробелов", strings.Repeat(" ", 12), false},
{"пробельные символы разных видов", strings.Repeat(" \t\n ", 4), false},
{"пусто", "", false},
}
for _, c := range cases {
if got := validatePassword(c.in); got != c.want {
t.Errorf("%s: validatePassword(%q) = %v, want %v", c.name, c.in, got, c.want)
}
}
}
func TestValidateText(t *testing.T) {
if validateText(strings.Repeat(" ", 5)) {
t.Error("whitespace-only text must be rejected")
}
if !validateText("привет") {
t.Error("normal text must be accepted")
}
}
+130
View File
@@ -0,0 +1,130 @@
// Package storage — приватное S3-хранилище байтов вложений (MinIO).
package storage
import (
"context"
"errors"
"fmt"
"io"
"net/url"
"strings"
"time"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
// ErrNotFound — объекта нет в bucket.
var ErrNotFound = errors.New("object not found")
// Object — элемент листинга.
type Object struct {
Key string
Size int64
LastModified time.Time
}
// Store — то, что нужно приложению и reconciler от объектного хранилища.
type Store interface {
Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error
Get(ctx context.Context, key string) (io.ReadCloser, int64, error)
Stat(ctx context.Context, key string) (Object, error)
Delete(ctx context.Context, key string) error
// List отдаёт объекты с префиксом в лексикографическом (байтовом) порядке ключей.
List(ctx context.Context, prefix string, fn func(Object) error) error
}
type S3 struct {
client *minio.Client
bucket string
}
func NewS3(endpoint, region, bucket, accessKey, secretKey string) (*S3, error) {
u, err := url.Parse(endpoint)
if err != nil || u.Host == "" {
return nil, fmt.Errorf("bad S3 endpoint %q", endpoint)
}
c, err := minio.New(u.Host, &minio.Options{
Creds: credentials.NewStaticV4(accessKey, secretKey, ""),
Secure: u.Scheme == "https",
Region: region,
// По умолчанию minio-go повторяет до 10 раз; при недоступном S3 клиент
// должен быстро получить 503, а не ждать таймаута LB.
MaxRetries: 2,
BucketLookup: minio.BucketLookupPath,
})
if err != nil {
return nil, fmt.Errorf("s3 client: %w", err)
}
return &S3{client: c, bucket: bucket}, nil
}
func isNotFound(err error) bool {
code := minio.ToErrorResponse(err).Code
return code == "NoSuchKey" || code == "NotFound"
}
// Put пишет объект одним PUT, читая r потоково (size известен заранее).
func (s *S3) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error {
_, err := s.client.PutObject(ctx, s.bucket, key, r, size, minio.PutObjectOptions{
ContentType: contentType,
DisableMultipart: true,
})
if err != nil {
return fmt.Errorf("s3 put: %w", err)
}
return nil
}
func (s *S3) Get(ctx context.Context, key string) (io.ReadCloser, int64, error) {
obj, err := s.client.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{})
if err != nil {
return nil, 0, fmt.Errorf("s3 get: %w", err)
}
// GetObject ленивый: ошибки (нет объекта, S3 недоступен) видны на Stat.
st, err := obj.Stat()
if err != nil {
obj.Close()
if isNotFound(err) {
return nil, 0, ErrNotFound
}
return nil, 0, fmt.Errorf("s3 stat: %w", err)
}
return obj, st.Size, nil
}
func (s *S3) Stat(ctx context.Context, key string) (Object, error) {
st, err := s.client.StatObject(ctx, s.bucket, key, minio.StatObjectOptions{})
if err != nil {
if isNotFound(err) {
return Object{}, ErrNotFound
}
return Object{}, fmt.Errorf("s3 stat: %w", err)
}
return Object{Key: st.Key, Size: st.Size, LastModified: st.LastModified}, nil
}
// Delete идемпотентен: удаление отсутствующего объекта не ошибка.
func (s *S3) Delete(ctx context.Context, key string) error {
if err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{}); err != nil && !isNotFound(err) {
return fmt.Errorf("s3 delete: %w", err)
}
return nil
}
func (s *S3) List(ctx context.Context, prefix string, fn func(Object) error) error {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
for o := range s.client.ListObjects(ctx, s.bucket, minio.ListObjectsOptions{Prefix: prefix, Recursive: true}) {
if o.Err != nil {
return fmt.Errorf("s3 list: %w", o.Err)
}
if strings.HasSuffix(o.Key, "/") {
continue
}
if err := fn(Object{Key: o.Key, Size: o.Size, LastModified: o.LastModified}); err != nil {
return err
}
}
return nil
}
+90
View File
@@ -0,0 +1,90 @@
package http
import (
"io"
"log/slog"
"net/http"
"strconv"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
type AttachmentHandler struct {
attachments *service.AttachmentService
}
func NewAttachmentHandler(attachments *service.AttachmentService) *AttachmentHandler {
return &AttachmentHandler{attachments: attachments}
}
// Upload: POST /api/v1/chats/{chat_id}/attachments?filename=... с сырыми байтами PNG/JPEG.
func (h *AttachmentHandler) Upload(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
if uid == "" {
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
q := r.URL.Query()
if len(q["filename"]) != 1 {
httputil.WriteError(w, r, service.ErrInvalidInput)
return
}
// MaxBytesReader — второй рубеж: не дать прочитать больше лимита + 1 байт,
// даже если Content-Length солгал.
r.Body = http.MaxBytesReader(w, r.Body, 10*1024*1024+1)
a, err := h.attachments.Upload(r.Context(), uid, r.PathValue("chat_id"), q.Get("filename"),
r.Header.Get("Content-Type"), r.Body, r.ContentLength)
if err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusCreated, a)
}
// Get: GET /api/v1/attachments/{attachment_id} — метаданные.
func (h *AttachmentHandler) Get(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
a, err := h.attachments.Get(r.Context(), uid, r.PathValue("attachment_id"))
if err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusOK, a)
}
// Content: GET /api/v1/attachments/{attachment_id}/content[?variant=original] — байты
// через авторизованный API, без redirect на S3.
func (h *AttachmentHandler) Content(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
variant := r.URL.Query().Get("variant")
switch variant {
case "", "original":
case "thumbnail", "crop", "optimized":
// Варианты появятся в lab5; у ready-объекта lab4 их нет — после проверки доступа 404.
if _, err := h.attachments.Get(r.Context(), uid, r.PathValue("attachment_id")); err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteError(w, r, service.ErrNotFound)
return
default:
httputil.WriteError(w, r, service.ErrInvalidInput)
return
}
a, rc, err := h.attachments.Open(r.Context(), uid, r.PathValue("attachment_id"))
if err != nil {
httputil.WriteError(w, r, err)
return
}
defer rc.Close()
w.Header().Set("Content-Type", a.ContentType)
w.Header().Set("Content-Length", strconv.FormatInt(a.SizeBytes, 10))
w.Header().Set("Cache-Control", "private, no-store")
w.Header().Set("X-Content-Type-Options", "nosniff")
w.WriteHeader(http.StatusOK)
if n, err := io.Copy(w, rc); err != nil {
// Заголовок уже отправлен: клиент увидит обрыв по Content-Length.
slog.Warn("attachment download interrupted", "attachment_id", a.ID, "sent", n, "err", err)
}
}
+92
View File
@@ -0,0 +1,92 @@
package http
import (
"encoding/base64"
"net/http"
"strings"
"time"
"github.com/charawein/mtusi2026lab4/internal/domain"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
type AuthHandler struct {
auth *service.AuthService
}
func NewAuthHandler(auth *service.AuthService) *AuthHandler {
return &AuthHandler{auth: auth}
}
type sessionResponse struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt string `json:"expires_at"`
User *domain.User `json:"user"`
}
func (h *AuthHandler) CreateSession(w http.ResponseWriter, r *http.Request) {
username, password, ok := parseBasicAuth(r.Header.Get("Authorization"))
if !ok {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
sess, u, err := h.auth.Login(r.Context(), username, password)
if err != nil {
if err == service.ErrUnauthorized {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
}
httputil.WriteError(w, r, err)
return
}
// Формат RFC3339 без микросекунд: "2026-10-09T19:00:36Z".
// Python-клиент тестов ожидает 'Z' в конце строки.
httputil.WriteJSON(w, r, http.StatusCreated, sessionResponse{
Token: sess.Token,
TokenType: "Bearer",
ExpiresAt: sess.ExpiresAt.UTC().Truncate(time.Second).Format(time.RFC3339),
User: u,
})
}
func (h *AuthHandler) RevokeSession(w http.ResponseWriter, r *http.Request) {
token := bearerToken(r)
if token == "" {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
if err := h.auth.Logout(r.Context(), token); err != nil {
httputil.WriteError(w, r, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func parseBasicAuth(h string) (string, string, bool) {
const prefix = "Basic "
if !strings.HasPrefix(h, prefix) {
return "", "", false
}
raw, err := base64.StdEncoding.DecodeString(h[len(prefix):])
if err != nil {
return "", "", false
}
parts := strings.SplitN(string(raw), ":", 2)
if len(parts) != 2 {
return "", "", false
}
return parts[0], parts[1], true
}
func bearerToken(r *http.Request) string {
h := r.Header.Get("Authorization")
if !strings.HasPrefix(h, "Bearer ") {
return ""
}
return strings.TrimPrefix(h, "Bearer ")
}
+86
View File
@@ -0,0 +1,86 @@
package http
import (
"log/slog"
"net/http"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
type ChatHandler struct {
chats *service.ChatService
}
func NewChatHandler(chats *service.ChatService) *ChatHandler {
return &ChatHandler{chats: chats}
}
func (h *ChatHandler) CreateChat(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
if uid == "" {
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
var body struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
if err := httputil.DecodeJSON(r, &body); err != nil {
httputil.WriteError(w, r, err)
return
}
c, err := h.chats.Create(r.Context(), uid, body.Title, body.MemberIDs)
if err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusCreated, c)
}
func (h *ChatHandler) ListChats(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
if uid == "" {
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
limit, err := httputil.ParseLimit(r)
if err != nil {
httputil.WriteError(w, r, err)
return
}
cursor := r.URL.Query().Get("cursor")
items, next, err := h.chats.List(r.Context(), uid, cursor, limit)
if err != nil {
// ВРЕМЕННО: логируем точную ошибку
slog.Error("ListChats failed", "err", err, "uid", uid, "cursor", cursor, "limit", limit)
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusOK, httputil.PageResponse{Items: items, NextCursor: httputil.NextOrNull(next)})
}
func (h *ChatHandler) GetChat(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
if uid == "" {
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
chatID := r.PathValue("chat_id")
if chatID == "" {
httputil.WriteError(w, r, service.ErrInvalidInput)
return
}
c, err := h.chats.Get(r.Context(), uid, chatID)
if err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusOK, c)
}
+54
View File
@@ -0,0 +1,54 @@
package http
import (
"context"
"net/http"
"sync/atomic"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/redis/go-redis/v9"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
type HealthHandler struct {
pool *pgxpool.Pool
redis *redis.Client
draining *atomic.Bool
}
func NewHealthHandler(pool *pgxpool.Pool, redisClient *redis.Client, draining *atomic.Bool) *HealthHandler {
return &HealthHandler{pool: pool, redis: redisClient, draining: draining}
}
// Live проверяет только жизнь процесса.
func (h *HealthHandler) Live(w http.ResponseWriter, r *http.Request) {
httputil.WriteJSON(w, r, http.StatusOK, healthResponse{Status: "ok"})
}
// Ready проверяет доступность PostgreSQL и Redis.
// После SIGTERM возвращает 503, чтобы LB исключил реплику до закрытия listener.
func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) {
if h.draining.Load() {
httputil.WriteError(w, r, service.ErrUnavailable)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
defer cancel()
if err := h.pool.Ping(ctx); err != nil {
httputil.WriteError(w, r, service.ErrUnavailable)
return
}
if err := h.redis.Ping(ctx).Err(); err != nil {
httputil.WriteError(w, r, service.ErrUnavailable)
return
}
httputil.WriteJSON(w, r, http.StatusOK, healthResponse{Status: "ok"})
}
type healthResponse struct {
Status string `json:"status"`
}
+39
View File
@@ -0,0 +1,39 @@
package http
import (
"encoding/json"
"net/http"
"runtime"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/charawein/mtusi2026lab4/internal/config"
)
// NewInternalStatsHandler отдаёт счётчики пула PostgreSQL и рантайма Go.
// Нужен для поиска точки насыщения пула в экспериментах трека 1:
// рост empty_acquire_count/acquire_duration означает ожидание свободного соединения.
func NewInternalStatsHandler(pool *pgxpool.Pool, cfg config.Config) http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /internal/stats", func(w http.ResponseWriter, r *http.Request) {
st := pool.Stat()
body := map[string]any{
"instance_id": cfg.InstanceID,
"cache_invalidation": cfg.CacheInvalidation,
"pool": map[string]any{
"max_conns": st.MaxConns(),
"total_conns": st.TotalConns(),
"acquired_conns": st.AcquiredConns(),
"idle_conns": st.IdleConns(),
"acquire_count": st.AcquireCount(),
"empty_acquire_count": st.EmptyAcquireCount(),
"canceled_acquire_count": st.CanceledAcquireCount(),
"acquire_duration_ms": st.AcquireDuration().Milliseconds(),
},
"goroutines": runtime.NumGoroutine(),
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(body)
})
return mux
}
+113
View File
@@ -0,0 +1,113 @@
package http
import (
"encoding/json"
"errors"
"net/http"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
type MessageHandler struct {
messages *service.MessageService
}
func NewMessageHandler(messages *service.MessageService) *MessageHandler {
return &MessageHandler{messages: messages}
}
// attachmentIDs — поле контракта, которое обязано быть JSON-массивом строк.
// null недопустим (в отличие от отсутствия поля — его трактуем как пустой
// список и пробрасываем дальше как nil-срез).
type attachmentIDs struct {
present bool
value []string
}
var errAttachmentIDsNull = errors.New("attachment_ids must be an array, not null")
func (a *attachmentIDs) UnmarshalJSON(b []byte) error {
a.present = true
if string(b) == "null" {
return errAttachmentIDsNull
}
var v []string
if err := json.Unmarshal(b, &v); err != nil {
return err
}
a.value = v
return nil
}
func (h *MessageHandler) SendMessage(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
if uid == "" {
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
chatID := r.PathValue("chat_id")
if chatID == "" {
httputil.WriteError(w, r, service.ErrInvalidInput)
return
}
var body struct {
Text *string `json:"text"`
AttachmentIDs attachmentIDs `json:"attachment_ids"`
}
if err := httputil.DecodeJSON(r, &body); err != nil {
httputil.WriteError(w, r, err)
return
}
if body.Text == nil { // text обязателен по контракту, даже пустой
httputil.WriteError(w, r, service.ErrInvalidInput)
return
}
// null в attachment_ids — нарушение контракта; отсутствие поля считаем
// пустым списком.
if body.AttachmentIDs.present && body.AttachmentIDs.value == nil {
// present == true и value == nil возможно только если был null —
// но UnmarshalJSON уже вернул ошибку. Оставляем защиту на будущее.
httputil.WriteError(w, r, service.ErrInvalidInput)
return
}
// Повтор с тем же ключом возвращает тот же 201 и то же сообщение.
key := r.Header.Get("Idempotency-Key")
m, err := h.messages.Send(r.Context(), uid, chatID, *body.Text, body.AttachmentIDs.value, key)
if err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusCreated, m)
}
func (h *MessageHandler) ListMessages(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
if uid == "" {
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
chatID := r.PathValue("chat_id")
if chatID == "" {
httputil.WriteError(w, r, service.ErrInvalidInput)
return
}
limit, err := httputil.ParseLimit(r)
if err != nil {
httputil.WriteError(w, r, err)
return
}
cursor := r.URL.Query().Get("cursor")
items, next, err := h.messages.List(r.Context(), uid, chatID, cursor, limit)
if err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusOK, httputil.PageResponse{Items: items, NextCursor: httputil.NextOrNull(next)})
}
@@ -0,0 +1,48 @@
package middleware
import (
"errors"
"log/slog"
"net/http"
"strings"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
// Auth проверяет Authorization: Bearer <token> через AuthService.
func Auth(auth *service.AuthService) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
header := r.Header.Get("Authorization")
if !strings.HasPrefix(header, "Bearer ") {
writeUnauthorized(w, r)
return
}
token := strings.TrimPrefix(header, "Bearer ")
if token == "" {
writeUnauthorized(w, r)
return
}
u, err := auth.ValidateSession(r.Context(), token)
if err != nil {
if errors.Is(err, service.ErrUnauthorized) {
writeUnauthorized(w, r)
return
}
slog.Error("auth: unexpected", "err", err)
httputil.WriteError(w, r, nil)
return
}
ctx := httputil.ContextWithUserID(r.Context(), u.ID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
func writeUnauthorized(w http.ResponseWriter, r *http.Request) {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
httputil.WriteError(w, r, service.ErrUnauthorized)
}
@@ -0,0 +1,14 @@
package middleware
import "net/http"
// InstanceID добавляет X-Instance-Id ко всем ответам API, включая ошибки и health.
// Значение задаётся один раз при старте процесса и не меняется до его завершения.
func InstanceID(id string) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-Instance-Id", id)
next.ServeHTTP(w, r)
})
}
}
@@ -0,0 +1,34 @@
package middleware
import (
"log/slog"
"net/http"
"time"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
type statusRecorder struct {
http.ResponseWriter
status int
}
func (r *statusRecorder) WriteHeader(code int) {
r.status = code
r.ResponseWriter.WriteHeader(code)
}
func Logging(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
next.ServeHTTP(rec, r)
slog.Info("http request",
"request_id", httputil.RequestIDFrom(r.Context()),
"method", r.Method,
"path", r.URL.Path,
"status", rec.status,
"duration_ms", time.Since(start).Milliseconds(),
)
})
}
@@ -0,0 +1,25 @@
package middleware
import (
"log/slog"
"net/http"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
func Recovery(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rec := recover(); rec != nil {
slog.Error("panic in handler",
"panic", rec,
"request_id", httputil.RequestIDFrom(r.Context()),
"method", r.Method,
"path", r.URL.Path,
)
httputil.WriteError(w, r, nil)
}
}()
next.ServeHTTP(w, r)
})
}
@@ -0,0 +1,29 @@
package middleware
import (
"crypto/rand"
"fmt"
"net/http"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
func RequestID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := r.Header.Get("X-Request-Id")
if id == "" {
id = newRequestID()
}
w.Header().Set("X-Request-Id", id)
ctx := httputil.ContextWithRequestID(r.Context(), id)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
func newRequestID() string {
var b [12]byte
if _, err := rand.Read(b[:]); err != nil {
panic(fmt.Sprintf("crypto/rand failed: %v", err))
}
return fmt.Sprintf("%x", b[:])
}
@@ -0,0 +1,18 @@
package middleware
import (
"context"
"net/http"
"time"
)
// Timeout ограничивает время выполнения запроса.
func Timeout(d time.Duration) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), d)
defer cancel()
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
+62
View File
@@ -0,0 +1,62 @@
package http
import (
"net/http"
"sync/atomic"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/redis/go-redis/v9"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/transport/http/middleware"
)
func NewRouter(
users *service.UserService,
chats *service.ChatService,
messages *service.MessageService,
attachments *service.AttachmentService,
auth *service.AuthService,
pool *pgxpool.Pool,
redisClient *redis.Client,
instanceID string,
draining *atomic.Bool,
) http.Handler {
userH := NewUserHandler(users)
chatH := NewChatHandler(chats)
msgH := NewMessageHandler(messages)
authH := NewAuthHandler(auth)
attH := NewAttachmentHandler(attachments)
healthH := NewHealthHandler(pool, redisClient, draining)
mux := http.NewServeMux()
// Таймаут на запрос: обычный API — 5 s, передача файлов — 30 s.
short := middleware.Timeout(5 * time.Second)
long := middleware.Timeout(30 * time.Second)
authMW := func(h http.Handler) http.Handler { return short(middleware.Auth(auth)(h)) }
fileMW := func(h http.Handler) http.Handler { return long(middleware.Auth(auth)(h)) }
mux.Handle("GET /health/live", short(http.HandlerFunc(healthH.Live)))
mux.Handle("GET /health/ready", short(http.HandlerFunc(healthH.Ready)))
mux.Handle("POST /api/v1/users", short(http.HandlerFunc(userH.CreateUser)))
mux.Handle("POST /api/v1/auth/sessions", short(http.HandlerFunc(authH.CreateSession)))
mux.Handle("DELETE /api/v1/auth/sessions/current", authMW(http.HandlerFunc(authH.RevokeSession)))
mux.Handle("GET /api/v1/users/me", authMW(http.HandlerFunc(userH.CurrentUser)))
mux.Handle("POST /api/v1/chats", authMW(http.HandlerFunc(chatH.CreateChat)))
mux.Handle("GET /api/v1/chats", authMW(http.HandlerFunc(chatH.ListChats)))
mux.Handle("GET /api/v1/chats/{chat_id}", authMW(http.HandlerFunc(chatH.GetChat)))
mux.Handle("POST /api/v1/chats/{chat_id}/messages", authMW(http.HandlerFunc(msgH.SendMessage)))
mux.Handle("GET /api/v1/chats/{chat_id}/messages", authMW(http.HandlerFunc(msgH.ListMessages)))
mux.Handle("POST /api/v1/chats/{chat_id}/attachments", fileMW(http.HandlerFunc(attH.Upload)))
mux.Handle("GET /api/v1/attachments/{attachment_id}", authMW(http.HandlerFunc(attH.Get)))
mux.Handle("GET /api/v1/attachments/{attachment_id}/content", fileMW(http.HandlerFunc(attH.Content)))
handler := middleware.Logging(mux)
handler = middleware.Recovery(handler)
handler = middleware.RequestID(handler)
handler = middleware.InstanceID(instanceID)(handler)
return handler
}
+49
View File
@@ -0,0 +1,49 @@
package http
import (
"net/http"
"github.com/charawein/mtusi2026lab4/internal/service"
"github.com/charawein/mtusi2026lab4/internal/transport/httputil"
)
type UserHandler struct {
users *service.UserService
}
func NewUserHandler(users *service.UserService) *UserHandler {
return &UserHandler{users: users}
}
func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) {
var body struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
if err := httputil.DecodeJSON(r, &body); err != nil {
httputil.WriteError(w, r, err)
return
}
u, err := h.users.Register(r.Context(), body.Username, body.DisplayName, body.Password)
if err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusCreated, u)
}
func (h *UserHandler) CurrentUser(w http.ResponseWriter, r *http.Request) {
uid := httputil.UserIDFromContext(r.Context())
if uid == "" {
httputil.WriteError(w, r, service.ErrUnauthorized)
return
}
u, err := h.users.GetByID(r.Context(), uid)
if err != nil {
httputil.WriteError(w, r, err)
return
}
httputil.WriteJSON(w, r, http.StatusOK, u)
}
+166
View File
@@ -0,0 +1,166 @@
package httputil
import (
"context"
"encoding/json"
"errors"
"log/slog"
"net/http"
"strconv"
"github.com/charawein/mtusi2026lab4/internal/service"
)
// requestIDKey — ключ контекста для X-Request-Id.
type requestIDKey struct{}
// ContextWithRequestID кладёт request_id в контекст. Используется middleware.RequestID.
func ContextWithRequestID(ctx context.Context, id string) context.Context {
return context.WithValue(ctx, requestIDKey{}, id)
}
// RequestIDFrom извлекает request_id из контекста.
func RequestIDFrom(ctx context.Context) string {
if v, ok := ctx.Value(requestIDKey{}).(string); ok {
return v
}
return ""
}
// userIDKey — ключ контекста для аутентифицированного user_id.
type userIDKey struct{}
// ContextWithUserID кладёт user_id в контекст. Используется middleware.Auth.
func ContextWithUserID(ctx context.Context, id string) context.Context {
return context.WithValue(ctx, userIDKey{}, id)
}
// UserIDFromContext извлекает user_id из контекста.
func UserIDFromContext(ctx context.Context) string {
if v, ok := ctx.Value(userIDKey{}).(string); ok {
return v
}
return ""
}
// errorBody — формат тела ошибки по contracts/openapi.json.
type errorBody struct {
Error errorDetail `json:"error"`
}
type errorDetail struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
// WriteJSON пишет JSON-ответ с заданным статусом.
func WriteJSON(w http.ResponseWriter, r *http.Request, status int, v any) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(status)
if v == nil {
return
}
if err := json.NewEncoder(w).Encode(v); err != nil {
slog.Error("failed to encode response", "err", err, "request_id", RequestIDFrom(r.Context()))
}
}
// WriteError мапит доменную ошибку в HTTP-статус и пишет тело в формате контракта.
func WriteError(w http.ResponseWriter, r *http.Request, err error) {
status, code := mapError(err)
reqID := RequestIDFrom(r.Context())
if reqID == "" {
reqID = "missing-request-id"
}
body := errorBody{Error: errorDetail{
Code: code,
Message: messageFor(code),
RequestID: reqID,
}}
WriteJSON(w, r, status, body)
}
func mapError(err error) (int, string) {
switch {
case errors.Is(err, service.ErrInvalidInput):
return http.StatusBadRequest, "invalid_request"
case errors.Is(err, service.ErrUnauthorized):
return http.StatusUnauthorized, "unauthorized"
case errors.Is(err, service.ErrNotFound):
return http.StatusNotFound, "not_found"
case errors.Is(err, service.ErrConflict):
return http.StatusConflict, "conflict"
case errors.Is(err, service.ErrUnavailable):
return http.StatusServiceUnavailable, "unavailable"
case errors.Is(err, service.ErrPayloadTooLarge):
return http.StatusRequestEntityTooLarge, "payload_too_large"
case errors.Is(err, service.ErrUnsupportedMedia):
return http.StatusUnsupportedMediaType, "unsupported_media_type"
default:
return http.StatusInternalServerError, "internal_error"
}
}
func messageFor(code string) string {
switch code {
case "invalid_request":
return "Неверный запрос"
case "unauthorized":
return "Требуется аутентификация"
case "not_found":
return "Объект не найден"
case "conflict":
return "Конфликт"
case "internal_error":
return "Внутренняя ошибка"
case "unavailable":
return "Сервис недоступен"
case "payload_too_large":
return "Слишком большой файл или изображение"
case "unsupported_media_type":
return "Поддерживаются только корректные PNG и JPEG"
default:
return "Ошибка"
}
}
// DecodeJSON парсит тело запроса в v, строго запрещая неизвестные поля.
func DecodeJSON(r *http.Request, v any) error {
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(v); err != nil {
return service.ErrInvalidInput
}
if dec.More() {
return service.ErrInvalidInput
}
return nil
}
// ParseLimit читает query-параметр limit с дефолтом и границами по контракту.
func ParseLimit(r *http.Request) (int, error) {
s := r.URL.Query().Get("limit")
if s == "" {
return 50, nil
}
n, err := strconv.Atoi(s)
if err != nil || n < 1 || n > 100 {
return 0, service.ErrInvalidInput
}
return n, nil
}
// PageResponse — универсальный ответ пагинации.
type PageResponse struct {
Items any `json:"items"`
NextCursor *string `json:"next_cursor"`
}
// NextOrNull превращает пустую строку в nil (для сериализации в null).
func NextOrNull(s string) *string {
if s == "" {
return nil
}
return &s
}
+6
View File
@@ -0,0 +1,6 @@
-- Откат миграции 0001
DROP TABLE IF EXISTS sessions;
DROP TABLE IF EXISTS messages;
DROP TABLE IF EXISTS chat_members;
DROP TABLE IF EXISTS chats;
DROP TABLE IF EXISTS users;
+50
View File
@@ -0,0 +1,50 @@
-- migrations/0001_init.sql
-- Пользователи
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL UNIQUE,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
-- Чаты
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
-- Членство
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 CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members(user_id);
-- Сообщения
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id),
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
-- Главный индекс для пагинации
CREATE INDEX messages_chat_created_id_idx
ON messages (chat_id, created_at, id);
-- Сессии (если SESSION_STORE=postgres)
CREATE TABLE sessions (
token TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX sessions_expires_idx ON sessions(expires_at);
CREATE INDEX sessions_user_idx ON sessions(user_id);
+1
View File
@@ -0,0 +1 @@
DROP TABLE IF EXISTS idempotency_keys;
+18
View File
@@ -0,0 +1,18 @@
-- migrations/0002_idempotency.sql
-- Ключи идемпотентности отправки сообщения (lab3).
-- Область уникальности: пользователь + метод + путь чата + ключ.
-- Метод всегда POST, путь однозначно задаётся chat_id, поэтому храним chat_id.
-- Запись создаётся в одной транзакции с сообщением: либо есть обе, либо ни одной.
CREATE TABLE idempotency_keys (
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
key TEXT NOT NULL,
request_hash TEXT NOT NULL,
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, chat_id, key)
);
-- Для периодической очистки ключей старше IDEMPOTENCY_TTL_SECONDS.
CREATE INDEX idempotency_keys_created_idx ON idempotency_keys(created_at);
+1
View File
@@ -0,0 +1 @@
ALTER TABLE chats DROP COLUMN IF EXISTS version;
+7
View File
@@ -0,0 +1,7 @@
-- migrations/0003_chat_version.sql
-- Версия истории чата: увеличивается в той же транзакции, что и вставка сообщения.
-- Входит в ключ кэша истории, поэтому видимость подтверждённой записи не зависит
-- от доступности Redis. Только добавление столбца с DEFAULT — совместимо с
-- работающей предыдущей версией API (expand).
ALTER TABLE chats ADD COLUMN version BIGINT NOT NULL DEFAULT 0;
+2
View File
@@ -0,0 +1,2 @@
DROP TABLE IF EXISTS message_attachments;
DROP TABLE IF EXISTS attachments;
+42
View File
@@ -0,0 +1,42 @@
-- migrations/0004_attachments.sql
-- Метаданные вложений. Байты — только в приватном S3-bucket по object_key,
-- который назначает сервер (filename используется только для отображения).
--
-- Жизненный цикл строки:
-- uploading — намерение записано ДО PUT в S3; так у каждого объекта, который
-- мог появиться в bucket, есть учётная запись. Брошенные намерения
-- старше grace period убирает reconciler (cmd/reconcile);
-- ready — объект записан и проверен, метаданные заполнены; только такие
-- вложения видны через API и прикрепляются к сообщениям;
-- missing — reconciler не нашёл объект в S3 (карантин, API отвечает 503).
CREATE TABLE attachments (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
owner_id UUID NOT NULL REFERENCES users(id),
filename TEXT NOT NULL,
object_key TEXT NOT NULL UNIQUE,
status TEXT NOT NULL CHECK (status IN ('uploading', 'ready', 'missing')),
content_type TEXT CHECK (content_type IN ('image/png', 'image/jpeg')),
size_bytes BIGINT CHECK (size_bytes > 0),
sha256 TEXT CHECK (sha256 ~ '^[a-f0-9]{64}$'),
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CHECK (status = 'uploading' OR (content_type IS NOT NULL AND size_bytes IS NOT NULL AND sha256 IS NOT NULL))
);
CREATE INDEX attachments_chat_idx ON attachments(chat_id);
-- Для reconciler: брошенные намерения и карантин по возрасту.
CREATE INDEX attachments_status_updated_idx ON attachments(status, updated_at);
-- Для merge-обхода в порядке ключей S3 (байтовый порядок, как в ListObjectsV2).
CREATE INDEX attachments_object_key_c_idx ON attachments(object_key COLLATE "C");
-- Связь сообщения с вложениями; position сохраняет порядок attachment_ids.
CREATE TABLE message_attachments (
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
attachment_id UUID NOT NULL REFERENCES attachments(id),
position SMALLINT NOT NULL,
PRIMARY KEY (message_id, attachment_id)
);
CREATE INDEX message_attachments_attachment_idx ON message_attachments(attachment_id);
+114
View File
@@ -0,0 +1,114 @@
#!/bin/sh
set -eu
# Прогоняет проверки lab4 на запущенном Docker-стенде и сохраняет вывод в evidence/.
# Токены и секреты не печатаются (тесты держат их в памяти, mc читает их внутри контейнера).
#
# sh scripts/collect-evidence.sh base # уровни 3–4 lab3 + smoke/persistence/failover lab4
# sh scripts/collect-evidence.sh files # вложения: негативный набор, отказы S3/БД, приватность, память
# sh scripts/collect-evidence.sh track2 # reconciler: внедрение расхождений и стоимость обхода
# sh scripts/collect-evidence.sh all
# Windows (Git Bash): PYTHON=python STOP=scripts/win/stop-one.cmd RESTART=scripts/win/restart.cmd sh scripts/collect-evidence.sh all
cd "$(dirname "$0")/.."
PY=${PYTHON:-python3}
STOP=${STOP:-scripts/stop-one.sh}
RESTART=${RESTART:-scripts/restart.sh}
BASE=${BASE_URL:-http://localhost:8080}
WHAT=${1:-all}
export PYTHONUTF8=1
mkdir -p evidence evidence/track2
step() { echo "== $*"; }
base() {
step "состояние стенда и образы"
{ date -u +%Y-%m-%dT%H:%M:%SZ; docker compose version; docker compose ps; } > evidence/docker_ps.txt
for img in $(docker compose config --images | sort -u); do
printf '%s %s\n' "$img" "$(docker image inspect --format '{{index .RepoDigests 0}}' "$img" 2>/dev/null || echo local-build)"
done > evidence/images.txt
cat evidence/images.txt
step "X-Instance-Id через LB"
$PY - "$BASE" > evidence/instances.txt <<'EOF'
import sys, urllib.request, collections
seen = collections.Counter()
for _ in range(20):
with urllib.request.urlopen(sys.argv[1] + '/health/ready') as r:
seen[r.headers['X-Instance-Id']] += 1
for k, v in sorted(seen.items()):
print(k, v)
EOF
cat evidence/instances.txt
step "smoke (lab4: вложение, checksum, посторонний)"
$PY tests/smoke.py --base-url "$BASE" | tee evidence/smoke.txt
step "конкурентная идемпотентность"
$PY student-tests/idempotency_concurrent.py --base-url "$BASE" --output evidence/idempotency_concurrent.json | tail -1
step "регрессии lab3"
$PY student-tests/regressions.py --base-url "$BASE" > evidence/regressions.txt 2>&1
cat evidence/regressions.txt
step "публичный failover lab4 (с проверкой оригинала), 2 прогона"
for n in 1 2; do
{ $PY tests/resilience.py --mode failover --action-script "$STOP" --base-url "$BASE" || echo "FAILED"; \
echo "-- контейнеры api после stop-one:"; docker compose ps -a api --format '{{.Name}} {{.ID}} {{.Status}}'; } \
> evidence/failover_$n.txt 2>&1
cat evidence/failover_$n.txt
sh scripts/restore.sh >> evidence/failover_$n.txt
done
step "persistence lab4 (restart всего стенда, включая S3, с volumes)"
{ echo "-- до:"; docker compose ps --format '{{.Name}} {{.Status}}'; \
$PY tests/resilience.py --mode persistence --action-script "$RESTART" --base-url "$BASE" || echo "FAILED"; \
echo "-- после:"; docker compose ps --format '{{.Name}} {{.Status}}'; } > evidence/persistence.txt 2>&1
cat evidence/persistence.txt
step "серия отказов каждой реплики под нагрузкой"
$PY student-tests/failover_series.py --base-url "$BASE" --output evidence/failover_series.json | tail -1
step "rolling update под нагрузкой"
docker compose build -q api
{ echo "-- до:"; docker compose ps api --format '{{.Name}} {{.ID}} {{.Status}}'; } > evidence/rolling_update.txt
$PY tests/load.py --base-url "$BASE" --duration 90 --concurrency 4 --output evidence/rolling_update_load.json > /dev/null &
LOAD=$!
sleep 5
start=$(date +%s)
sh scripts/rolling-update.sh >> evidence/rolling_update.txt 2>&1
echo "-- замена заняла $(( $(date +%s) - start )) s (внутри 90 s нагрузки)" >> evidence/rolling_update.txt
wait $LOAD
tail -4 evidence/rolling_update.txt; cat evidence/rolling_update_load.json
}
files() {
step "негативный набор вложений"
$PY student-tests/attachments_negative.py --base-url "$BASE" > evidence/attachments_negative.txt 2>&1
tail -3 evidence/attachments_negative.txt
for s in failover s3-outage interrupt security db-gap memory; do
step "вложения: $s"
$PY student-tests/attachments_ops.py "$s" --base-url "$BASE" --output "evidence/files_$s.json" \
> "evidence/files_$s.log" 2>&1 || echo "FAILED: $s (см. evidence/files_$s.log)"
tail -2 "evidence/files_$s.log"
done
docker compose logs --no-color api 2>&1 | grep -E 'compensat|s3 get failed|object missing' | tail -20 > evidence/compensation_log.txt || true
}
track2() {
step "reconciler: внедрение расхождений с обеих сторон"
$PY student-tests/reconcile_faults.py --base-url "$BASE" --output evidence/track2/faults.json \
> evidence/track2/faults.log 2>&1 || echo "FAILED: reconcile_faults (см. evidence/track2/faults.log)"
tail -2 evidence/track2/faults.log
step "reconciler: стоимость обхода"
$PY student-tests/reconcile_cost.py --base-url "$BASE" --sizes "${COST_SIZES:-1000,10000,30000}" \
--output evidence/track2/cost.json > evidence/track2/cost.log 2>&1 || echo "FAILED: reconcile_cost"
tail -2 evidence/track2/cost.log
}
case "$WHAT" in
base) base ;;
files) files ;;
track2) track2 ;;
all) base; files; track2 ;;
*) echo "usage: $0 base|files|track2|all" >&2; exit 2 ;;
esac
docker stats --no-stream --format '{{.Name}} {{.CPUPerc}} {{.MemUsage}}' > "evidence/docker_stats_$WHAT.txt"
+24
View File
@@ -0,0 +1,24 @@
#!/bin/sh
set -eu
# Создаёт локальные .env и secrets/ для учебного стенда. Повторный запуск ничего
# не перезаписывает (иначе пароль разойдётся с уже инициализированным volume).
cd "$(dirname "$0")/.."
[ -f .env ] || cp .env.example .env
mkdir -p secrets
chmod 700 secrets
if [ ! -f secrets/postgres_password ]; then
# 32 случайных байта в hex — без символов, требующих экранирования в URL.
pw=$(od -An -N32 -tx1 /dev/urandom | tr -d ' \n')
printf '%s' "$pw" > secrets/postgres_password
printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' "$pw" > secrets/database_url
fi
[ -f secrets/cache_url ] || printf '%s' 'redis://redis:6379/0' > secrets/cache_url
rnd() { od -An -N"$1" -tx1 /dev/urandom | tr -d ' \n'; }
# MinIO: root — только для s3 и s3-init; отдельный ключ API с правами на один bucket.
[ -f secrets/s3_root_user ] || printf 'root-%s' "$(rnd 6)" > secrets/s3_root_user
[ -f secrets/s3_root_password ] || printf '%s' "$(rnd 24)" > secrets/s3_root_password
[ -f secrets/s3_access_key_id ] || printf 'api-%s' "$(rnd 8)" > secrets/s3_access_key_id
[ -f secrets/s3_secret_access_key ] || printf '%s' "$(rnd 24)" > secrets/s3_secret_access_key
# 644: файлы монтируются в контейнеры (uid 1001) как есть; доступ с хоста закрывает каталог 700.
chmod 644 secrets/* 2>/dev/null || true
echo "secrets ready in ./secrets (values not printed)"
+20
View File
@@ -0,0 +1,20 @@
#!/bin/sh
set -eu
# Перезапускает API, LB, reconciler и все хранилища (PostgreSQL, Redis, S3) с сохранением volumes.
# Никаких down -v / FLUSH / повторного seed.
cd "$(dirname "$0")/.."
docker compose stop lb api reconciler
docker compose restart postgres redis s3
until docker compose exec -T postgres pg_isready -U messenger -d messenger >/dev/null 2>&1; do
sleep 1
done
until docker compose exec -T redis redis-cli ping >/dev/null 2>&1; do
sleep 1
done
until [ "$(docker inspect -f '{{.State.Health.Status}}' "$(docker compose ps -q s3)")" = healthy ]; do
sleep 1
done
docker compose start api lb reconciler
+17
View File
@@ -0,0 +1,17 @@
#!/bin/sh
set -eu
# Запускает остановленные stop-one.sh API-реплики и ждёт их готовности.
cd "$(dirname "$0")/.."
docker compose start api >/dev/null
deadline=$(( $(date +%s) + 60 ))
while :; do
bad=0
for cid in $(docker compose ps -aq api); do
st=$(docker inspect -f '{{.State.Health.Status}}' "$cid")
[ "$st" = healthy ] || bad=1
done
[ $bad -eq 0 ] && break
[ "$(date +%s)" -lt $deadline ] || { echo "api replicas not healthy in 60s" >&2; exit 1; }
sleep 1
done
docker compose ps api --format '{{.Name}} {{.Status}}'

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