Author SHA1 Message Date
Голиков Maximillian Антон 5175ccb676 docs(lab5):final 2026-11-13 22:14:09 +03:00
Голиков Maximillian Антон 873c67d0d2 feat(worker): lab5 add automatic reconnect loop for rabbitmq 2026-11-13 19:55:32 +03:00
Голиков Maximillian Антон 2c6c8e8a0b test(lab5): add chaos scripts, fault generation tool and evidence logs 2026-11-13 19:32:10 +03:00
Голиков Maximillian Антон e1bea0bc3e chore(lab5): add secret maker 2026-11-13 13:15:15 +03:00
Голиков Maximillian Антон de686d1956 docs(lab5): add initial report structure, setup guide and architecture diagram 2026-11-13 13:12:32 +03:00
Голиков Maximillian Антон 19ddbfd16a test(lab5): add fault injection script and expose ports for testing 2026-11-13 11:59:57 +03:00
Голиков Maximillian Антон 20fdd31c12 fix(worker): lab5 enforce pipeline version check on claim 2026-11-13 09:12:45 +03:00
Голиков Maximillian Антон d40b339906 feat(reconciler): lab5 recover expired leases and cleanup staging 2026-11-11 12:40:53 +03:00
Голиков Maximillian Антон f748c09e10 feat(worker): lab5 add retries, DLQ registry and manual replay endpoint 2026-11-10 19:08:15 +03:00
Голиков Maximillian Антон dce767a156 hotfix(worker): lab5 add failedjobs and outbox to main 2026-11-10 15:29:26 +03:00
Голиков Maximillian Антон 996e305ea4 feat(worker): lab5 add exponential backoff retries and permanent error classification 2026-11-10 15:28:20 +03:00
Голиков Maximillian Антон 8fb191fc78 feat(storage): lab5 implement delayed outbox and attempts tracking 2026-11-10 13:43:12 +03:00
Голиков Maximillian Антон d27a779c20 feat(storage): lab5 implement ScheduleRetry for transient errors 2026-11-10 12:00:48 +03:00
Голиков Maximillian Антон b022f8f7fc feat(db): lab5 add failed_jobs table and repository 2026-11-10 11:02:57 +03:00
Голиков Maximillian Антон 295371c326 feat(worker): lab5 generate all variants and enforce execution timeout 2026-11-09 19:12:21 +03:00
Голиков Maximillian Антон 9b28579031 feat(imaging): lab5 add optimized webp generation and update enums 2026-11-09 17:28:59 +03:00
Голиков Maximillian Антон b8d6e0efda feat(imaging): lab5 add webp optimization and strip metadata 2026-11-09 16:19:33 +03:00
Голиков Maximillian Антон d0153a88b6 feat(imaging): lab5 add crop 128x128 generation 2026-11-09 15:50:12 +03:00
Голиков Maximillian Антон bb5f2fb237 feat(api): lab5 serve attachment variants in json and content endpoints 2026-11-09 14:51:17 +03:00
Голиков Maximillian Антон 22c876f63c feat(worker): lab5 implement thumbnail generation and complete job logic 2026-11-09 12:39:59 +03:00
Голиков Maximillian Антон 872406773f feat(outbox): lab5 run outbox background publisher in api server 2026-11-09 09:12:48 +03:00
Голиков Maximillian Антон af9e94080e fix(infra): lab5 fix docker entrypoints, migration index and worker deps 2026-11-08 22:12:14 +03:00
Голиков Maximillian Антон 4c979dcc71 feat(worker): lab5 implement full pipeline with thumbnail generation 2026-11-08 21:34:04 +03:00
Голиков Maximillian Антон 693d92f93d feat(infra): lab5 add worker service to docker compose 2026-11-08 19:23:11 +03:00
Голиков Maximillian Антон 2895b3fbc1 feat(worker): lab5 implement rabbitmq consumer loop in main.go 2026-11-08 15:02:12 +03:00
Голиков Maximillian Антон 4f3e91e50e feat(worker): create pipeline skeleton 2026-11-08 15:21:12 +03:00
Голиков Maximillian Антон d235c82b39 feat(imaging): lab5 add thumbnail generation logic 2026-11-08 13:32:56 +03:00
Голиков Maximillian Антон 9fbc9da693 feat(storage): lab5 implement job claim, complete and variants upsert 2026-11-08 11:39:32 +03:00
Голиков Maximillian Антон a7c7532622 feat(domain): lab5 add attachment variants and job repository contracts 2026-11-08 10:19:32 +03:00
Голиков Maximillian Антон 4413c43eb5 feat(broker): lab5 make publisher thread-safe with reconnect and close 2026-11-07 15:43:22 +03:00
Голиков Maximillian Антон 2048203173 feat(broker): lab5 implement publish with publisher confirms 2026-11-07 15:25:45 +03:00
Голиков Maximillian Антон 2934d221d7 feat(broker): lab5 setup rabbitmq connection and durable topology 2026-11-07 15:12:22 +03:00
Голиков Maximillian Антон 1443b07ee1 feat(broker): add rabbitmq publisher interface and struct 2026-11-07 14:56:14 +03:00
Голиков Maximillian Антон 70b1b702c7 feat(storage): lab5 add outbox claim batch and mark published 2026-11-07 13:56:12 +03:00
Голиков Maximillian Антон bc9d69c6e2 feat(infra): lab5 add rabbitmq service and outbox config 2026-11-07 12:34:22 +03:00
Голиков Maximillian Антон 228aa88723 fix(storage): read lab5 job fields in GetByID 2026-11-07 11:23:46 +03:00
Голиков Maximillian Антон f4c6657a10 feat(api): lab5 return 202 on upload and allow queued attachments in messages 2026-11-07 10:52:00 +03:00
Голиков Maximillian Антон c34db41342 feat(db): lab5 drop pending status from attachments constraints 2026-11-07 10:28:45 +03:00
Голиков Maximillian Антон 6eaf2a89b0 feat(service): lab5 switch upload to queued and write to transactional outbox 2026-11-07 09:54:11 +03:00
Голиков Maximillian Антон 0fddc697f1 feat(storage): lab5 add CreateInTx for transactional outbox support 2026-11-07 07:45:56 +03:00
Голиков Maximillian Антон ab35077afd feat(storage): lab5 implement outbox enqueue and pgx transaction adapter 2026-11-07 06:46:21 +03:00
Голиков Maximillian Антон 09cf547254 feat(domain): lab5 add JobMessage contract 2026-11-06 22:59:32 +03:00
Голиков Maximillian Антон 7f0fb2b0da feat(domain,db): lab5 add outbox entry, transaction contract and 0006 migration 2026-11-06 22:43:56 +03:00
Голиков Maximillian Антон 18afe2563e feat(db): lab5 migration 0005 add queued/processing statuses and job columns on attachments 2026-11-06 21:27:05 +03:00
Голиков Maximillian Антон f2940880f5 feat(domain): lab5 add queued/processing statuses and job fields on Attachment 2026-11-06 20:53:22 +03:00
Голиков Maximillian Антон 4bba40d098 chore: lab import lab4 backend and infrastructure as baseline 2026-11-06 20:21:23 +03:00
103 changed files with 7719 additions and 38 deletions
+17 -8
View File
@@ -1,25 +1,34 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Run ./setup_secrets.sh before starting to generate required secrets.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
SESSION_STORE=redis
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
# S3 / MinIO Settings
S3_ENDPOINT=http://minio:9000
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MINIO_ROOT_USER_FILE=/run/secrets/minio_root_user
MINIO_ROOT_PASSWORD_FILE=/run/secrets/minio_root_password
# Upload Limits
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
BROKER_URL_FILE=/run/secrets/broker_url
# RabbitMQ Settings
RABBITMQ_PASSWORD=secret_rabbit
RABBITMQ_URL=amqp://messenger:secret_rabbit@rabbitmq:5672/
# Outbox & Worker Settings
OUTBOX_INTERVAL_MS=1000
WORKER_CONCURRENCY=2
JOB_MAX_ATTEMPTS=5
JOB_TIMEOUT_SECONDS=60
STAGING_RETENTION_SECONDS=86400
JOB_TIMEOUT_SECONDS=60
+16
View File
@@ -0,0 +1,16 @@
# Контейнеры Linux; shell-скрипты, Dockerfile, конфиги nginx/yaml
# должны иметь LF независимо от core.autocrlf на стороне разработчика.
*.sh text eol=lf
*.bash text eol=lf
Dockerfile text eol=lf
Dockerfile.* text eol=lf
*.yml text eol=lf
*.yaml text eol=lf
*.go text eol=lf
*.sql text eol=lf
*.md text eol=lf
*.conf text eol=lf
# Windows-специфичные - CRLF
*.bat text eol=crlf
*.cmd text eol=crlf
+54 -14
View File
@@ -1,18 +1,58 @@
## Лабораторная 5
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Голиков А.П., БВТ2303
Целевая оценка (3/4/5): 5
Трек 5, если заявлен: Трек 2 (Доказанная идемпотентность pipeline)
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
**Что реализовано и что перенесено:**
* **Перенесено из Lab 4:** Базовая структура пользователей, чатов, сообщений, аутентификация (Bearer/Basic), идемпотентность сообщений, загрузка вложений (изменен HTTP-код на 202 Accepted).
* **Реализовано в Lab 5:**
* **Архитектура:** Выделен отдельный Worker, внедрен RabbitMQ. API больше не делает тяжелый ресайз, а только валидирует заголовок.
* **Transactional Outbox:** Запись в `attachments` и `outbox` происходит атомарно в одной транзакции. Publisher (горутина в API) надежно перекладывает задачи в RabbitMQ с Publisher Confirms.
* **Обработка:** Worker генерирует Thumbnail (256x160), Crop (128x128) и Optimized WebP (до 1280x1280, без EXIF) с лимитами по времени и памяти.
* **Отказоустойчивость (Level 4):** Экспоненциальный Retry с jitter для временных ошибок. DLQ (`failed_jobs`) для постоянных ошибок. Ручка `POST /replay` для восстановления. Reconciler чистит Staging и спасает "зависшие" задачи (Lease Recovery).
* **Идемпотентность (Level 5):** Защита от дублей на уровне БД (`ClaimForProcessing`) и защита от гонки версий пайплайна (`pipeline_version`).
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
**Команды запуска из чистого clone:**
```sh
cp .env.example .env
chmod +x setup_secrets.sh
./setup_secrets.sh
docker compose up -d --build
# Ожидаем healthcheck: docker compose ps
$env:PYTHONUTF8 = "1" # Для Windows
python -X utf8 tests/smoke.py
```
Результаты проверок и ссылка на REPORT.md:
Публичный смоук tests/smoke.py пройден (лог в evidence/smoke.log).
Скрипт student-tests/fault_injection.py показывает 2 PASS (дубликаты и старая версия), доказывая Трек 2 (лог в evidence/fault_injection.log).
Все логи и доказательства (включая восстановление Worker'а после рестарта RabbitMQ) собраны в папке evidence/.
Подробное описание, схема и результаты экспериментов в REPORT.md.
Ограничения / известные ошибки:
На ОС Windows скрипт make test-persistence может падать на этапе проверки API из-за специфики перезапуска Docker Desktop сетей (API временно отдает 503). Логи восстановления Worker'а и API при этом подтверждают успешное переподключение.
Файлы staging хранятся в том же S3-бакете, что и финальные файлы (разделение по префиксам). В production лучше использовать отдельный бакет с Lifecycle Policy.
Трассировка OpenTelemetry не реализована (хотя ID для этого в сообщениях передаются).
Источники и использование ИИ:
Документация RabbitMQ (Publisher Confirms, DLX), Go (pgx, Gin).
Библиотеки: disintegration/imaging, gen2brain/webp.
ИИ использовался для генерации boilerplate-кода, написания bash-скриптов для Chaos Engineering и структурирования отчета.
Чек-лист (проверено):
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [x] Контракт и публичные тесты не ослаблены.
- [x] make check и make test выполнены; приложен реальный вывод.
- [x] Сценарии отказов/безопасности своего уровня воспроизведены.
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
+36
View File
@@ -0,0 +1,36 @@
FROM golang:1.26.1-alpine AS builder
WORKDIR /src
COPY backend/go.mod backend/go.sum ./
RUN go mod download
COPY backend/ .
RUN CGO_ENABLED=0 GOOS=linux go build \
-trimpath \
-ldflags="-s -w" \
-o /out/server \
./cmd/server
RUN CGO_ENABLED=0 GOOS=linux go build \
-trimpath \
-ldflags="-s -w" \
-o /out/worker \
./cmd/worker
FROM alpine:3.20
RUN adduser -D -u 1000 app
COPY --from=builder /out/server /server
COPY --from=builder /out/worker /worker
EXPOSE 8080
USER app
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD wget -q -O - http://127.0.0.1:8080/health/live >/dev/null || exit 1
CMD ["/server"]
+130 -16
View File
@@ -1,37 +1,151 @@
# Отчёт — лабораторная 5
Отчёт — лабораторная 5
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Голиков А.П., БВТ2303
- Целевая оценка; выбранный трек 5, если нужен: Оценка 5, Трек 2
- Commit/PR: ...
- Использованные источники, библиотеки и помощь ИИ: Документация RabbitMQ (Publisher Confirms, DLX), документация Go (pgx, Gin), библиотека `disintegration/imaging` для ресайза, `gen2brain/webp` для WebP. При написании кода использовалась помощь ИИ для генерации boilerplate-кода и архитектурных консультаций.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Требования (Prerequisites):**
- Docker и Docker Compose (рекомендуется Docker Desktop).
- Python 3.9+ (для запуска тестов).
- OpenSSL (для генерации секретов, встроен в Git Bash).
- ОС: Windows / Linux / macOS.
**Быстрый старт (Bash / Git Bash):**
Для запуска стенда выполните следующие команды в корне проекта:
```sh
# 1. Создаем .env из шаблона
cp .env.example .env
# 2. Генерируем секреты и автоматически обновляем .env
chmod +x setup_secrets.sh
./setup_secrets.sh
# 3. Собираем и запускаем весь стенд
docker compose up -d --build
# 4. Ожидаем, пока все сервисы пройдут healthcheck
Проверить статус: docker compose ps
```
Запуск тестов (Windows / PowerShell):
Для корректной работы Python на Windows с кириллицей в JSON-контрактах необходимо указать кодировку UTF-8:
```powershell
$env:PYTHONUTF8 = "1"
make test
# или
python -X utf8 tests/smoke.py
```
Безопасная остановка и удаление данных:
```sh
# Остановить контейнеры
docker compose stop
# Полностью удалить контейнеры и тома с учебными данными
docker compose down -v
```
## Архитектура и решения
```
[ Клиент ]
│ POST /attachments (bytes)
▼
[ API (реплики) ] ───(1) быстрый sniff & DecodeConfig───> [ Проверка лимитов ]
│
├──(2) PUT объект в S3 (prefix: staging/{id})
│
└──(3) BEGIN TX
├── INSERT INTO attachments (status='queued')
└── INSERT INTO outbox (payload=JobMessage)
COMMIT TX
│
▼ HTTP 202 Accepted (статус queued)
│
[ Outbox Publisher (горутина) ] ──(4) SELECT ... FOR UPDATE SKIP LOCKED──> [ PostgreSQL ]
│
├──(5) Publish в RabbitMQ с Publisher Confirm
└──(6) UPDATE outbox SET published_at = now()
│
▼
[ RabbitMQ ] (Очередь attachments.process, durable)
│
▼
[ Worker ] ──(7) ClaimForProcessing (status='processing', аренда 5 мин)
│
├──(8) GET staging/{id} из S3
├──(9) Генерация вариантов: Thumbnail, Crop, Optimized(WebP)
├──(10) PUT оригинал и варианты в S3 (prefix: chats/{chat_id}/{id})
├──(11) BEGIN TX
│ ├── UPDATE attachments SET status='ready'
│ └── INSERT INTO attachment_variants
│ COMMIT TX
└──(12) ACK сообщения в RabbitMQ
```
**Источник истины и транзакционные границы**
* **Источник истины:** PostgreSQL. Только база данных является авторитетным хранилищем состояний (`queued`, `processing`, `ready`, `failed`) и метаданных.
* **Транзакционные границы:** Для преодоления проблемы «двойной записи» (Dual-Write) между базой данных и брокером сообщений используется паттерн **Transactional Outbox**. Запись `INSERT attachments` и `INSERT outbox` происходит в рамках одной ACID-транзакции PostgreSQL. Это гарантирует, что если клиент получил `202 Accepted`, задача сохранена на диске и не будет потеряна, даже если RabbitMQ временно недоступен (Publisher дослать её при восстановлении).
* **Идемпотентность:** Брокер гарантирует доставку *at-least-once* (минимум один раз). Защита от дублей реализована на уровне метода `ClaimForProcessing` (атомарный `UPDATE ... WHERE status='queued'`), а также через защиту `pipeline_version` в методе `CompleteJob`.
**Логика обработки ошибок и Retry (Level 4)**
В Worker реализована классификация ошибок. Постоянные ошибки (например, `decode_failed` при битом файле) сразу переводят задачу в `failed`. Временные ошибки (например, `storage_error` при недоступности S3) ретраятся. Используется экспоненциальный backoff: задержка рассчитывается как `2^attempts` секунд + случайный jitter (до 1 сек). Для отложенных ретраев используется Outbox. После исчерпания лимита попыток (`JOB_MAX_ATTEMPTS=5`) задача попадает в реестр `failed_jobs` (DLQ). Для восстановления предусмотрена ручка `POST /attachments/{id}/replay`.
**Лимиты и защита**
Worker ограничен по памяти (лимит Docker 256 МБ), а обработка каждого изображения ограничена по времени (30 секунд через `context.WithTimeout`). Лимиты по размеру (10 МБ) и пикселям (40 млн) проверяются на уровне API. WebP генерируется с качеством 80 и удалением EXIF, JPEG (thumbnail и crop) — с качеством 85.
**Что перенесено из lab4 и что изменено**
* **Сохранено:** Базовая структура БД (пользователи, чаты, сообщения), аутентификация (Bearer/Basic), идемпотентность создания сообщений, интерфейсы репозиториев.
* **Изменено:**
* *Отказ от синхронного ресайза:* Метод `Upload` больше не делает полный `image.Decode` (который потреблял до 160 МБ RAM), теперь выполняется только быстрый `image.DecodeConfig` по заголовку.
* *Код ответа:* `201 Created` заменен на `202 Accepted`, так как обработка стала асинхронной.
* *Staging:* Оригинал при загрузке теперь сохраняется во временный префикс S3 (`staging/`), а не сразу в конечный (`chats/`).
* *Состояния:* Удален статус `pending`, добавлены `queued` и `processing`.
* *Инфраструктура:* Добавлены сервисы RabbitMQ и Worker. Появился фоновый процесс Outbox Publisher (внутри API) и Reconciler (сборка мусора и спасение зависших задач).
* *Обработка:* Добавлена генерация `crop` (128x128) и `optimized` (WebP до 1280x1280) с удалением метаданных.
**Конфигурация и переменные (.env.example)**
Переменные окружения разделены на логические блоки и передаются в контейнеры через `compose.yaml`:
* **API:** `APP_PORT`, `SESSION_TTL_SECONDS`, `API_REPLICAS` (масштабирование).
* **Лимиты файлов:** `MAX_UPLOAD_BYTES` (10 МБ), `MAX_IMAGE_PIXELS` (40 млн).
* **Outbox & Worker:** `OUTBOX_INTERVAL_MS` (частота опроса таблицы outbox), `WORKER_CONCURRENCY` (количество параллельных обработчиков), `JOB_MAX_ATTEMPTS` (лимит попыток), `JOB_TIMEOUT_SECONDS` (лимит времени на одну картинку).
* **Инфраструктура:** Строки подключения (`DATABASE_URL`, `CACHE_URL`, `RABBITMQ_URL`) и настройки S3/MinIO. Все пароли вынесены в Docker Secrets (генерация через `setup_secrets.sh`).
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke (Level 3) | `python -X utf8 tests/smoke.py` | `PASS: lab5 public API scenario` | `evidence/smoke.log` |
| Outbox + Async Worker (Level 3) | Загрузка файла через API | API отвечает 202, файл получает `ready` после Worker'а | `evidence/worker_logs.txt` |
| Переподключение Worker (Level 4) | `restart.sh` (рестарт БД/RabbitMQ) | Worker теряет связь, пишет ошибку, переподключается и продолжает работу | `evidence/worker_logs.txt` (строки 43-45) |
| Идемпотентность (Level 5) | `python -X utf8 student-tests/fault_injection.py` | `PASS` для дублей и устаревших версий. Лог воркера: "уже взята" | `evidence/fault_injection.log`, `evidence/worker_logs.txt` (строка 80) |
| Reconciler (Level 4) | Логи фонового процесса API | `reconciler: очистка завершена (удалено_staging=3...)` | `evidence/api_logs.txt` (строка 5) |
| DLQ / Failed jobs (Level 4) | Загрузка битого файла | Запись в `failed_jobs` создана | `evidence/failed_jobs.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
**Track 2: Доказанная идемпотентность pipeline**
- **Гипотеза:** Использование `pipeline_version` и транзакционного захвата задачи (`ClaimForProcessing`) гарантирует, что даже при at-least-once доставке сообщений от RabbitMQ, конечное состояние в БД будет корректным (effectively-once).
- **Методика:** Скрипт `fault_injection.py` отправляет дубликаты сообщений напрямую в RabbitMQ. Также скрипт меняет `pipeline_version` в БД и отправляет сообщение со старой версией. Дополнительно проверено восстановление после падения Worker'а (временное отключение БД/RabbitMQ через `restart.sh`) и обработка постоянных ошибок (битый файл).
- **Результаты:**
1. При дублировании сообщений количество вариантов (thumbnail, crop, optimized) остается равным 3. В логах Worker'а видно, что дубль игнорируется (`задача уже взята...`).
2. Задача со старой версией пайплайна игнорируется (статус остается `queued`).
3. Worker успешно переподключается к брокеру и БД после рестарта, не теряя принятые задачи.
- **Ограничения:** Мы не достигаем exactly-once на уровне брокера (at-least-once — гарантия RabbitMQ), но достигаем exactly-once эффекта (идемпотентности) на уровне записи в БД. Это доказывает, что архитектура спроектирована правильно.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Дубль сообщения (RabbitMQ) | Игнорирование дубля, 3 варианта в БД | Игнорирование, 3 варианта | 0 сек / потерь нет |
| Устаревшая версия (pipeline) | Игнорирование сообщения, статус `queued` | Игнорирование, `queued` | 0 сек / потерь нет |
| Рестарт БД и RabbitMQ (`restart.sh`) | API и Worker переподключаются | API временно отдает 503, Worker перезапускает коннект и продолжает работу | ~5 сек / потерь нет |
| Неисправимый файл (битый PNG) | Задача падает в `failed`, запись в `failed_jobs` | Запись в `failed_jobs` создана | - / потерь нет |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Какие отказы выдерживаются:** Система выдерживает недоступность S3 (ретраи), недоступность RabbitMQ (задачи копятся в Outbox), падение Worker'а (аренда истекает, Reconciler спасает задачу).
- **Учебные упрощения:** Файлы staging хранятся в том же бакете MinIO, что и финальные (разделение по префиксам). Для production лучше использовать lifecycle policy.
- **Что не реализовано:** В полной мере не реализована распределенная трассировка (OpenTelemetry), однако в сообщениях есть все необходимые ID для нее.
- **Следующие шаги:** Добавление Grafana для мониторинга глубины очередей и health-метрик.
+224
View File
@@ -0,0 +1,224 @@
package main
import (
"context"
"errors"
"fmt"
"log"
"net/http"
"os"
"os/signal"
"strings"
"sync/atomic"
"syscall"
"time"
"high-loud-apps-labs/internal/broker"
"high-loud-apps-labs/internal/config"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi"
"high-loud-apps-labs/internal/httpapi/handler"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/outbox"
"high-loud-apps-labs/internal/service"
"high-loud-apps-labs/internal/storage/postgres"
redisstore "high-loud-apps-labs/internal/storage/redis"
s3store "high-loud-apps-labs/internal/storage/s3"
)
func main() {
if len(os.Args) > 1 && os.Args[1] == "migrate" {
if err := runMigrate(); err != nil {
log.Fatalf("миграции: %v", err)
}
return
}
cfg, err := config.Load()
if err != nil {
log.Fatalf("конфигурация: %v", err)
}
addr := cfg.Host + ":" + cfg.Port
ctx := context.Background()
pool, err := postgres.Connect(ctx, postgres.Config{
URL: cfg.DatabaseURL,
MaxConns: 10,
MinConns: 1,
MaxConnLifetime: time.Hour,
MaxConnIdleTime: 30 * time.Minute,
ConnectTimeout: 5 * time.Second,
})
if err != nil {
log.Fatalf("БД: %v", err)
}
defer pool.Close()
store := postgres.New(pool)
rabbitPub, err := broker.NewRabbitPublisher(cfg.RabbitMQURL)
if err != nil {
log.Fatalf("rabbitmq: %v", err)
}
defer rabbitPub.Close()
outboxPub := outbox.NewPublisher(store.Outbox(), rabbitPub, 50)
outboxCtx, outboxCancel := context.WithCancel(context.Background())
defer outboxCancel()
go outboxPub.Run(outboxCtx, cfg.OutboxInterval)
sessionRepo, cachePing, closeSession := newSessionRepo(cfg, store)
defer closeSession()
hasher := service.NewArgon2idHasher()
userSvc := service.NewUserService(store.Users(), hasher)
sessionSvc := service.NewSessionService(store.Users(), sessionRepo, hasher, cfg.SessionTTL)
chatSvc := service.NewChatService(store.Chats(), store.Users())
messageSvc := service.NewMessageService(store.Messages(), store.Chats(), cfg.IdempotencyTTL)
if !cfg.S3Configured() {
log.Fatal("S3 не настроен: задайте S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY_ID_FILE/S3_ACCESS_KEY_ID, S3_SECRET_ACCESS_KEY_FILE/S3_SECRET_ACCESS_KEY")
}
objectStorage, err := s3store.New(ctx, s3store.Config{
Endpoint: cfg.S3Endpoint,
Bucket: cfg.S3Bucket,
AccessKey: cfg.S3AccessKey,
SecretKey: cfg.S3SecretKey,
UseSSL: cfg.S3UseSSL,
Region: cfg.S3Region,
})
if err != nil {
var unavailable *domain.UnavailableError
if errors.As(err, &unavailable) {
log.Fatalf("s3: %v (reason: %s)", err, unavailable.Reason)
}
log.Fatalf("s3: %v", err)
}
attachmentSvc := service.NewAttachmentService(
store.Attachments(),
store.Chats(),
objectStorage,
store.Outbox(),
store.FailedJobs(),
store,
cfg.MaxUploadBytes,
cfg.MaxImagePixels,
)
healthChecks := []handler.HealthCheck{
func(ctx context.Context) error { return pool.Ping(ctx) },
func(ctx context.Context) error { return objectStorage.Ping(ctx) },
}
if cachePing != nil {
healthChecks = append(healthChecks, cachePing)
}
var ready atomic.Bool
ready.Store(true)
router := httpapi.NewRouter(
httpapi.Handlers{
Health: handler.NewHealthHandler(healthChecks...).WithReadyFlag(&ready),
User: handler.NewUserHandler(userSvc),
Chat: handler.NewChatHandler(chatSvc),
Message: handler.NewMessageHandler(messageSvc),
Auth: handler.NewAuthHandler(sessionSvc),
Attachment: handler.NewAttachmentHandler(attachmentSvc),
},
middleware.BearerAuth(sessionSvc),
)
srv := &http.Server{Addr: addr, Handler: router}
reconcilerCtx, reconcilerCancel := context.WithCancel(context.Background())
defer reconcilerCancel()
if cfg.ReconcilerEnabled {
reconciler := service.NewReconciler(
store.Attachments(),
objectStorage,
store.Outbox(),
pool,
cfg.ReconcilerGracePeriod,
)
go reconciler.Run(reconcilerCtx, cfg.ReconcilerInterval)
}
go func() {
log.Printf("Запускаем на %s (SESSION_STORE=%s, RECONCILER_ENABLED=%v)", addr, cfg.SessionStore, cfg.ReconcilerEnabled)
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("Ошибка запуска: %v", err)
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
log.Printf("Получен сигнал завершения; readiness выключен, drain %s", cfg.ShutdownDrain)
ready.Store(false)
outboxCancel()
reconcilerCancel()
if cfg.ShutdownDrain > 0 {
time.Sleep(cfg.ShutdownDrain)
}
log.Println("Drain завершён, останавливаем HTTP-сервер...")
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Fatalf("Ошибка при остановке: %v", err)
}
log.Println("Сервер остановлен")
}
func runMigrate() error {
cfg, err := config.Load()
if err != nil {
return fmt.Errorf("конфигурация: %w", err)
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
pool, err := postgres.Connect(ctx, postgres.Config{
URL: cfg.DatabaseURL,
ConnectTimeout: 5 * time.Second,
})
if err != nil {
return fmt.Errorf("БД: %w", err)
}
defer pool.Close()
if err := postgres.RunMigrations(ctx, pool); err != nil {
return fmt.Errorf("применение миграций: %w", err)
}
return nil
}
func newSessionRepo(cfg *config.Config, store *postgres.Storage) (domain.SessionRepository, handler.HealthCheck, func()) {
switch strings.ToLower(cfg.SessionStore) {
case "", "postgres":
return store.Sessions(), nil, func() {}
case "redis":
if cfg.CacheURL == "" {
log.Fatalf("SESSION_STORE=%s требует CACHE_URL_FILE или CACHE_URL", cfg.SessionStore)
}
client, err := redisstore.NewClient(cfg.CacheURL)
if err != nil {
log.Fatalf("redis: %v", err)
}
ping := func(ctx context.Context) error {
return client.Ping(ctx).Err()
}
return redisstore.NewSessionRepo(client), ping, func() { _ = client.Close() }
default:
log.Fatalf("SESSION_STORE=%q не поддерживается", cfg.SessionStore)
return nil, nil, nil
}
}
+113
View File
@@ -0,0 +1,113 @@
package main
import (
"context"
"encoding/json"
"log"
"os"
"os/signal"
"syscall"
"time"
amqp "github.com/rabbitmq/amqp091-go"
"high-loud-apps-labs/internal/config"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/storage/postgres"
s3store "high-loud-apps-labs/internal/storage/s3"
"high-loud-apps-labs/internal/worker"
)
func main() {
cfg, err := config.Load()
if err != nil {
log.Fatalf("конфигурация: %v", err)
}
ctx := context.Background()
pool, err := postgres.Connect(ctx, postgres.Config{URL: cfg.DatabaseURL})
if err != nil {
log.Fatalf("БД: %v", err)
}
defer pool.Close()
store := postgres.New(pool)
objectStorage, err := s3store.New(ctx, s3store.Config{
Endpoint: cfg.S3Endpoint,
Bucket: cfg.S3Bucket,
AccessKey: cfg.S3AccessKey,
SecretKey: cfg.S3SecretKey,
UseSSL: cfg.S3UseSSL,
Region: cfg.S3Region,
})
if err != nil {
log.Fatalf("S3: %v", err)
}
pipeline := worker.NewPipeline(store.Attachments(), objectStorage, store.Variants(), store.FailedJobs(), store.Outbox())
// Цикл переподключения к RabbitMQ
for {
err := runWorker(ctx, cfg, pipeline)
if err == nil {
break // Нормальное завершение по сигналу
}
log.Printf("worker: ошибка соединения, перезапуск через 5 секунд: %v", err)
time.Sleep(5 * time.Second)
}
}
func runWorker(ctx context.Context, cfg *config.Config, pipeline *worker.Pipeline) error {
conn, err := amqp.Dial(cfg.RabbitMQURL)
if err != nil {
return err
}
defer conn.Close()
ch, err := conn.Channel()
if err != nil {
return err
}
defer ch.Close()
ch.Qos(2, 0, false)
q, err := ch.QueueDeclare("attachments.process", true, false, false, false, nil)
if err != nil {
return err
}
msgs, err := ch.Consume(q.Name, "", false, false, false, false, nil)
if err != nil {
return err
}
log.Println("worker: запущен и слушает очередь")
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
for {
select {
case <-quit:
log.Println("worker: получен сигнал завершения, останавливаемся...")
return nil
case d, ok := <-msgs:
if !ok {
return context.Canceled // Канал закрыт (соединение разорвано)
}
var msg domain.JobMessage
if err := json.Unmarshal(d.Body, &msg); err != nil {
log.Printf("worker: битое сообщение: %v", err)
_ = d.Nack(false, false)
continue
}
if err := pipeline.Process(ctx, msg.AttachmentID, msg.PipelineVersion); err != nil {
log.Printf("worker: ошибка %s: %v", msg.AttachmentID, err)
_ = d.Nack(false, true)
} else {
_ = d.Ack(false)
}
}
}
}
+73
View File
@@ -0,0 +1,73 @@
module high-loud-apps-labs
go 1.26.1
require (
github.com/gin-gonic/gin v1.12.0
github.com/google/uuid v1.6.0
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6
github.com/jackc/pgx/v5 v5.7.1
github.com/minio/minio-go/v7 v7.4.1
github.com/pressly/goose/v3 v3.22.1
github.com/redis/go-redis/v9 v9.22.0
golang.org/x/crypto v0.57.0
)
require (
github.com/ebitengine/purego v0.10.1 // indirect
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8 // indirect
)
require (
github.com/bytedance/gopkg v0.1.3 // indirect
github.com/bytedance/sonic v1.15.0 // indirect
github.com/bytedance/sonic/loader v0.5.0 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/cloudwego/base64x v0.1.6 // indirect
github.com/disintegration/imaging v1.6.2
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/gabriel-vasile/mimetype v1.4.12 // indirect
github.com/gen2brain/webp v0.6.4
github.com/gin-contrib/sse v1.1.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.30.1 // indirect
github.com/goccy/go-json v0.10.5 // indirect
github.com/goccy/go-yaml v1.19.2 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/json-iterator/go v1.1.12 // 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/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.22 // indirect
github.com/mfridman/interpolate v0.0.2 // indirect
github.com/minio/crc64nvme v1.1.1 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.4.3 // indirect
github.com/philhofer/fwd v1.2.0 // indirect
github.com/quic-go/qpack v0.6.0 // indirect
github.com/quic-go/quic-go v0.59.0 // indirect
github.com/rabbitmq/amqp091-go v1.16.0
github.com/rs/xid v1.6.0 // indirect
github.com/sethvargo/go-retry v0.3.0 // indirect
github.com/tinylib/msgp v1.6.4 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.3.1 // indirect
github.com/zeebo/xxh3 v1.1.0 // indirect
go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
go.uber.org/atomic v1.11.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
go.yaml.in/yaml/v3 v3.0.5 // indirect
golang.org/x/arch v0.22.0 // indirect
golang.org/x/net v0.60.0 // indirect
golang.org/x/sync v0.23.0 // indirect
golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.42.0 // indirect
google.golang.org/protobuf v1.36.12 // indirect
gopkg.in/ini.v1 v1.67.3 // indirect
)
+178
View File
@@ -0,0 +1,178 @@
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/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE=
github.com/bytedance/sonic v1.15.0/go.mod h1:tFkWrPz0/CUCLEF4ri4UkHekCIcdnkqXw9VduqpJh0k=
github.com/bytedance/sonic/loader v0.5.0 h1:gXH3KVnatgY7loH5/TkeVyXPfESoqSBSBEiDd5VjlgE=
github.com/bytedance/sonic/loader v0.5.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo=
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/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/ebitengine/purego v0.10.1 h1:dewVBCBT2GaMu1SrNTYxQhgQBethzfhiwvZiLGP/qyY=
github.com/ebitengine/purego v0.10.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
github.com/gen2brain/webp v0.6.4 h1:SUDdmxADOAiPQ+5ylNmuHhuYf2dOi0KgKZHL5vpVCNU=
github.com/gen2brain/webp v0.6.4/go.mod h1:iGWMaCSw7t3I/Cv9llzEKmpnR36S8lS8VL/ZVjxU0JE=
github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8=
github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w=
github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM=
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
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/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6 h1:D/V0gu4zQ3cL2WKeVNVM4r2gLxGGf6McLwgXzRTo2RQ=
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6/go.mod h1:a/s9Lp5W7n/DD0VrVoyJ00FbP2ytTPDVOivvn2bMlds=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs=
github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA=
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/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
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/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/mattn/go-isatty v0.0.22 h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
github.com/mattn/go-isatty v0.0.22/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY=
github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg=
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/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
github.com/pelletier/go-toml/v2 v2.4.3 h1:GTRvJQutkOSftxIFD5xw9aepkYNuPWmVJpffdDPYVpY=
github.com/pelletier/go-toml/v2 v2.4.3/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
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/pressly/goose/v3 v3.22.1 h1:2zICEfr1O3yTP9BRZMGPj7qFxQ+ik6yeo+z1LMuioLc=
github.com/pressly/goose/v3 v3.22.1/go.mod h1:xtMpbstWyCpyH+0cxLTMCENWBG+0CSxvTsXhW95d5eo=
github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw=
github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
github.com/rabbitmq/amqp091-go v1.16.0 h1:1O8oQqnj9hLACoo6CVMgn57z2pLWXvgemhh4GsquV+Y=
github.com/rabbitmq/amqp091-go v1.16.0/go.mod h1:Hy4jKW5kQART1u+JkDTF9YYOQUHXqMuhrgxOEeS7G4o=
github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0=
github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE=
github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas=
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.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
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/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY=
github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
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/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI=
golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8 h1:hVwzHzIUGRjiF7EcUjqNxk3NCfkPxbDKRdnNE1Rpg0U=
golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU=
golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc=
google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/ini.v1 v1.67.3 h1:iM9Lhz5MRSGhHVGGwCuzG9KO8PoirCXj/m/qTmOJJQw=
gopkg.in/ini.v1 v1.67.3/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI=
modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4=
modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E=
modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU=
modernc.org/sqlite v1.33.0 h1:WWkA/T2G17okiLGgKAj4/RMIvgyMT19yQ038160IeYk=
modernc.org/sqlite v1.33.0/go.mod h1:9uQ9hF/pCZoYZK73D/ud5Z7cIRIILSZI8NdIemVMTX8=
modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA=
modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0=
modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
+110
View File
@@ -0,0 +1,110 @@
package broker
import (
"context"
"fmt"
"sync"
"time"
amqp "github.com/rabbitmq/amqp091-go"
)
type Publisher interface {
Publish(ctx context.Context, routingKey string, body []byte) error
Close() error
}
type RabbitPublisher struct {
url string
mu sync.Mutex
conn *amqp.Connection
ch *amqp.Channel
confirms chan amqp.Confirmation
}
func NewRabbitPublisher(url string) (*RabbitPublisher, error) {
p := &RabbitPublisher{url: url}
if err := p.connect(); err != nil {
return nil, err
}
return p, nil
}
func (p *RabbitPublisher) connect() error {
var err error
p.conn, err = amqp.Dial(p.url)
if err != nil {
return fmt.Errorf("подключение к rabbitmq: %w", err)
}
p.ch, err = p.conn.Channel()
if err != nil {
return fmt.Errorf("открытие канала rabbitmq: %w", err)
}
if err := p.ch.Confirm(false); err != nil {
return fmt.Errorf("включение режима confirm: %w", err)
}
p.confirms = p.ch.NotifyPublish(make(chan amqp.Confirmation, 1))
err = p.ch.ExchangeDeclare("attachments", "direct", true, false, false, false, nil)
if err != nil {
return fmt.Errorf("объявление exchange: %w", err)
}
_, err = p.ch.QueueDeclare("attachments.process", true, false, false, false, nil)
if err != nil {
return fmt.Errorf("объявление очереди: %w", err)
}
err = p.ch.QueueBind("attachments.process", "process", "attachments", false, nil)
if err != nil {
return fmt.Errorf("привязка очереди: %w", err)
}
return nil
}
func (p *RabbitPublisher) Publish(ctx context.Context, routingKey string, body []byte) error {
p.mu.Lock()
defer p.mu.Unlock()
if p.conn == nil || p.conn.IsClosed() {
if err := p.connect(); err != nil {
return err
}
}
err := p.ch.PublishWithContext(ctx, "attachments", routingKey, false, false, amqp.Publishing{
ContentType: "application/json",
DeliveryMode: amqp.Persistent,
Body: body,
})
if err != nil {
return err
}
select {
case confirm := <-p.confirms:
if !confirm.Ack {
return fmt.Errorf("сообщение отклонено брокером")
}
return nil
case <-time.After(5 * time.Second):
return fmt.Errorf("таймаут ожидания подтверждения от rabbitmq")
case <-ctx.Done():
return ctx.Err()
}
}
func (p *RabbitPublisher) Close() error {
p.mu.Lock()
defer p.mu.Unlock()
if p.ch != nil {
_ = p.ch.Close()
}
if p.conn != nil {
return p.conn.Close()
}
return nil
}
+246
View File
@@ -0,0 +1,246 @@
package config
import (
"fmt"
"os"
"strconv"
"strings"
"time"
)
type Config struct {
Host string
Port string
DatabaseURL string
SessionStore string
CacheURL string
SessionTTL time.Duration
IdempotencyTTL time.Duration
ShutdownDrain time.Duration
S3Endpoint string
S3Bucket string
S3UseSSL bool
S3Region string
S3AccessKey string
S3SecretKey string
MaxUploadBytes int64
MaxImagePixels int64
ReconcilerEnabled bool
ReconcilerInterval time.Duration
ReconcilerGracePeriod time.Duration
RabbitMQURL string
OutboxInterval time.Duration
}
func Load() (*Config, error) {
dsn, err := readSecret("DATABASE_URL_FILE", "DATABASE_URL")
if err != nil {
return nil, fmt.Errorf("database url: %w", err)
}
cacheURL, err := readSecretOptional("CACHE_URL_FILE", "CACHE_URL")
if err != nil {
return nil, fmt.Errorf("cache url: %w", err)
}
ttlSeconds, err := readInt("SESSION_TTL_SECONDS", 3600)
if err != nil {
return nil, fmt.Errorf("SESSION_TTL_SECONDS: %w", err)
}
if ttlSeconds <= 0 {
return nil, fmt.Errorf("SESSION_TTL_SECONDS должен быть положительным")
}
idemSeconds, err := readInt("IDEMPOTENCY_TTL_SECONDS", 86400)
if err != nil {
return nil, fmt.Errorf("IDEMPOTENCY_TTL_SECONDS: %w", err)
}
if idemSeconds <= 0 {
return nil, fmt.Errorf("IDEMPOTENCY_TTL_SECONDS должен быть положительным")
}
drainSeconds, err := readInt("SHUTDOWN_DRAIN_SECONDS", 3)
if err != nil {
return nil, fmt.Errorf("SHUTDOWN_DRAIN_SECONDS: %w", err)
}
if drainSeconds < 0 {
return nil, fmt.Errorf("SHUTDOWN_DRAIN_SECONDS не может быть отрицательным")
}
store := strings.ToLower(getenv("SESSION_STORE", "postgres"))
switch store {
case "postgres", "redis", "valkey":
default:
return nil, fmt.Errorf("SESSION_STORE=%q не поддерживается", store)
}
s3Endpoint := getenv("S3_ENDPOINT", "")
s3Bucket := getenv("S3_BUCKET", "")
s3UseSSL, err := readBool("S3_USE_SSL", false)
if err != nil {
return nil, fmt.Errorf("S3_USE_SSL: %w", err)
}
s3Region := getenv("S3_REGION", "us-east-1")
s3AccessKey, err := readSecretOptional("S3_ACCESS_KEY_ID_FILE", "S3_ACCESS_KEY_ID")
if err != nil {
return nil, fmt.Errorf("s3 access key: %w", err)
}
s3SecretKey, err := readSecretOptional("S3_SECRET_ACCESS_KEY_FILE", "S3_SECRET_ACCESS_KEY")
if err != nil {
return nil, fmt.Errorf("s3 secret key: %w", err)
}
maxUploadBytes, err := readInt64("MAX_UPLOAD_BYTES", 10485760)
if err != nil {
return nil, fmt.Errorf("MAX_UPLOAD_BYTES: %w", err)
}
if maxUploadBytes <= 0 {
return nil, fmt.Errorf("MAX_UPLOAD_BYTES должен быть положительным")
}
maxImagePixels, err := readInt64("MAX_IMAGE_PIXELS", 40000000)
if err != nil {
return nil, fmt.Errorf("MAX_IMAGE_PIXELS: %w", err)
}
if maxImagePixels <= 0 {
return nil, fmt.Errorf("MAX_IMAGE_PIXELS должен быть положительным")
}
reconcilerEnabled, err := readBool("RECONCILER_ENABLED", true)
if err != nil {
return nil, fmt.Errorf("RECONCILER_ENABLED: %w", err)
}
reconcilerIntervalSec, err := readInt("RECONCILER_INTERVAL_SECONDS", 300)
if err != nil {
return nil, fmt.Errorf("RECONCILER_INTERVAL_SECONDS: %w", err)
}
if reconcilerIntervalSec <= 0 {
return nil, fmt.Errorf("RECONCILER_INTERVAL_SECONDS должен быть положительным")
}
reconcilerGraceSec, err := readInt("RECONCILER_GRACE_SECONDS", 3600)
if err != nil {
return nil, fmt.Errorf("RECONCILER_GRACE_SECONDS: %w", err)
}
if reconcilerGraceSec <= 0 {
return nil, fmt.Errorf("RECONCILER_GRACE_SECONDS должен быть положительным")
}
rabbitURL, err := readSecretOptional("RABBITMQ_URL_FILE", "RABBITMQ_URL")
if err != nil {
return nil, fmt.Errorf("rabbitmq url: %w", err)
}
outboxMs, err := readInt("OUTBOX_INTERVAL_MS", 1000)
if err != nil {
return nil, fmt.Errorf("OUTBOX_INTERVAL_MS: %w", err)
}
return &Config{
Host: getenv("APP_HOST", "0.0.0.0"),
Port: getenv("APP_PORT", "8080"),
DatabaseURL: dsn,
SessionStore: store,
CacheURL: cacheURL,
SessionTTL: time.Duration(ttlSeconds) * time.Second,
IdempotencyTTL: time.Duration(idemSeconds) * time.Second,
ShutdownDrain: time.Duration(drainSeconds) * time.Second,
S3Endpoint: s3Endpoint,
S3Bucket: s3Bucket,
S3UseSSL: s3UseSSL,
S3Region: s3Region,
S3AccessKey: s3AccessKey,
S3SecretKey: s3SecretKey,
MaxUploadBytes: maxUploadBytes,
MaxImagePixels: maxImagePixels,
ReconcilerEnabled: reconcilerEnabled,
ReconcilerInterval: time.Duration(reconcilerIntervalSec) * time.Second,
ReconcilerGracePeriod: time.Duration(reconcilerGraceSec) * time.Second,
RabbitMQURL: rabbitURL,
OutboxInterval: time.Duration(outboxMs) * time.Millisecond,
}, nil
}
func (c *Config) S3Configured() bool {
return c.S3Endpoint != "" &&
c.S3Bucket != "" &&
c.S3AccessKey != "" &&
c.S3SecretKey != ""
}
func getenv(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
func readInt(key string, def int) (int, error) {
v := os.Getenv(key)
if v == "" {
return def, nil
}
n, err := strconv.Atoi(v)
if err != nil {
return 0, fmt.Errorf("не целое число: %q", v)
}
return n, nil
}
func readInt64(key string, def int64) (int64, error) {
v := os.Getenv(key)
if v == "" {
return def, nil
}
n, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return 0, fmt.Errorf("не целое число: %q", v)
}
return n, nil
}
func readBool(key string, def bool) (bool, error) {
v := os.Getenv(key)
if v == "" {
return def, nil
}
b, err := strconv.ParseBool(v)
if err != nil {
return false, fmt.Errorf("не bool: %q", v)
}
return b, nil
}
func readSecret(fileEnv, envKey string) (string, error) {
v, err := readSecretOptional(fileEnv, envKey)
if err != nil {
return "", err
}
if v == "" {
return "", fmt.Errorf("не задан %s или %s", fileEnv, envKey)
}
return v, nil
}
func readSecretOptional(fileEnv, envKey string) (string, error) {
if path := os.Getenv(fileEnv); path != "" {
b, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("чтение %s=%s: %w", fileEnv, path, err)
}
s := strings.TrimSpace(string(b))
if s == "" {
return "", fmt.Errorf("файл %s пуст", path)
}
return s, nil
}
return os.Getenv(envKey), nil
}
@@ -0,0 +1,21 @@
package domain
import "time"
type AttachmentVariant struct {
AttachmentID string
Name string
ObjectKey string
ContentType string
SizeBytes int64
Width int
Height int
SHA256 []byte
CreatedAt time.Time
}
const (
VariantThumbnail = "thumbnail"
VariantCrop = "crop"
VariantOptimized = "optimized"
)
+70
View File
@@ -0,0 +1,70 @@
package domain
import "time"
type Health struct {
Status string
}
type User struct {
ID string
Username string
DisplayName string
PasswordHash string // в DTO UserResponse его не будет
CreatedAt time.Time
}
type Chat struct {
ID string
Title string
MemberIDs []string
CreatedAt time.Time
}
type Message struct {
ID string
ChatID string
SenderID string
Text string
AttachmentIDs []string
CreatedAt time.Time
}
type Session struct {
TokenHash []byte
UserID string
ExpiresAt time.Time
CreatedAt time.Time
}
type AttachmentStatus string
const (
AttachmentStatusQueued AttachmentStatus = "queued"
AttachmentStatusProcessing AttachmentStatus = "processing"
AttachmentStatusReady AttachmentStatus = "ready"
AttachmentStatusFailed AttachmentStatus = "failed"
)
type Attachment struct {
ID string
ChatID string
OwnerID string
Filename string
ContentType string
SizeBytes int64
SHA256 []byte
ObjectKey string
Status AttachmentStatus
ErrorCode *string
CreatedAt time.Time
UpdatedAt time.Time
Attempts int // авторитетный счётчик попыток (в БД)
NextAttemptAt *time.Time // "не раньше"; nil = можно брать сразу
LockedUntil *time.Time // lease; nil = не арендовано
PipelineVersion int // guard в CompleteJob; в БД default 1
StagingKey string // S3-ключ оригинала до 202; "" в lab4-пути
Variants []AttachmentVariant
}
+197
View File
@@ -0,0 +1,197 @@
package domain
// Этот файл — единственный источник доменных ошибок.
// Правила:
// 1. sentinel-ошибки (ErrXxx) нужны для errors.Is.
// 2. типы *XxxError нужны для errors.As и для поля code в JSON.
// 3. У каждого типа есть Code() ErrorCode — через него DTO маппит
// в HTTP-код (StatusFromError в httpapi/dto/error.go).
// 4. В Error() пишем только то, что безопасно показать клиенту:
// без SQL, stack trace, путей, credential'ов.
import (
"errors"
"fmt"
)
// ===================================================================
// ErrorCode — машинный код для JSON {"error":{"code":"..."}}
// ===================================================================
type ErrorCode string
const (
CodeInvalidRequest ErrorCode = "invalid_request" // 400
CodeUnauthorized ErrorCode = "unauthorized" // 401
CodeNotFound ErrorCode = "not_found" // 404
CodeConflict ErrorCode = "conflict" // 409
CodePayloadTooLarge ErrorCode = "payload_too_large" // 413
CodeUnsupportedMediaType ErrorCode = "unsupported_media_type" // 415
CodeUnavailable ErrorCode = "unavailable" // 503
CodeInternalError ErrorCode = "internal_error" // 500
)
// ===================================================================
// Sentinel-ошибки (errors.Is)
// ===================================================================
var (
ErrNotFound = errors.New("не найдено")
ErrAlreadyExists = errors.New("уже существует")
ErrInvalidInput = errors.New("некорректные данные")
ErrUnauthorized = errors.New("требуется аутентификация")
ErrUnsupportedMediaType = errors.New("неподдерживаемый тип содержимого")
ErrPayloadTooLarge = errors.New("превышен допустимый размер")
ErrUnavailable = errors.New("сервис недоступен")
ErrConflict = errors.New("конфликт")
)
// ===================================================================
// 404 Not Found
// ===================================================================
type NotFoundError struct {
Entity string
ID string
}
func (e *NotFoundError) Error() string {
return fmt.Sprintf("%s с id %q не найден", e.Entity, e.ID)
}
func (e *NotFoundError) Unwrap() error { return ErrNotFound }
func (e *NotFoundError) Code() ErrorCode { return CodeNotFound }
// ===================================================================
// 409 Conflict
// ===================================================================
// AlreadyExistsError — конфликт уникальности (например, username занят).
// Отдельно от ConflictError: другой смысл, но оба дают HTTP 409.
type AlreadyExistsError struct {
Entity string
Field string
Value string
}
func (e *AlreadyExistsError) Error() string {
return fmt.Sprintf("%s с %s %q уже существует", e.Entity, e.Field, e.Value)
}
func (e *AlreadyExistsError) Unwrap() error { return ErrAlreadyExists }
func (e *AlreadyExistsError) Code() ErrorCode { return CodeConflict }
// IdempotencyConflictError — тот же Idempotency-Key, но другое тело запроса.
type IdempotencyConflictError struct {
Key string
}
func (e *IdempotencyConflictError) Error() string {
return "Idempotency-Key " + e.Key + " уже использован с другим телом запроса"
}
func (e *IdempotencyConflictError) Unwrap() error { return ErrAlreadyExists }
func (e *IdempotencyConflictError) Code() ErrorCode { return CodeConflict }
// ConflictError — конфликт бизнес-состояния, а не уникальности.
// Примеры: "вложение ещё не готово", "нельзя перевести failed-вложение в ready".
// Reason — короткая безопасная фраза, идёт клиенту как message.
type ConflictError struct{ Reason string }
func (e *ConflictError) Error() string { return e.Reason }
func (e *ConflictError) Unwrap() error { return ErrConflict }
func (e *ConflictError) Code() ErrorCode { return CodeConflict }
// ===================================================================
// 400 Bad Request
// ===================================================================
// ValidationError — неверное поле или формат.
type ValidationError struct {
Field string
Message string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("ошибка валидации поля %q: %s", e.Field, e.Message)
}
func (e *ValidationError) Unwrap() error { return ErrInvalidInput }
func (e *ValidationError) Code() ErrorCode { return CodeInvalidRequest }
// ===================================================================
// 401 Unauthorized
// ===================================================================
// UnauthorizedError — нет/просрочен/отозван токен, неверные credentials.
// Reason — только для логов, в JSON не попадает (по контракту все 401
// должны иметь одинаковое сообщение, чтобы не перебирать username).
type UnauthorizedError struct {
Reason string
}
func (e *UnauthorizedError) Error() string {
return "требуется аутентификация"
}
func (e *UnauthorizedError) Unwrap() error { return ErrUnauthorized }
func (e *UnauthorizedError) Code() ErrorCode { return CodeUnauthorized }
// ===================================================================
// 415 Unsupported Media Type
// ===================================================================
// UnsupportedMediaTypeError — неверный Content-Type.
//
// ВАЖНО: сейчас текст жёстко про application/json. Для lab4 (вложения)
// ожидается image/png или image/jpeg. Прежде чем использовать этот тип
// в AttachmentHandler, добавить поле Expected string (дефолт application/json)
// или сделать отдельный тип — не переиспользовать как есть, иначе клиент
// увидит неверную подсказку.
type UnsupportedMediaTypeError struct {
MediaType string
Expected string
}
func (e *UnsupportedMediaTypeError) Error() string {
expected := e.Expected
if expected == "" {
expected = "application/json"
}
if e.MediaType == "" {
return "требуется Content-Type: " + expected
}
return fmt.Sprintf("неподдерживаемый Content-Type %q; требуется %s", e.MediaType, expected)
}
func (e *UnsupportedMediaTypeError) Unwrap() error { return ErrUnsupportedMediaType }
func (e *UnsupportedMediaTypeError) Code() ErrorCode { return CodeUnsupportedMediaType }
// ===================================================================
// 413 Payload Too Large
// ===================================================================
// PayloadTooLargeError — тело больше лимита.
// Message опционален: если пуст — формируется из Limit.
type PayloadTooLargeError struct {
Limit int64
Message string
}
func (e *PayloadTooLargeError) Error() string {
if e.Message != "" {
return e.Message
}
return fmt.Sprintf("превышен лимит %d байт", e.Limit)
}
func (e *PayloadTooLargeError) Unwrap() error { return ErrPayloadTooLarge }
func (e *PayloadTooLargeError) Code() ErrorCode { return CodePayloadTooLarge }
// ===================================================================
// 503 Service Unavailable
// ===================================================================
// UnavailableError — недоступна критичная зависимость (БД, кэш, S3).
// Reason — только для логов; клиент видит общее сообщение по контракту,
// чтобы не раскрывать имена сервисов и топологию.
type UnavailableError struct{ Reason string }
func (e *UnavailableError) Error() string {
return "сервис временно недоступен"
}
func (e *UnavailableError) Unwrap() error { return ErrUnavailable }
func (e *UnavailableError) Code() ErrorCode { return CodeUnavailable }
+17
View File
@@ -0,0 +1,17 @@
package domain
import "time"
// FailedJob — реестр окончательно проваленных задач (DLQ-сторона).
// Заполняется worker'ом после исчерпания retry или при permanent-ошибке.
// Читается для операторского просмотра и для явного replay (Этап 5).
type FailedJob struct {
ID string
AttachmentID string
ReasonCode string // из jobcodes.go
Attempts int
LastErrorAt time.Time
ResolvedAt *time.Time // nil = не разобрана
Resolution string // "replayed", "manual_fix", ...
CreatedAt time.Time
}
+33
View File
@@ -0,0 +1,33 @@
package domain
import (
"crypto/sha256"
)
type IdempotencyScope struct {
UserID string
Method string
Path string
Key string
}
type CreateIdempotentResult struct {
Status int
Body []byte
Replayed bool
}
func RequestHash(text string, attachmentIDs []string) []byte {
if len(attachmentIDs) == 0 {
sum := sha256.Sum256([]byte(text))
return sum[:]
}
h := sha256.New()
h.Write([]byte(text))
h.Write([]byte{0})
for _, id := range attachmentIDs {
h.Write([]byte(id))
h.Write([]byte{0})
}
return h.Sum(nil)
}
+7
View File
@@ -0,0 +1,7 @@
package domain
type JobMessage struct {
AttachmentID string `json:"attachment_id"`
PipelineVersion int `json:"pipeline_version"`
Attempt int `json:"attempt"`
}
+10
View File
@@ -0,0 +1,10 @@
package domain
const (
JobErrorDecodeFailed = "decode_failed"
JobErrorTooLarge = "too_large"
JobErrorUnsupportedFormat = "unsupported_format"
JobErrorStorage = "storage_error"
JobErrorInternal = "internal_error"
JobErrorRetryExhausted = "retry_exhausted"
)
+28
View File
@@ -0,0 +1,28 @@
package domain
import "time"
const (
OutboxAggregateAttachment = "attachment"
OutboxEventProcess = "attachment.process"
)
// OutboxEntry — намерение опубликовать сообщение, записанное
// в одной транзакции с бизнес-изменением (transactional outbox).
//
// Инварианты:
// - PublishedAt == nil => ещё не опубликовано, publisher обязан дослать;
// - PublishedAt != nil => RabbitMQ принял сообщение,
// а не «мы вызвали Publish». At-least-once: повторная доставка
// возможна и нормальна, гасится идемпотентностью consumer'а.
//
type OutboxEntry struct {
ID string
AggregateType string
AggregateID string
EventType string
Payload []byte
CreatedAt time.Time
PublishedAt *time.Time
Attempts int
}
+77
View File
@@ -0,0 +1,77 @@
package domain
import (
"context"
"time"
)
type UserRepository interface {
Create(ctx context.Context, user *User) error
GetByID(ctx context.Context, id string) (*User, error)
GetByUsername(ctx context.Context, username string) (*User, error)
}
type ChatRepository interface {
Create(ctx context.Context, chat *Chat) error
GetByID(ctx context.Context, id string) (*Chat, error)
ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]Chat, *string, error)
}
type MessageRepository interface {
Create(ctx context.Context, message *Message) error
ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]Message, *string, error)
CreateIdempotent(
ctx context.Context,
scope IdempotencyScope,
requestHash []byte,
fresh *Message,
freshResponse []byte,
ttl time.Duration,
) (*CreateIdempotentResult, error)
}
type SessionRepository interface {
Create(ctx context.Context, session *Session) error
GetByTokenHash(ctx context.Context, tokenHash []byte) (*Session, error)
DeleteByTokenHash(ctx context.Context, tokenHash []byte) error
}
type AttachmentRepository interface {
Create(ctx context.Context, a *Attachment) error
GetByID(ctx context.Context, id string) (*Attachment, error)
MarkReady(ctx context.Context, id string) error
MarkFailed(ctx context.Context, id string, errorCode string) error
ExistingKeys(ctx context.Context, keys []string) ([]string, error)
CreateInTx(ctx context.Context, tx Tx, a *Attachment) error
ResetForReplay(ctx context.Context, tx Tx, id string) error
ListExpiredLeases(ctx context.Context, limit int) ([]Attachment, error)
ResetLease(ctx context.Context, id string) error
ListStagingToCleanup(ctx context.Context, limit int) ([]Attachment, error)
ClearStagingKey(ctx context.Context, id string) error
}
type OutboxRepository interface {
Enqueue(ctx context.Context, tx Tx, e *OutboxEntry) error
ClaimBatch(ctx context.Context, limit int) ([]OutboxEntry, error)
MarkPublished(ctx context.Context, ids []string) error
EnqueueDirect(ctx context.Context, e *OutboxEntry) error
}
type AttachmentJobRepository interface {
ClaimForProcessing(ctx context.Context, id string, version int, lease time.Duration) (*Attachment, error)
CompleteJob(ctx context.Context, id string, pipelineVersion int, variants []AttachmentVariant) (bool, error)
FailJob(ctx context.Context, id string, errorCode string) error
ScheduleRetry(ctx context.Context, id string, nextAttemptAt time.Time, errorCode string) error
}
type AttachmentVariantRepository interface {
Upsert(ctx context.Context, tx Tx, v *AttachmentVariant) error
ListByAttachment(ctx context.Context, id string) ([]AttachmentVariant, error)
}
type FailedJobRepository interface {
Record(ctx context.Context, f *FailedJob) error
Resolve(ctx context.Context, attachmentID string, resolution string) error
ResolveInTx(ctx context.Context, tx Tx, id string) error
}
+21
View File
@@ -0,0 +1,21 @@
package domain
import (
"context"
"io"
"time"
)
type ObjectInfo struct {
Key string
LastModified time.Time
Size int64
}
type ObjectStorage interface {
Ping(ctx context.Context) error
Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error
Get(ctx context.Context, key string) (io.ReadCloser, int64, string, error)
Delete(ctx context.Context, key string) error
List(ctx context.Context, prefix string) ([]ObjectInfo, error)
}
+18
View File
@@ -0,0 +1,18 @@
package domain
import "context"
// Tx — минимальная абстракция транзакции, нужная domain-слою.
// Реализуется адаптером над pgx.Tx в storage/postgres, поэтому
// domain не зависит от драйвера БД.
//
// Зачем: transactional outbox требует, чтобы бизнес-изменение
// (например, INSERT attachments) и INSERT outbox шли в одной
// транзакции. Без передачи транзакции в репозиторий эту гарантию
// не выразить.
//
// Метод один — Exec. Расширять по мере появления реальных
// потребителей, а не на будущее.
type Tx interface {
Exec(ctx context.Context, sql string, args ...any) error
}
@@ -0,0 +1,60 @@
package dto
import (
"encoding/hex"
"high-loud-apps-labs/internal/domain"
)
type VariantResponse struct {
Name string `json:"name"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
Width int `json:"width"`
Height int `json:"height"`
SHA256 string `json:"sha256"`
}
type AttachmentResponse struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
OwnerID string `json:"owner_id"`
Filename string `json:"filename"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
SHA256 string `json:"sha256"`
Status string `json:"status"`
Variants []VariantResponse `json:"variants"`
ErrorCode *string `json:"error_code"`
CreatedAt string `json:"created_at"`
UpdatedAt string `json:"updated_at"`
}
func AttachmentFromDomain(a *domain.Attachment) AttachmentResponse {
variants := make([]VariantResponse, len(a.Variants))
for i, v := range a.Variants {
variants[i] = VariantResponse{
Name: v.Name,
ContentType: v.ContentType,
SizeBytes: v.SizeBytes,
Width: v.Width,
Height: v.Height,
SHA256: hex.EncodeToString(v.SHA256),
}
}
errCode := a.ErrorCode
return AttachmentResponse{
ID: a.ID,
ChatID: a.ChatID,
OwnerID: a.OwnerID,
Filename: a.Filename,
ContentType: a.ContentType,
SizeBytes: a.SizeBytes,
SHA256: hex.EncodeToString(a.SHA256),
Status: string(a.Status),
Variants: variants,
ErrorCode: errCode,
CreatedAt: a.CreatedAt.UTC().Format(timeFormat),
UpdatedAt: a.UpdatedAt.UTC().Format(timeFormat),
}
}
+39
View File
@@ -0,0 +1,39 @@
package dto
import (
"high-loud-apps-labs/internal/domain"
)
type CreateChatRequest struct {
Title string `json:"title" binding:"required,min=1,max=100"`
MemberIDs []string `json:"member_ids" binding:"required,min=1,max=100,dive,uuid"`
}
type ChatResponse struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt string `json:"created_at"`
}
type ChatPageResponse struct {
Items []ChatResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func ChatFromDomain(c *domain.Chat) ChatResponse {
return ChatResponse{
ID: c.ID,
Title: c.Title,
MemberIDs: append([]string(nil), c.MemberIDs...),
CreatedAt: c.CreatedAt.UTC().Format(timeFormat),
}
}
func ChatsFromDomain(items []domain.Chat) []ChatResponse {
out := make([]ChatResponse, len(items))
for i := range items {
out[i] = ChatFromDomain(&items[i])
}
return out
}
+86
View File
@@ -0,0 +1,86 @@
package dto
import (
"errors"
"high-loud-apps-labs/internal/domain"
)
// делаем вложенный ответ через вкладку ErrorBody в обертку.
type ErrorBody struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
type ErrorResponse struct {
Error ErrorBody `json:"error"`
}
type coded interface {
Code() domain.ErrorCode
}
func ErrorFromDomain(err error, requestID string) ErrorResponse {
var c coded
if errors.As(err, &c) {
code := c.Code()
message := err.Error()
if code == domain.CodeInternalError {
message = "внутренняя ошибка"
}
return ErrorResponse{Error: ErrorBody{
Code: string(code),
Message: message,
RequestID: requestID,
}}
}
code := domain.CodeInternalError
switch {
case errors.Is(err, domain.ErrNotFound):
code = domain.CodeNotFound
case errors.Is(err, domain.ErrAlreadyExists):
code = domain.CodeConflict
case errors.Is(err, domain.ErrInvalidInput):
code = domain.CodeInvalidRequest
case errors.Is(err, domain.ErrUnauthorized):
code = domain.CodeUnauthorized
case errors.Is(err, domain.ErrUnsupportedMediaType):
code = domain.CodeUnsupportedMediaType
case errors.Is(err, domain.ErrUnavailable):
code = domain.CodeUnavailable
}
message := err.Error()
if code == domain.CodeInternalError {
message = "внутренняя ошибка"
}
return ErrorResponse{Error: ErrorBody{
Code: string(code),
Message: message,
RequestID: requestID,
}}
}
func StatusFromError(err error) int {
switch {
case errors.Is(err, domain.ErrNotFound):
return 404
case errors.Is(err, domain.ErrAlreadyExists):
return 409
case errors.Is(err, domain.ErrInvalidInput):
return 400
case errors.Is(err, domain.ErrUnauthorized):
return 401
case errors.Is(err, domain.ErrUnsupportedMediaType):
return 415
case errors.Is(err, domain.ErrUnavailable):
return 503
case errors.Is(err, domain.ErrPayloadTooLarge):
return 413
case errors.Is(err, domain.ErrConflict):
return 409
default:
return 500
}
}
+5
View File
@@ -0,0 +1,5 @@
package dto
type HealthResponse struct {
Status string `json:"status"`
}
+47
View File
@@ -0,0 +1,47 @@
package dto
import (
"high-loud-apps-labs/internal/domain"
)
type CreateMessageRequest struct {
Text string `json:"text" binding:"max=4000"`
AttachmentIDs []string `json:"attachment_ids" binding:"max=10,dive,uuid"`
}
type MessageResponse struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
CreatedAt string `json:"created_at"`
}
type MessagePageResponse struct {
Items []MessageResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func MessageFromDomain(m *domain.Message) MessageResponse {
ids := m.AttachmentIDs
if ids == nil {
ids = []string{}
}
return MessageResponse{
ID: m.ID,
ChatID: m.ChatID,
SenderID: m.SenderID,
Text: m.Text,
AttachmentIDs: ids,
CreatedAt: m.CreatedAt.UTC().Format(timeFormat),
}
}
func MessagesFromDomain(items []domain.Message) []MessageResponse {
out := make([]MessageResponse, len(items))
for i := range items {
out[i] = MessageFromDomain(&items[i])
}
return out
}
+21
View File
@@ -0,0 +1,21 @@
package dto
import (
"high-loud-apps-labs/internal/domain"
)
type SessionResponse struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt string `json:"expires_at"`
User UserResponse `json:"user"`
}
func SessionResponseFromDomain(s *domain.Session, token string, u *domain.User) SessionResponse {
return SessionResponse{
Token: token,
TokenType: "Bearer",
ExpiresAt: s.ExpiresAt.UTC().Format(timeFormat),
User: UserFromDomain(u),
}
}
+29
View File
@@ -0,0 +1,29 @@
package dto
import (
"high-loud-apps-labs/internal/domain"
)
const timeFormat = "2006-01-02T15:04:05.000000Z07:00"
type CreateUserRequest struct {
Username string `json:"username" binding:"required,min=3,max=32"`
DisplayName string `json:"display_name" binding:"required,min=1,max=100"`
Password string `json:"password" binding:"required,min=12,max=512"`
}
type UserResponse struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt string `json:"created_at"`
}
func UserFromDomain(u *domain.User) UserResponse {
return UserResponse{
ID: u.ID,
Username: u.Username,
DisplayName: u.DisplayName,
CreatedAt: u.CreatedAt.UTC().Format(timeFormat),
}
}
@@ -0,0 +1,111 @@
package handler
import (
"mime"
"net/http"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
type AttachmentHandler struct {
svc *service.AttachmentService
}
func NewAttachmentHandler(svc *service.AttachmentService) *AttachmentHandler {
return &AttachmentHandler{svc: svc}
}
func (h *AttachmentHandler) Upload(c *gin.Context) {
me := middleware.CurrentUser(c)
chatID, err := parseUUIDPathParam(c, "chat_id")
if err != nil {
respondError(c, err)
return
}
filename := c.Query("filename")
if filename == "" {
respondError(c, &domain.ValidationError{
Field: "filename",
Message: "обязателен",
})
return
}
mediaType, _, err := mime.ParseMediaType(c.GetHeader("Content-Type"))
if err != nil || (mediaType != "image/png" && mediaType != "image/jpeg") {
respondError(c, &domain.UnsupportedMediaTypeError{
MediaType: c.GetHeader("Content-Type"),
Expected: "image/png или image/jpeg",
})
return
}
att, err := h.svc.Upload(c.Request.Context(), me.ID, chatID, filename, c.Request.Body)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusAccepted, dto.AttachmentFromDomain(att))
}
func (h *AttachmentHandler) Get(c *gin.Context) {
me := middleware.CurrentUser(c)
attachmentID, err := parseUUIDPathParam(c, "attachment_id")
if err != nil {
respondError(c, err)
return
}
a, err := h.svc.Get(c.Request.Context(), me.ID, attachmentID)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusOK, dto.AttachmentFromDomain(a))
}
func (h *AttachmentHandler) Content(c *gin.Context) {
me := middleware.CurrentUser(c)
attachmentID, err := parseUUIDPathParam(c, "attachment_id")
if err != nil {
respondError(c, err)
return
}
variant := c.DefaultQuery("variant", "original")
rc, size, contentType, err := h.svc.Download(c.Request.Context(), me.ID, attachmentID, variant)
if err != nil {
respondError(c, err)
return
}
defer func() { _ = rc.Close() }()
c.DataFromReader(http.StatusOK, size, contentType, rc, nil)
}
func (h *AttachmentHandler) Replay(c *gin.Context) {
me := middleware.CurrentUser(c)
attachmentID, err := parseUUIDPathParam(c, "attachment_id")
if err != nil {
respondError(c, err)
return
}
if err := h.svc.Replay(c.Request.Context(), me.ID, attachmentID); err != nil {
respondError(c, err)
return
}
c.Status(http.StatusAccepted)
}
+77
View File
@@ -0,0 +1,77 @@
package handler
import (
"encoding/base64"
"net/http"
"strings"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
type AuthHandler struct {
sessions *service.SessionService
}
func NewAuthHandler(sessions *service.SessionService) *AuthHandler {
return &AuthHandler{sessions: sessions}
}
func (h *AuthHandler) CreateSession(c *gin.Context) {
username, password, err := parseBasicAuth(c)
if err != nil {
respondBasicChallenge(c, err)
return
}
session, token, user, err := h.sessions.Login(c.Request.Context(), username, password)
if err != nil {
respondBasicChallenge(c, err)
return
}
c.JSON(http.StatusCreated, dto.SessionResponseFromDomain(session, token, user))
}
// RevokeCurrent отзывает текущую сессию. Токен уже проверен BearerAuth,
// поэтому здесь его достаточно передать в SessionService.
func (h *AuthHandler) RevokeCurrent(c *gin.Context) {
token := middleware.CurrentToken(c)
if token == "" {
respondError(c, &domain.UnauthorizedError{Reason: "нет токена"})
return
}
if err := h.sessions.Revoke(c.Request.Context(), token); err != nil {
respondError(c, err)
return
}
c.Status(http.StatusNoContent)
}
// parseBasicAuth читает Authorization: Basic base64(username:password).
func parseBasicAuth(c *gin.Context) (string, string, error) {
const prefix = "Basic "
auth := c.GetHeader("Authorization")
if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) {
return "", "", &domain.UnauthorizedError{Reason: "требуется Basic"}
}
decoded, err := base64.StdEncoding.DecodeString(auth[len(prefix):])
if err != nil {
return "", "", &domain.UnauthorizedError{Reason: "некорректный Base64"}
}
username, password, ok := strings.Cut(string(decoded), ":")
if !ok || username == "" {
return "", "", &domain.UnauthorizedError{Reason: "некорректный Basic-формат"}
}
return username, password, nil
}
+52
View File
@@ -0,0 +1,52 @@
package handler
import (
"bytes"
"encoding/json"
"errors"
"io"
"mime"
"strings"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
"high-loud-apps-labs/internal/domain"
)
func bindStrictJSON(c *gin.Context, dst any) error {
ct := c.GetHeader("Content-Type")
mediaType, _, err := mime.ParseMediaType(ct)
if ct == "" || err != nil || !strings.EqualFold(mediaType, "application/json") {
return &domain.UnsupportedMediaTypeError{MediaType: ct}
}
body, err := io.ReadAll(c.Request.Body)
if err != nil {
return &badRequestError{msg: "не удалось прочитать тело запроса"}
}
_ = c.Request.Body.Close()
dec := json.NewDecoder(bytes.NewReader(body))
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
if errors.Is(err, io.EOF) {
return &badRequestError{msg: "тело запроса обязательно"}
}
return &badRequestError{msg: err.Error()}
}
// Отклоняем любой непустой остаток после первого JSON-значения.
var extra json.RawMessage
if err := dec.Decode(&extra); !errors.Is(err, io.EOF) {
return &badRequestError{msg: "тело запроса содержит данные после JSON"}
}
if v := binding.Validator; v != nil {
if err := v.ValidateStruct(dst); err != nil {
return &badRequestError{msg: err.Error()}
}
}
return nil
}
+88
View File
@@ -0,0 +1,88 @@
package handler
import (
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
type ChatHandler struct {
chats *service.ChatService
}
func NewChatHandler(chats *service.ChatService) *ChatHandler {
return &ChatHandler{chats: chats}
}
func (h *ChatHandler) Create(c *gin.Context) {
var req dto.CreateChatRequest
if err := bindStrictJSON(c, &req); err != nil {
respondError(c, err)
return
}
me := middleware.CurrentUser(c)
chat, err := h.chats.Create(c.Request.Context(), me.ID, req.Title, req.MemberIDs)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusCreated, dto.ChatFromDomain(chat))
}
func (h *ChatHandler) Get(c *gin.Context) {
me := middleware.CurrentUser(c)
chatID, err := parseUUIDPathParam(c, "chat_id")
if err != nil {
respondError(c, err)
return
}
chat, err := h.chats.Get(c.Request.Context(), me.ID, chatID)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusOK, dto.ChatFromDomain(chat))
}
func (h *ChatHandler) List(c *gin.Context) {
me := middleware.CurrentUser(c)
limit, cursor, err := parseListQuery(c)
if err != nil {
respondError(c, err)
return
}
items, next, err := h.chats.List(c.Request.Context(), me.ID, limit, cursor)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusOK, dto.ChatPageResponse{
Items: dto.ChatsFromDomain(items),
NextCursor: next,
})
}
func parseListQuery(c *gin.Context) (int, *string, error) {
limit := 50
if v := c.Query("limit"); v != "" {
n, err := strconv.Atoi(v)
if err != nil || n < 1 || n > 100 {
return 0, nil, &badRequestError{msg: "limit должен быть целым 1..100"}
}
limit = n
}
var cursor *string
if v := c.Query("cursor"); v != "" {
cursor = &v
}
return limit, cursor, nil
}
@@ -0,0 +1,54 @@
package handler
import (
"context"
"net/http"
"sync/atomic"
"time"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
)
type HealthCheck func(ctx context.Context) error
type HealthHandler struct {
checks []HealthCheck
ready *atomic.Bool
}
func NewHealthHandler(checks ...HealthCheck) *HealthHandler {
return &HealthHandler{checks: checks}
}
func (h *HealthHandler) WithReadyFlag(v *atomic.Bool) *HealthHandler {
h.ready = v
return h
}
func (h *HealthHandler) Live(c *gin.Context) {
c.JSON(http.StatusOK, dto.HealthResponse{Status: "ok"})
}
func (h *HealthHandler) Ready(c *gin.Context) {
if h.ready != nil && !h.ready.Load() {
respondError(c, &domain.UnavailableError{Reason: "shutting down"})
return
}
ctx, cancel := context.WithTimeout(c.Request.Context(), 2*time.Second)
defer cancel()
for _, check := range h.checks {
if check == nil {
continue
}
if err := check(ctx); err != nil {
respondError(c, &domain.UnavailableError{Reason: "зависимость недоступна"})
return
}
}
c.JSON(http.StatusOK, dto.HealthResponse{Status: "ok"})
}
@@ -0,0 +1,88 @@
package handler
import (
"net/http"
"regexp"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
var idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
type MessageHandler struct {
messages *service.MessageService
}
func NewMessageHandler(messages *service.MessageService) *MessageHandler {
return &MessageHandler{messages: messages}
}
func (h *MessageHandler) Create(c *gin.Context) {
var req dto.CreateMessageRequest
if err := bindStrictJSON(c, &req); err != nil {
respondError(c, err)
return
}
key := c.GetHeader("Idempotency-Key")
if key == "" || !idempotencyKeyPattern.MatchString(key) {
respondError(c, &badRequestError{
msg: "Idempotency-Key обязателен и должен соответствовать ^[A-Za-z0-9._:-]{1,128}$",
})
return
}
me := middleware.CurrentUser(c)
chatID, err := parseUUIDPathParam(c, "chat_id")
if err != nil {
respondError(c, err)
return
}
result, err := h.messages.Create(
c.Request.Context(),
me.ID,
chatID,
req.Text,
req.AttachmentIDs,
key,
c.Request.URL.Path,
)
if err != nil {
respondError(c, err)
return
}
c.Data(result.Status, "application/json", result.Body)
}
func (h *MessageHandler) List(c *gin.Context) {
me := middleware.CurrentUser(c)
chatID, err := parseUUIDPathParam(c, "chat_id")
if err != nil {
respondError(c, err)
return
}
limit, cursor, err := parseListQuery(c)
if err != nil {
respondError(c, err)
return
}
items, next, err := h.messages.List(c.Request.Context(), me.ID, chatID, limit, cursor)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusOK, dto.MessagePageResponse{
Items: dto.MessagesFromDomain(items),
NextCursor: next,
})
}
@@ -0,0 +1,44 @@
package handler
import (
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
)
type badRequestError struct{ msg string }
func (e *badRequestError) Error() string { return e.msg }
func (e *badRequestError) Unwrap() error { return domain.ErrInvalidInput }
func (e *badRequestError) Code() domain.ErrorCode { return domain.CodeInvalidRequest }
func parseUUIDPathParam(c *gin.Context, name string) (string, error) {
raw := c.Param(name)
if raw == "" {
return "", &badRequestError{msg: "параметр " + name + " обязателен"}
}
id, err := uuid.Parse(raw)
if err != nil {
return "", &badRequestError{msg: "параметр " + name + " должен быть корректным UUID"}
}
return id.String(), nil
}
func respondError(c *gin.Context, err error) {
reqID := middleware.GetRequestID(c)
c.JSON(dto.StatusFromError(err), dto.ErrorFromDomain(err, reqID))
}
// respondBasicChallenge выставляет WWW-Authenticate для 401 на /auth/sessions.
// На не-401 ответах заголовок не ставится как по контракту нужно
func respondBasicChallenge(c *gin.Context, err error) {
if dto.StatusFromError(err) == 401 {
c.Header("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
}
respondError(c, err)
}
+43
View File
@@ -0,0 +1,43 @@
package handler
import (
"net/http"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
type UserHandler struct {
users *service.UserService
}
func NewUserHandler(users *service.UserService) *UserHandler {
return &UserHandler{users: users}
}
func (h *UserHandler) Create(c *gin.Context) {
var req dto.CreateUserRequest
if err := bindStrictJSON(c, &req); err != nil {
respondError(c, err)
return
}
u, err := h.users.Create(c.Request.Context(), req.Username, req.DisplayName, req.Password)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusCreated, dto.UserFromDomain(u))
}
func (h *UserHandler) Current(c *gin.Context) {
u := middleware.CurrentUser(c)
if u == nil {
respondError(c, &badRequestError{msg: "нет текущего пользователя"})
return
}
c.JSON(http.StatusOK, dto.UserFromDomain(u))
}
@@ -0,0 +1,38 @@
package middleware
import (
"net/http"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
)
func Auth(users domain.UserRepository) gin.HandlerFunc {
return func(c *gin.Context) {
id := c.GetHeader("X-User-Id")
if id == "" {
abortUnauthorized(c, "требуется X-User-Id")
return
}
u, err := users.GetByID(c.Request.Context(), id)
if err != nil {
abortUnauthorized(c, "неизвестный пользователь")
return
}
c.Set(CurrentUserKey, u)
c.Next()
}
}
func abortUnauthorized(c *gin.Context, msg string) {
reqID := GetRequestID(c)
body := dto.ErrorFromDomain(
&domain.UnauthorizedError{Reason: msg},
reqID,
)
c.AbortWithStatusJSON(http.StatusUnauthorized, body)
}
@@ -0,0 +1,70 @@
package middleware
import (
"context"
"strings"
"time"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/service"
)
const authTimeout = 3 * time.Second
// BearerAuth читает Authorization: Bearer <token>, проверяет сессию
// через SessionService и кладёт пользователя и токен в контекст.
func BearerAuth(sessions *service.SessionService) gin.HandlerFunc {
return func(c *gin.Context) {
token, ok := parseBearerToken(c)
if !ok {
abortBearer(c, "требуется Bearer")
return
}
ctx, cancel := context.WithTimeout(c.Request.Context(), authTimeout)
defer cancel()
user, err := sessions.Resolve(ctx, token)
if err != nil {
abortBearerWithErr(c, err)
return
}
c.Set(CurrentUserKey, user)
c.Set(CurrentTokenKey, token)
c.Next()
}
}
// parseBearerToken читает Authorization: Bearer <opaque-token>.
func parseBearerToken(c *gin.Context) (string, bool) {
const prefix = "Bearer "
auth := c.GetHeader("Authorization")
if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) {
return "", false
}
token := strings.TrimSpace(auth[len(prefix):])
if token == "" {
return "", false
}
return token, true
}
func abortBearer(c *gin.Context, reason string) {
abortBearerWithErr(c, &domain.UnauthorizedError{Reason: reason})
}
// abortBearerWithErr формирует ответ на ошибку аутентификации.
// Заголовок WWW-Authenticate: Bearer выставляется только на 401;
// при 503 (недоступность БД/кэша) — обычный ответ ошибки без challenge.
func abortBearerWithErr(c *gin.Context, err error) {
reqID := GetRequestID(c)
status := dto.StatusFromError(err)
if status == 401 {
c.Header("WWW-Authenticate", `Bearer realm="messenger"`)
}
c.AbortWithStatusJSON(status, dto.ErrorFromDomain(err, reqID))
}
@@ -0,0 +1,30 @@
package middleware
import (
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
)
const (
CurrentUserKey = "current_user"
CurrentTokenKey = "current_token"
)
func CurrentUser(c *gin.Context) *domain.User {
if v, ok := c.Get(CurrentUserKey); ok {
if u, ok := v.(*domain.User); ok {
return u
}
}
return nil
}
func CurrentToken(c *gin.Context) string {
if v, ok := c.Get(CurrentTokenKey); ok {
if s, ok := v.(string); ok {
return s
}
}
return ""
}
@@ -0,0 +1,31 @@
package middleware
import (
"os"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
const InstanceIDHeader = "X-Instance-Id"
var instanceID = resolveInstanceID()
func resolveInstanceID() string {
if v := os.Getenv("INSTANCE_ID"); v != "" {
return v
}
if v, err := os.Hostname(); err == nil && v != "" {
return v
}
return uuid.NewString()
}
func Instance() gin.HandlerFunc {
return func(c *gin.Context) {
c.Writer.Header().Set(InstanceIDHeader, instanceID)
c.Next()
}
}
func GetInstanceID() string { return instanceID }
@@ -0,0 +1,32 @@
package middleware
import (
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
const (
RequestIDKey = "request_id"
RequestIDHeader = "X-Request-Id"
)
func RequestID() gin.HandlerFunc {
return func(c *gin.Context) {
id := c.GetHeader(RequestIDHeader)
if id == "" {
id = uuid.NewString()
}
c.Set(RequestIDKey, id)
c.Writer.Header().Set(RequestIDHeader, id)
c.Next()
}
}
func GetRequestID(c *gin.Context) string {
if v, ok := c.Get(RequestIDKey); ok {
if s, ok := v.(string); ok {
return s
}
}
return ""
}
+58
View File
@@ -0,0 +1,58 @@
package httpapi
import (
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/httpapi/handler"
"high-loud-apps-labs/internal/httpapi/middleware"
)
type Handlers struct {
Health *handler.HealthHandler
User *handler.UserHandler
Chat *handler.ChatHandler
Message *handler.MessageHandler
Auth *handler.AuthHandler
Attachment *handler.AttachmentHandler
}
func NewRouter(h Handlers, auth gin.HandlerFunc) *gin.Engine {
gin.EnableJsonDecoderDisallowUnknownFields()
r := gin.New()
r.Use(gin.Logger())
r.Use(gin.Recovery())
r.Use(middleware.RequestID())
r.Use(middleware.Instance())
r.GET("/health/live", h.Health.Live)
r.GET("/health/ready", h.Health.Ready)
api := r.Group("/api/v1")
{
api.POST("/users", h.User.Create)
api.POST("/auth/sessions", h.Auth.CreateSession)
}
protected := api.Group("")
protected.Use(auth)
{
protected.DELETE("/auth/sessions/current", h.Auth.RevokeCurrent)
protected.GET("/users/me", h.User.Current)
protected.POST("/chats", h.Chat.Create)
protected.GET("/chats", h.Chat.List)
protected.GET("/chats/:chat_id", h.Chat.Get)
protected.POST("/chats/:chat_id/messages", h.Message.Create)
protected.GET("/chats/:chat_id/messages", h.Message.List)
if h.Attachment != nil {
protected.POST("/chats/:chat_id/attachments", h.Attachment.Upload)
protected.GET("/attachments/:attachment_id", h.Attachment.Get)
protected.GET("/attachments/:attachment_id/content", h.Attachment.Content)
protected.POST("/attachments/:attachment_id/replay", h.Attachment.Replay)
}
}
return r
}
+44
View File
@@ -0,0 +1,44 @@
package imaging
import (
"bytes"
"crypto/sha256"
"fmt"
"image"
_ "image/jpeg"
_ "image/png"
"time"
"high-loud-apps-labs/internal/domain"
"github.com/disintegration/imaging"
)
func Crop(attachmentID string, imgData []byte) (*domain.AttachmentVariant, []byte, error) {
img, _, err := image.Decode(bytes.NewReader(imgData))
if err != nil {
return nil, nil, fmt.Errorf("декодирование изображения: %w", err)
}
cropImg := imaging.Fill(img, 128, 128, imaging.Center, imaging.Lanczos)
var buf bytes.Buffer
if err := imaging.Encode(&buf, cropImg, imaging.JPEG, imaging.JPEGQuality(85)); err != nil {
return nil, nil, fmt.Errorf("кодирование jpeg: %w", err)
}
data := buf.Bytes()
sha := sha256.Sum256(data)
v := &domain.AttachmentVariant{
AttachmentID: attachmentID,
Name: domain.VariantCrop,
ContentType: "image/jpeg",
SizeBytes: int64(len(data)),
Width: cropImg.Bounds().Dx(),
Height: cropImg.Bounds().Dy(),
SHA256: sha[:],
CreatedAt: time.Now().UTC(),
}
return v, data, nil
}
+45
View File
@@ -0,0 +1,45 @@
package imaging
import (
"bytes"
"crypto/sha256"
"fmt"
"image"
_ "image/jpeg"
_ "image/png"
"time"
"high-loud-apps-labs/internal/domain"
"github.com/disintegration/imaging"
"github.com/gen2brain/webp"
)
func Optimized(attachmentID string, imgData []byte) (*domain.AttachmentVariant, []byte, error) {
img, _, err := image.Decode(bytes.NewReader(imgData))
if err != nil {
return nil, nil, fmt.Errorf("декодирование изображения: %w", err)
}
optimizedImg := imaging.Fit(img, 1280, 1280, imaging.Lanczos)
var buf bytes.Buffer
if err := webp.Encode(&buf, optimizedImg, webp.Options{Quality: 80}); err != nil {
return nil, nil, fmt.Errorf("кодирование webp: %w", err)
}
data := buf.Bytes()
sha := sha256.Sum256(data)
v := &domain.AttachmentVariant{
AttachmentID: attachmentID,
Name: domain.VariantOptimized,
ContentType: "image/webp",
SizeBytes: int64(len(data)),
Width: optimizedImg.Bounds().Dx(),
Height: optimizedImg.Bounds().Dy(),
SHA256: sha[:],
CreatedAt: time.Now().UTC(),
}
return v, data, nil
}
+44
View File
@@ -0,0 +1,44 @@
package imaging
import (
"bytes"
"crypto/sha256"
"fmt"
"image"
_ "image/jpeg"
_ "image/png"
"high-loud-apps-labs/internal/domain"
"time"
"github.com/disintegration/imaging"
)
func Thumbnail(attachmentID string, imgData []byte) (*domain.AttachmentVariant, []byte, error) {
img, _, err := image.Decode(bytes.NewReader(imgData))
if err != nil {
return nil, nil, fmt.Errorf("декодирование изображения: %w", err)
}
thumb := imaging.Fit(img, 256, 256, imaging.Lanczos)
var buf bytes.Buffer
if err := imaging.Encode(&buf, thumb, imaging.JPEG, imaging.JPEGQuality(85)); err != nil {
return nil, nil, fmt.Errorf("кодирование jpeg: %w", err)
}
data := buf.Bytes()
sha := sha256.Sum256(data)
v := &domain.AttachmentVariant{
AttachmentID: attachmentID,
Name: domain.VariantThumbnail,
ContentType: "image/jpeg",
SizeBytes: int64(len(data)),
Width: thumb.Bounds().Dx(),
Height: thumb.Bounds().Dy(),
SHA256: sha[:],
CreatedAt: time.Now().UTC(),
}
return v, data, nil
}
+72
View File
@@ -0,0 +1,72 @@
package outbox
import (
"context"
"log"
"time"
"high-loud-apps-labs/internal/broker"
"high-loud-apps-labs/internal/domain"
)
type Publisher struct {
repo domain.OutboxRepository
broker broker.Publisher
batch int
}
func NewPublisher(repo domain.OutboxRepository, b broker.Publisher, batch int) *Publisher {
if batch <= 0 {
batch = 50
}
return &Publisher{repo: repo, broker: b, batch: batch}
}
func (p *Publisher) Run(ctx context.Context, interval time.Duration) {
if interval <= 0 {
interval = 1 * time.Second
}
ticker := time.NewTicker(interval)
defer ticker.Stop()
log.Printf("outbox: publisher запущен (interval=%s)", interval)
for {
select {
case <-ctx.Done():
log.Println("outbox: publisher остановлен")
return
case <-ticker.C:
p.tick(ctx)
}
}
}
func (p *Publisher) tick(ctx context.Context) {
entries, err := p.repo.ClaimBatch(ctx, p.batch)
if err != nil {
log.Printf("outbox: ошибка ClaimBatch: %v", err)
return
}
if len(entries) == 0 {
return
}
var successIDs []string
for _, e := range entries {
err := p.broker.Publish(ctx, "process", e.Payload)
if err != nil {
log.Printf("outbox: ошибка публикации %s: %v", e.ID, err)
break // Прерываем пачку
}
successIDs = append(successIDs, e.ID)
}
if len(successIDs) > 0 {
if err := p.repo.MarkPublished(ctx, successIDs); err != nil {
log.Printf("outbox: ошибка MarkPublished: %v", err)
} else {
log.Printf("outbox: успешно опубликовано %d сообщений", len(successIDs))
}
}
}
+268
View File
@@ -0,0 +1,268 @@
package service
import (
"bytes"
"context"
"crypto/sha256"
"encoding/json"
"image"
_ "image/jpeg"
_ "image/png"
"io"
"net/http"
"strings"
"time"
"unicode"
"unicode/utf8"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
)
type txRunner interface {
WithTx(ctx context.Context, fn func(tx domain.Tx) error) error
}
type AttachmentService struct {
attachments domain.AttachmentRepository
chats domain.ChatRepository
storage domain.ObjectStorage
outbox domain.OutboxRepository
failedJobs domain.FailedJobRepository
tx txRunner
maxBytes int64
maxPixels int64
}
func NewAttachmentService(
attachments domain.AttachmentRepository,
chats domain.ChatRepository,
storage domain.ObjectStorage,
outbox domain.OutboxRepository,
failedJobs domain.FailedJobRepository,
tx txRunner,
maxBytes, maxPixels int64,
) *AttachmentService {
return &AttachmentService{
attachments: attachments,
chats: chats,
storage: storage,
outbox: outbox,
failedJobs: failedJobs,
tx: tx,
maxBytes: maxBytes,
maxPixels: maxPixels,
}
}
// 1. Валидация, sniff Content-Type, проверка пикселей по заголовку.
// 2. Оригинал в S3 staging/{id}.
// 3. Транзакция: INSERT attachments(status=queued) + INSERT outbox.
func (s *AttachmentService) Upload(
ctx context.Context,
ownerID, chatID, filename string,
body io.Reader,
) (*domain.Attachment, error) {
if err := s.ensureMember(ctx, ownerID, chatID); err != nil {
return nil, err
}
if err := validateFilename(filename); err != nil {
return nil, err
}
limited := io.LimitReader(body, s.maxBytes+1)
buf, err := io.ReadAll(limited)
if err != nil {
return nil, &domain.UnavailableError{Reason: "не удалось прочитать тело загрузки"}
}
if int64(len(buf)) > s.maxBytes {
return nil, &domain.PayloadTooLargeError{Limit: s.maxBytes}
}
if len(buf) == 0 {
return nil, &domain.ValidationError{Field: "body", Message: "пустой файл"}
}
contentType := http.DetectContentType(buf)
if contentType != "image/png" && contentType != "image/jpeg" {
return nil, &domain.UnsupportedMediaTypeError{
MediaType: contentType,
Expected: "image/png или image/jpeg",
}
}
cfg, _, err := image.DecodeConfig(bytes.NewReader(buf))
if err != nil {
return nil, &domain.UnsupportedMediaTypeError{
MediaType: contentType,
Expected: "целостный image/png или image/jpeg",
}
}
if int64(cfg.Width)*int64(cfg.Height) > s.maxPixels {
return nil, &domain.PayloadTooLargeError{
Limit: s.maxPixels,
Message: "изображение превышает лимит пикселей",
}
}
sha := sha256.Sum256(buf)
id := uuid.NewString()
stagingKey := "staging/" + id
now := time.Now().UTC()
a := &domain.Attachment{
ID: id,
ChatID: chatID,
OwnerID: ownerID,
Filename: filename,
ContentType: contentType,
SizeBytes: int64(len(buf)),
SHA256: sha[:],
ObjectKey: "chats/" + chatID + "/" + id,
Status: domain.AttachmentStatusQueued,
StagingKey: stagingKey,
PipelineVersion: 1,
CreatedAt: now,
UpdatedAt: now,
}
if err := s.storage.Put(ctx, stagingKey, bytes.NewReader(buf), int64(len(buf)), contentType); err != nil {
return nil, err
}
payload, err := json.Marshal(domain.JobMessage{
AttachmentID: id,
PipelineVersion: 1,
Attempt: 1,
})
if err != nil {
return nil, err
}
err = s.tx.WithTx(ctx, func(tx domain.Tx) error {
if err := s.attachments.CreateInTx(ctx, tx, a); err != nil {
return err
}
return s.outbox.Enqueue(ctx, tx, &domain.OutboxEntry{
AggregateType: domain.OutboxAggregateAttachment,
AggregateID: id,
EventType: domain.OutboxEventProcess,
Payload: payload,
})
})
if err != nil {
return nil, err
}
return a, nil
}
func (s *AttachmentService) Get(ctx context.Context, userID, attachmentID string) (*domain.Attachment, error) {
a, err := s.attachments.GetByID(ctx, attachmentID)
if err != nil {
return nil, err
}
if err := s.ensureMember(ctx, userID, a.ChatID); err != nil {
return nil, err
}
return a, nil
}
func (s *AttachmentService) Download(
ctx context.Context,
userID, attachmentID, variantName string,
) (io.ReadCloser, int64, string, error) {
a, err := s.Get(ctx, userID, attachmentID)
if err != nil {
return nil, 0, "", err
}
if a.Status != domain.AttachmentStatusReady {
return nil, 0, "", &domain.ConflictError{Reason: "вложение не готово"}
}
if variantName == "original" || variantName == "" {
return s.storage.Get(ctx, a.ObjectKey)
}
for _, v := range a.Variants {
if v.Name == variantName {
return s.storage.Get(ctx, v.ObjectKey)
}
}
return nil, 0, "", &domain.NotFoundError{Entity: "variant", ID: variantName}
}
// Replay позволяет оператору перезапустить упавшую задачу.
func (s *AttachmentService) Replay(ctx context.Context, userID, attachmentID string) error {
a, err := s.Get(ctx, userID, attachmentID)
if err != nil {
return err
}
if a.Status != domain.AttachmentStatusFailed {
return &domain.ConflictError{Reason: "перезапустить можно только failed-вложение"}
}
// Формируем новое сообщение
payload, err := json.Marshal(domain.JobMessage{
AttachmentID: a.ID,
PipelineVersion: a.PipelineVersion,
Attempt: 1, // Сбрасываем счетчик попыток
})
if err != nil {
return err
}
err = s.tx.WithTx(ctx, func(tx domain.Tx) error {
if err := s.attachments.ResetForReplay(ctx, tx, a.ID); err != nil {
return err
}
// Помечаем в реестре упавших задач (внутри транзакции)
if err := s.failedJobs.ResolveInTx(ctx, tx, a.ID); err != nil {
return err
}
return s.outbox.Enqueue(ctx, tx, &domain.OutboxEntry{
AggregateType: domain.OutboxAggregateAttachment,
AggregateID: a.ID,
EventType: domain.OutboxEventProcess,
Payload: payload,
})
})
if err != nil {
return err
}
return nil
}
func (s *AttachmentService) ensureMember(ctx context.Context, userID, chatID string) error {
c, err := s.chats.GetByID(ctx, chatID)
if err != nil {
return err
}
for _, m := range c.MemberIDs {
if m == userID {
return nil
}
}
return &domain.NotFoundError{Entity: "chat", ID: chatID}
}
func validateFilename(name string) error {
if strings.TrimSpace(name) == "" {
return &domain.ValidationError{Field: "filename", Message: "не может быть пустым или состоять только из пробелов"}
}
if utf8.RuneCountInString(name) > 255 {
return &domain.ValidationError{Field: "filename", Message: "не более 255 символов"}
}
if strings.ContainsAny(name, "/\\\x00") {
return &domain.ValidationError{Field: "filename", Message: "содержит недопустимые символы"}
}
for _, r := range name {
if unicode.IsControl(r) {
return &domain.ValidationError{Field: "filename", Message: "содержит управляющие символы"}
}
}
return nil
}
+95
View File
@@ -0,0 +1,95 @@
package service
import (
"context"
"errors"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
)
type ChatService struct {
chats domain.ChatRepository
users domain.UserRepository
}
func NewChatService(chats domain.ChatRepository, users domain.UserRepository) *ChatService {
return &ChatService{chats: chats, users: users}
}
func (s *ChatService) Create(ctx context.Context, creatorID, title string, memberIDs []string) (*domain.Chat, error) {
if strings.TrimSpace(title) == "" {
return nil, &domain.ValidationError{
Field: "title",
Message: "не может состоять только из пробелов",
}
}
if utf8.RuneCountInString(title) > 100 {
return nil, &domain.ValidationError{
Field: "title",
Message: "не более 100 символов",
}
}
seen := make(map[string]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return nil, &domain.ValidationError{
Field: "member_ids",
Message: "дубликаты запрещены",
}
}
seen[id] = struct{}{}
}
if _, ok := seen[creatorID]; !ok {
return nil, &domain.ValidationError{
Field: "member_ids",
Message: "создатель должен входить в список участников",
}
}
for _, id := range memberIDs {
if _, err := s.users.GetByID(ctx, id); err != nil {
if errors.Is(err, domain.ErrNotFound) {
return nil, &domain.ValidationError{
Field: "member_ids",
Message: "неизвестный участник " + id,
}
}
return nil, err
}
}
c := &domain.Chat{
ID: uuid.NewString(),
Title: title,
MemberIDs: append([]string(nil), memberIDs...),
CreatedAt: time.Now().UTC(),
}
if err := s.chats.Create(ctx, c); err != nil {
return nil, err
}
return c, nil
}
func (s *ChatService) Get(ctx context.Context, userID, chatID string) (*domain.Chat, error) {
c, err := s.chats.GetByID(ctx, chatID)
if err != nil {
return nil, err
}
for _, m := range c.MemberIDs {
if m == userID {
return c, nil
}
}
return nil, &domain.NotFoundError{Entity: "chat", ID: chatID}
}
func (s *ChatService) List(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) {
return s.chats.ListByMember(ctx, userID, limit, cursor)
}
+122
View File
@@ -0,0 +1,122 @@
package service
import (
"context"
"encoding/json"
"net/http"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
)
type MessageService struct {
messages domain.MessageRepository
chats domain.ChatRepository
idempotencyTTL time.Duration
}
func NewMessageService(
messages domain.MessageRepository,
chats domain.ChatRepository,
idempotencyTTL time.Duration,
) *MessageService {
return &MessageService{
messages: messages,
chats: chats,
idempotencyTTL: idempotencyTTL,
}
}
func (s *MessageService) Create(
ctx context.Context,
senderID, chatID, text string,
attachmentIDs []string,
idempotencyKey, requestPath string,
) (*domain.CreateIdempotentResult, error) {
trimmed := strings.TrimSpace(text)
if trimmed == "" && len(attachmentIDs) == 0 {
return nil, &domain.ValidationError{
Field: "text",
Message: "text или attachment_ids обязательны",
}
}
if utf8.RuneCountInString(text) > 4000 {
return nil, &domain.ValidationError{
Field: "text",
Message: "не более 4000 символов",
}
}
if len(attachmentIDs) > 10 {
return nil, &domain.ValidationError{
Field: "attachment_ids",
Message: "не более 10",
}
}
seen := make(map[string]struct{}, len(attachmentIDs))
for _, id := range attachmentIDs {
if _, dup := seen[id]; dup {
return nil, &domain.ValidationError{
Field: "attachment_ids",
Message: "дубликаты запрещены",
}
}
seen[id] = struct{}{}
}
if err := s.ensureMember(ctx, senderID, chatID); err != nil {
return nil, err
}
fresh := &domain.Message{
ID: uuid.NewString(),
ChatID: chatID,
SenderID: senderID,
Text: text,
AttachmentIDs: append([]string(nil), attachmentIDs...),
CreatedAt: time.Now().UTC(),
}
body, err := json.Marshal(dto.MessageFromDomain(fresh))
if err != nil {
return nil, err
}
return s.messages.CreateIdempotent(
ctx,
domain.IdempotencyScope{
UserID: senderID,
Method: http.MethodPost,
Path: requestPath,
Key: idempotencyKey,
},
domain.RequestHash(text, attachmentIDs),
fresh,
body,
s.idempotencyTTL,
)
}
func (s *MessageService) List(ctx context.Context, userID, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) {
if err := s.ensureMember(ctx, userID, chatID); err != nil {
return nil, nil, err
}
return s.messages.ListByChat(ctx, chatID, limit, cursor)
}
func (s *MessageService) ensureMember(ctx context.Context, userID, chatID string) error {
c, err := s.chats.GetByID(ctx, chatID)
if err != nil {
return err
}
for _, m := range c.MemberIDs {
if m == userID {
return nil
}
}
return &domain.NotFoundError{Entity: "chat", ID: chatID}
}
+112
View File
@@ -0,0 +1,112 @@
package service
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
// PasswordHasher хеширует пароли и проверяет пароль сохранённого хеша.
type PasswordHasher interface {
Hash(password string) (string, error)
Verify(password, encoded string) (bool, error)
}
type Argon2idHasher struct {
memory uint32
iterations uint32
parallelism uint8
saltLength uint32
keyLength uint32
}
func NewArgon2idHasher() *Argon2idHasher {
return &Argon2idHasher{
memory: 64 * 1024,
iterations: 3,
parallelism: 4,
saltLength: 16,
keyLength: 32,
}
}
func (h *Argon2idHasher) Hash(password string) (string, error) {
salt := make([]byte, h.saltLength)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("генерация соли: %w", err)
}
key := argon2.IDKey(
[]byte(password),
salt,
h.iterations,
h.memory,
h.parallelism,
h.keyLength,
)
return fmt.Sprintf(
"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version,
h.memory,
h.iterations,
h.parallelism,
base64.RawStdEncoding.EncodeToString(salt),
base64.RawStdEncoding.EncodeToString(key),
), nil
}
// Verify сравнивает пароль с сохранённым PHC-хешем.
// Возвращает false и nil при неверном пароле.
// Возвращает false и ошибку, если строка хеша повреждена или несовместима.
func (h *Argon2idHasher) Verify(password, encoded string) (bool, error) {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return false, errors.New("некорректный формат хеша")
}
var version int
if n, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || n != 1 {
return false, errors.New("некорректная версия хеша")
}
if version != argon2.Version {
return false, errors.New("неподдерживаемая версия Argon2")
}
var (
memory uint32
iterations uint32
parallelism uint8
)
if n, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, &parallelism); err != nil || n != 3 {
return false, errors.New("некорректные параметры хеша")
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return false, errors.New("некорректная соль")
}
wantKey, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return false, errors.New("некорректный ключ")
}
gotKey := argon2.IDKey(
[]byte(password),
salt,
iterations,
memory,
parallelism,
uint32(len(wantKey)),
)
return subtle.ConstantTimeCompare(gotKey, wantKey) == 1, nil
}
var _ PasswordHasher = (*Argon2idHasher)(nil)
+216
View File
@@ -0,0 +1,216 @@
package service
import (
"context"
"encoding/json"
"log"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
const advisoryLockKey int64 = 0x4D5455534904
type Reconciler struct {
attachments domain.AttachmentRepository
storage domain.ObjectStorage
outbox domain.OutboxRepository
pool *pgxpool.Pool
gracePeriod time.Duration
batchSize int
}
func NewReconciler(
attachments domain.AttachmentRepository,
storage domain.ObjectStorage,
outbox domain.OutboxRepository,
pool *pgxpool.Pool,
gracePeriod time.Duration,
) *Reconciler {
if gracePeriod <= 0 {
gracePeriod = time.Hour
}
return &Reconciler{
attachments: attachments,
storage: storage,
outbox: outbox,
pool: pool,
gracePeriod: gracePeriod,
batchSize: 100,
}
}
func (r *Reconciler) Run(ctx context.Context, interval time.Duration) {
if interval <= 0 {
interval = 5 * time.Minute
}
ticker := time.NewTicker(interval)
defer ticker.Stop()
log.Printf("reconciler: запущен (interval=%s, grace=%s)", interval, r.gracePeriod)
r.tick(ctx)
for {
select {
case <-ctx.Done():
log.Println("reconciler: остановлен")
return
case <-ticker.C:
r.tick(ctx)
}
}
}
func (r *Reconciler) tick(ctx context.Context) {
acquired, release, err := r.acquireLock(ctx)
if err != nil {
log.Printf("reconciler: ошибка получения блокировки: %v", err)
return
}
if !acquired {
return
}
defer release()
leasesReset := r.sweepExpiredLeases(ctx)
stagingDeleted := r.sweepStaging(ctx)
orphansDeleted := r.sweepOrphans(ctx)
if leasesReset > 0 || stagingDeleted > 0 || orphansDeleted > 0 {
log.Printf("reconciler: очистка завершена (восстановлено_задач=%d, удалено_staging=%d, удалено_сирот=%d)", leasesReset, stagingDeleted, orphansDeleted)
}
}
func (r *Reconciler) acquireLock(ctx context.Context) (bool, func(), error) {
conn, err := r.pool.Acquire(ctx)
if err != nil {
return false, nil, err
}
var ok bool
if err := conn.QueryRow(ctx, `SELECT pg_try_advisory_lock($1)`, advisoryLockKey).Scan(&ok); err != nil {
conn.Release()
return false, nil, err
}
if !ok {
conn.Release()
return false, nil, nil
}
release := func() {
unlockCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if _, err := conn.Exec(unlockCtx, `SELECT pg_advisory_unlock($1)`, advisoryLockKey); err != nil {
log.Printf("reconciler: ошибка снятия блокировки: %v", err)
}
conn.Release()
}
return true, release, nil
}
func (r *Reconciler) sweepExpiredLeases(ctx context.Context) int {
expired, err := r.attachments.ListExpiredLeases(ctx, r.batchSize)
if err != nil {
log.Printf("reconciler: ошибка получения истёкших аренд: %v", err)
return 0
}
recovered := 0
for _, a := range expired {
if err := r.attachments.ResetLease(ctx, a.ID); err != nil {
log.Printf("reconciler: ошибка сброса аренды для %s: %v", a.ID, err)
continue
}
payload, _ := json.Marshal(domain.JobMessage{
AttachmentID: a.ID,
PipelineVersion: a.PipelineVersion,
Attempt: a.Attempts + 1,
})
err := r.outbox.EnqueueDirect(ctx, &domain.OutboxEntry{
AggregateType: domain.OutboxAggregateAttachment,
AggregateID: a.ID,
EventType: domain.OutboxEventProcess,
Payload: payload,
CreatedAt: time.Now().UTC(),
})
if err != nil {
log.Printf("reconciler: ошибка постановки в очередь восстановленной задачи %s: %v", a.ID, err)
continue
}
recovered++
}
return recovered
}
// Чистим staging в S3 для готовых задач
func (r *Reconciler) sweepStaging(ctx context.Context) int {
toCleanup, err := r.attachments.ListStagingToCleanup(ctx, r.batchSize)
if err != nil {
log.Printf("reconciler: ошибка получения списка staging для очистки: %v", err)
return 0
}
deleted := 0
for _, a := range toCleanup {
if err := r.storage.Delete(ctx, a.StagingKey); err != nil {
log.Printf("reconciler: ошибка удаления объекта staging %s: %v", a.StagingKey, err)
continue
}
if err := r.attachments.ClearStagingKey(ctx, a.ID); err != nil {
log.Printf("reconciler: ошибка очистки ключа staging %s: %v", a.ID, err)
continue
}
deleted++
}
return deleted
}
// Удаляем старые сиротские объекты (без записи в БД)
func (r *Reconciler) sweepOrphans(ctx context.Context) int {
objects, err := r.storage.List(ctx, "chats/")
if err != nil {
log.Printf("reconciler: ошибка получения списка объектов: %v", err)
return 0
}
if len(objects) == 0 {
return 0
}
cutoff := time.Now().UTC().Add(-r.gracePeriod)
keys := make([]string, 0, len(objects))
for _, o := range objects {
if o.LastModified.Before(cutoff) {
keys = append(keys, o.Key)
}
}
if len(keys) == 0 {
return 0
}
existing, err := r.attachments.ExistingKeys(ctx, keys)
if err != nil {
log.Printf("reconciler: ошибка получения существующих ключей: %v", err)
return 0
}
inDB := make(map[string]struct{}, len(existing))
for _, k := range existing {
inDB[k] = struct{}{}
}
deleted := 0
for _, k := range keys {
if _, ok := inDB[k]; ok {
continue
}
if err := r.storage.Delete(ctx, k); err != nil {
log.Printf("reconciler: ошибка удаления сиротского объекта %s: %v", k, err)
continue
}
deleted++
}
return deleted
}
+127
View File
@@ -0,0 +1,127 @@
package service
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"errors"
"fmt"
"time"
"high-loud-apps-labs/internal/domain"
)
// SessionService отвечает за вход, проверку и отзыв сессий.
type SessionService struct {
users domain.UserRepository
sessions domain.SessionRepository
hasher PasswordHasher
ttl time.Duration
}
// NewSessionService создаёт сервис с заданным TTL сессий.
func NewSessionService(
users domain.UserRepository,
sessions domain.SessionRepository,
hasher PasswordHasher,
ttl time.Duration,
) *SessionService {
return &SessionService{
users: users,
sessions: sessions,
hasher: hasher,
ttl: ttl,
}
}
// Login проверяет username/password и создаёт новую сессию.
// Возвращает сессию, открытый токен и пользователя.
// Открытый токен уходит клиенту; в БД сохраняется только его SHA-256.
func (s *SessionService) Login(ctx context.Context, username, password string) (*domain.Session, string, *domain.User, error) {
user, err := s.users.GetByUsername(ctx, username)
if err != nil {
if errors.Is(err, domain.ErrNotFound) {
return nil, "", nil, &domain.UnauthorizedError{Reason: "неверные учётные данные"}
}
return nil, "", nil, err
}
ok, err := s.hasher.Verify(password, user.PasswordHash)
if err != nil {
return nil, "", nil, err
}
if !ok {
return nil, "", nil, &domain.UnauthorizedError{Reason: "неверные учётные данные"}
}
token, err := generateToken()
if err != nil {
return nil, "", nil, err
}
tokenHash := sha256.Sum256([]byte(token))
now := time.Now().UTC()
session := &domain.Session{
TokenHash: tokenHash[:],
UserID: user.ID,
ExpiresAt: now.Add(s.ttl),
CreatedAt: now,
}
if err := s.sessions.Create(ctx, session); err != nil {
return nil, "", nil, err
}
return session, token, user, nil
}
// Resolve проверяет токен и возвращает пользователя сессии.
// Истёкший, отозванный или неизвестный токен - UnauthorizedError по контракту
func (s *SessionService) Resolve(ctx context.Context, token string) (*domain.User, error) {
if token == "" {
return nil, &domain.UnauthorizedError{Reason: "пустой токен"}
}
tokenHash := sha256.Sum256([]byte(token))
session, err := s.sessions.GetByTokenHash(ctx, tokenHash[:])
if err != nil {
if errors.Is(err, domain.ErrNotFound) {
return nil, &domain.UnauthorizedError{Reason: "неизвестный токен"}
}
return nil, err
}
if !session.ExpiresAt.After(time.Now().UTC()) {
return nil, &domain.UnauthorizedError{Reason: "сессия истекла"}
}
user, err := s.users.GetByID(ctx, session.UserID)
if err != nil {
if errors.Is(err, domain.ErrNotFound) {
return nil, &domain.UnauthorizedError{Reason: "пользователь сессии не найден"}
}
return nil, err
}
return user, nil
}
// Revoke удаляет сессию по токену.
func (s *SessionService) Revoke(ctx context.Context, token string) error {
if token == "" {
return nil
}
tokenHash := sha256.Sum256([]byte(token))
return s.sessions.DeleteByTokenHash(ctx, tokenHash[:])
}
// generateToken возвращает 32 случайных байта в base64url без паддинга=.
func generateToken() (string, error) {
buf := make([]byte, 32)
if _, err := rand.Read(buf); err != nil {
return "", fmt.Errorf("генерация токена: %w", err)
}
return base64.RawURLEncoding.EncodeToString(buf), nil
}
+78
View File
@@ -0,0 +1,78 @@
package service
import (
"context"
"regexp"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
)
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
type UserService struct {
users domain.UserRepository
hasher PasswordHasher
}
func NewUserService(users domain.UserRepository, hasher PasswordHasher) *UserService {
return &UserService{users: users, hasher: hasher}
}
func (s *UserService) Create(ctx context.Context, username, displayName, password string) (*domain.User, error) {
if !usernamePattern.MatchString(username) {
return nil, &domain.ValidationError{
Field: "username",
Message: "должен соответствовать ^[a-z0-9_]{3,32}$",
}
}
if strings.TrimSpace(displayName) == "" {
return nil, &domain.ValidationError{
Field: "display_name",
Message: "не может состоять только из пробелов",
}
}
if utf8.RuneCountInString(displayName) > 100 {
return nil, &domain.ValidationError{
Field: "display_name",
Message: "не более 100 символов",
}
}
passwordRunes := utf8.RuneCountInString(password)
if passwordRunes < 12 || passwordRunes > 128 {
return nil, &domain.ValidationError{
Field: "password",
Message: "длина 12–128 символов",
}
}
hash, err := s.hasher.Hash(password)
if err != nil {
return nil, err
}
u := &domain.User{
ID: uuid.NewString(),
Username: username,
DisplayName: displayName,
PasswordHash: hash,
CreatedAt: time.Now().UTC(),
}
if err := s.users.Create(ctx, u); err != nil {
return nil, err
}
return u, nil
}
func (s *UserService) GetByID(ctx context.Context, id string) (*domain.User, error) {
return s.users.GetByID(ctx, id)
}
func (s *UserService) GetByUsername(ctx context.Context, username string) (*domain.User, error) {
return s.users.GetByUsername(ctx, username)
}
@@ -0,0 +1,102 @@
package memory
import (
"context"
"slices"
"high-loud-apps-labs/internal/domain"
)
func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error {
if err := ctx.Err(); err != nil {
return err
}
r.mu.Lock()
defer r.mu.Unlock()
stored := *chat
stored.MemberIDs = append([]string(nil), chat.MemberIDs...)
r.chats[chat.ID] = &stored
return nil
}
func (r *ChatRepo) GetByID(ctx context.Context, id string) (*domain.Chat, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
c, ok := r.chats[id]
if !ok {
return nil, &domain.NotFoundError{Entity: "chat", ID: id}
}
copy := *c
copy.MemberIDs = append([]string(nil), c.MemberIDs...)
return &copy, nil
}
func (r *ChatRepo) ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) {
if err := ctx.Err(); err != nil {
return nil, nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
scope := "chats:" + userID
all := make([]domain.Chat, 0)
for _, c := range r.chats {
for _, m := range c.MemberIDs {
if m == userID {
copy := *c
copy.MemberIDs = append([]string(nil), c.MemberIDs...)
all = append(all, copy)
break
}
}
}
slices.SortFunc(all, func(a, b domain.Chat) int {
if lessThan(a.CreatedAt, a.ID, b.CreatedAt, b.ID) {
return -1
}
if lessThan(b.CreatedAt, b.ID, a.CreatedAt, a.ID) {
return 1
}
return 0
})
start := 0
if cursor != nil {
t, id, err := decodeCursor(*cursor, scope)
if err != nil {
return nil, nil, err
}
start = len(all)
for i, c := range all {
if lessThan(t, id, c.CreatedAt, c.ID) {
start = i
break
}
}
}
if start >= len(all) {
return []domain.Chat{}, nil, nil
}
end := start + limit
if end > len(all) {
end = len(all)
}
page := all[start:end]
var next *string
if end < len(all) {
last := page[len(page)-1]
c := encodeCursor(scope, last.CreatedAt, last.ID)
next = &c
}
return page, next, nil
}
@@ -0,0 +1,47 @@
package memory
import (
"encoding/base64"
"strings"
"time"
"high-loud-apps-labs/internal/domain"
)
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) {
data, err := base64.RawURLEncoding.DecodeString(cursor)
if err != nil {
return time.Time{}, "", badCursor()
}
parts := strings.SplitN(string(data), "|", 3)
if len(parts) != 3 {
return time.Time{}, "", badCursor()
}
if parts[0] != expectedScope {
return time.Time{}, "", badCursor()
}
t, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return time.Time{}, "", badCursor()
}
return t, parts[2], nil
}
func badCursor() error {
return &domain.ValidationError{
Field: "cursor",
Message: "некорректный формат",
}
}
func lessThan(aTime time.Time, aID string, bTime time.Time, bID string) bool {
if aTime.Equal(bTime) {
return aID < bID
}
return aTime.Before(bTime)
}
@@ -0,0 +1,93 @@
package memory
import (
"context"
"slices"
"time"
"high-loud-apps-labs/internal/domain"
)
func (r *MessageRepo) Create(ctx context.Context, message *domain.Message) error {
if err := ctx.Err(); err != nil {
return err
}
r.mu.Lock()
defer r.mu.Unlock()
stored := *message
r.messages[message.ChatID] = append(r.messages[message.ChatID], stored)
return nil
}
func (r *MessageRepo) ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) {
if err := ctx.Err(); err != nil {
return nil, nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
scope := "messages:" + chatID
var (
afterTime time.Time
afterID string
hasCursor bool
)
if cursor != nil {
t, id, err := decodeCursor(*cursor, scope)
if err != nil {
return nil, nil, err
}
afterTime = t
afterID = id
hasCursor = true
}
src := r.messages[chatID]
if len(src) == 0 {
return []domain.Message{}, nil, nil
}
all := make([]domain.Message, len(src))
copy(all, src)
slices.SortFunc(all, func(a, b domain.Message) int {
if lessThan(a.CreatedAt, a.ID, b.CreatedAt, b.ID) {
return -1
}
if lessThan(b.CreatedAt, b.ID, a.CreatedAt, a.ID) {
return 1
}
return 0
})
start := 0
if hasCursor {
start = len(all)
for i, m := range all {
if lessThan(afterTime, afterID, m.CreatedAt, m.ID) {
start = i
break
}
}
}
if start >= len(all) {
return []domain.Message{}, nil, nil
}
end := start + limit
if end > len(all) {
end = len(all)
}
page := all[start:end]
var next *string
if end < len(all) {
last := page[len(page)-1]
c := encodeCursor(scope, last.CreatedAt, last.ID)
next = &c
}
return page, next, nil
}
@@ -0,0 +1,34 @@
package memory
import (
"sync"
"high-loud-apps-labs/internal/domain"
)
type Storage struct {
mu sync.RWMutex
users map[string]*domain.User
chats map[string]*domain.Chat
messages map[string][]domain.Message
}
func New() *Storage {
return &Storage{
users: make(map[string]*domain.User),
chats: make(map[string]*domain.Chat),
messages: make(map[string][]domain.Message),
}
}
func (s *Storage) Users() *UserRepo { return &UserRepo{s} }
func (s *Storage) Chats() *ChatRepo { return &ChatRepo{s} }
func (s *Storage) Messages() *MessageRepo { return &MessageRepo{s} }
type UserRepo struct{ *Storage }
type ChatRepo struct{ *Storage }
type MessageRepo struct{ *Storage }
var _ domain.UserRepository = (*UserRepo)(nil)
var _ domain.ChatRepository = (*ChatRepo)(nil)
var _ domain.MessageRepository = (*MessageRepo)(nil)
@@ -0,0 +1,59 @@
package memory
import (
"context"
"high-loud-apps-labs/internal/domain"
)
func (r *UserRepo) Create(ctx context.Context, user *domain.User) error {
if err := ctx.Err(); err != nil {
return err
}
r.mu.Lock()
defer r.mu.Unlock()
for _, u := range r.users {
if u.Username == user.Username {
return &domain.AlreadyExistsError{
Entity: "user",
Field: "username",
Value: user.Username,
}
}
}
stored := *user
r.users[user.ID] = &stored
return nil
}
func (r *UserRepo) GetByID(ctx context.Context, id string) (*domain.User, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
u, ok := r.users[id]
if !ok {
return nil, &domain.NotFoundError{Entity: "user", ID: id}
}
copy := *u
return &copy, nil
}
func (r *UserRepo) GetByUsername(ctx context.Context, username string) (*domain.User, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
for _, u := range r.users {
if u.Username == username {
copy := *u
return &copy, nil
}
}
return nil, &domain.NotFoundError{Entity: "user", ID: username}
}
@@ -0,0 +1,47 @@
package postgres
import (
"context"
"high-loud-apps-labs/internal/domain"
"github.com/jackc/pgx/v5/pgxpool"
)
type AttachmentVariantRepo struct {
pool *pgxpool.Pool
}
func NewAttachmentVariantRepo(pool *pgxpool.Pool) *AttachmentVariantRepo {
return &AttachmentVariantRepo{pool: pool}
}
func (r *AttachmentVariantRepo) Upsert(ctx context.Context, tx domain.Tx, v *domain.AttachmentVariant) error {
const q = `
INSERT INTO attachment_variants
(attachment_id, name, object_key, content_type, size_bytes, width, height, sha256, created_at)
VALUES ($1::uuid, $2, $3, $4, $5, $6, $7, $8, $9)
ON CONFLICT (attachment_id, name) DO NOTHING
`
return tx.Exec(ctx, q, v.AttachmentID, v.Name, v.ObjectKey, v.ContentType, v.SizeBytes, v.Width, v.Height, v.SHA256, v.CreatedAt)
}
func (r *AttachmentVariantRepo) ListByAttachment(ctx context.Context, id string) ([]domain.AttachmentVariant, error) {
const q = `SELECT attachment_id, name, object_key, content_type, size_bytes, width, height, sha256, created_at FROM attachment_variants WHERE attachment_id = $1::uuid`
rows, err := r.pool.Query(ctx, q, id)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
var out []domain.AttachmentVariant
for rows.Next() {
var v domain.AttachmentVariant
if err := rows.Scan(&v.AttachmentID, &v.Name, &v.ObjectKey, &v.ContentType, &v.SizeBytes, &v.Width, &v.Height, &v.SHA256, &v.CreatedAt); err != nil {
return nil, mapError(err)
}
out = append(out, v)
}
return out, mapError(rows.Err())
}
var _ domain.AttachmentVariantRepository = (*AttachmentVariantRepo)(nil)
@@ -0,0 +1,352 @@
package postgres
import (
"context"
"log"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type AttachmentRepo struct {
pool *pgxpool.Pool
}
func NewAttachmentRepo(pool *pgxpool.Pool) *AttachmentRepo {
return &AttachmentRepo{pool: pool}
}
func (r *AttachmentRepo) Create(ctx context.Context, a *domain.Attachment) error {
const q = `
INSERT INTO attachments
(id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, status, error_code, created_at, updated_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5, $6, $7, $8, $9, NULL, $10, $10)`
_, err := r.pool.Exec(ctx, q,
a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes,
a.SHA256, a.ObjectKey, string(a.Status), a.CreatedAt,
)
if err != nil {
if uniqueViolation(err) {
return &domain.AlreadyExistsError{
Entity: "attachment",
Field: "object_key",
Value: a.ObjectKey,
}
}
if foreignKeyViolation(err) {
return &domain.NotFoundError{Entity: "chat", ID: a.ChatID}
}
if checkViolation(err) {
return &domain.ValidationError{
Field: "attachment",
Message: "нарушено ограничение целостности",
}
}
return mapError(err)
}
return nil
}
func (r *AttachmentRepo) CreateInTx(ctx context.Context, tx domain.Tx, a *domain.Attachment) error {
const q = `
INSERT INTO attachments
(id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, status, error_code,
attempts, pipeline_version, staging_key,
created_at, updated_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5, $6, $7, $8, $9, NULL,
0, $10, $11, $12, $12)
`
return tx.Exec(ctx, q,
a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes,
a.SHA256, a.ObjectKey, string(a.Status),
a.PipelineVersion, a.StagingKey, a.CreatedAt,
)
}
func (r *AttachmentRepo) GetByID(ctx context.Context, id string) (*domain.Attachment, error) {
const q = `
SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, status, error_code, created_at, updated_at,
attempts, next_attempt_at, locked_until, pipeline_version, staging_key
FROM attachments
WHERE id = $1::uuid
`
a := &domain.Attachment{}
var status string
err := r.pool.QueryRow(ctx, q, id).
Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType,
&a.SizeBytes, &a.SHA256, &a.ObjectKey, &status, &a.ErrorCode,
&a.CreatedAt, &a.UpdatedAt,
&a.Attempts, &a.NextAttemptAt, &a.LockedUntil, &a.PipelineVersion, &a.StagingKey)
if err != nil {
return nil, notFound(err, "attachment", id)
}
a.Status = domain.AttachmentStatus(status)
rows, err := r.pool.Query(ctx, `
SELECT name, object_key, content_type, size_bytes, width, height, sha256, created_at
FROM attachment_variants
WHERE attachment_id = $1::uuid
ORDER BY name
`, id)
if err != nil {
log.Printf("GetByID: ошибка запроса variants: %v", err)
} else {
defer rows.Close()
for rows.Next() {
var v domain.AttachmentVariant
v.AttachmentID = id
if err := rows.Scan(&v.Name, &v.ObjectKey, &v.ContentType, &v.SizeBytes, &v.Width, &v.Height, &v.SHA256, &v.CreatedAt); err != nil {
log.Printf("GetByID: ошибка Scan variant: %v", err)
} else {
a.Variants = append(a.Variants, v)
}
}
}
return a, nil
}
func (r *AttachmentRepo) MarkReady(ctx context.Context, id string) error {
const q = `
UPDATE attachments
SET status = 'ready', updated_at = now()
WHERE id = $1::uuid AND status = 'pending'
`
tag, err := r.pool.Exec(ctx, q, id)
if err != nil {
return mapError(err)
}
if tag.RowsAffected() > 0 {
return nil
}
var status string
err = r.pool.QueryRow(ctx, `SELECT status FROM attachments WHERE id = $1::uuid`, id).
Scan(&status)
if err != nil {
return notFound(err, "attachment", id)
}
switch domain.AttachmentStatus(status) {
case domain.AttachmentStatusReady:
return nil
case domain.AttachmentStatusFailed:
return &domain.ConflictError{Reason: "нельзя перевести failed-вложение в ready"}
default:
return &domain.ConflictError{Reason: "некорректное состояние вложения"}
}
}
func (r *AttachmentRepo) MarkFailed(ctx context.Context, id, errorCode string) error {
if errorCode == "" {
return &domain.ValidationError{Field: "error_code", Message: "не может быть пустым"}
}
const q = `
UPDATE attachments
SET status = 'failed', error_code = $2, updated_at = now()
WHERE id = $1::uuid AND status = 'pending'
`
tag, err := r.pool.Exec(ctx, q, id, errorCode)
if err != nil {
return mapError(err)
}
if tag.RowsAffected() > 0 {
return nil
}
var status string
err = r.pool.QueryRow(ctx, `SELECT status FROM attachments WHERE id = $1::uuid`, id).
Scan(&status)
if err != nil {
return notFound(err, "attachment", id)
}
switch domain.AttachmentStatus(status) {
case domain.AttachmentStatusFailed, domain.AttachmentStatusReady:
return nil
default:
return &domain.ConflictError{Reason: "некорректное состояние вложения"}
}
}
func (r *AttachmentRepo) ExistingKeys(ctx context.Context, keys []string) ([]string, error) {
if len(keys) == 0 {
return []string{}, nil
}
const q = `SELECT object_key FROM attachments WHERE object_key = ANY($1::text[])`
rows, err := r.pool.Query(ctx, q, keys)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
out := make([]string, 0, len(keys))
for rows.Next() {
var k string
if err := rows.Scan(&k); err != nil {
return nil, mapError(err)
}
out = append(out, k)
}
return out, mapError(rows.Err())
}
func (r *AttachmentRepo) ClaimForProcessing(ctx context.Context, id string, version int, lease time.Duration) (*domain.Attachment, error) {
const q = `
UPDATE attachments
SET status = 'processing', locked_until = now() + $2, updated_at = now(), attempts = attempts + 1
WHERE id = $1::uuid AND status = 'queued' AND pipeline_version = $3
RETURNING id, chat_id, staging_key, pipeline_version, object_key, content_type, attempts
`
var a domain.Attachment
err := r.pool.QueryRow(ctx, q, id, lease, version).Scan(&a.ID, &a.ChatID, &a.StagingKey, &a.PipelineVersion, &a.ObjectKey, &a.ContentType, &a.Attempts)
if err != nil {
if err == pgx.ErrNoRows {
return nil, nil
}
return nil, mapError(err)
}
return &a, nil
}
func (r *AttachmentRepo) CompleteJob(ctx context.Context, id string, pipelineVersion int, variants []domain.AttachmentVariant) (bool, error) {
tx, err := r.pool.Begin(ctx)
if err != nil {
return false, mapError(err)
}
defer func() { _ = tx.Rollback(ctx) }()
const q = `
UPDATE attachments
SET status = 'ready', locked_until = NULL, updated_at = now()
WHERE id = $1::uuid AND pipeline_version = $2 AND status = 'processing'
`
tag, err := tx.Exec(ctx, q, id, pipelineVersion)
if err != nil {
return false, mapError(err)
}
if tag.RowsAffected() == 0 {
return false, nil
}
variantRepo := NewAttachmentVariantRepo(r.pool)
for _, v := range variants {
if err := variantRepo.Upsert(ctx, &pgxTx{tx: tx}, &v); err != nil {
log.Printf("CompleteJob: ошибка Upsert %s: %v", v.Name, err)
return false, err
} else {
log.Printf("CompleteJob: успешно добавлен вариант %s", v.Name)
}
}
return true, mapError(tx.Commit(ctx))
}
func (r *AttachmentRepo) FailJob(ctx context.Context, id string, errorCode string) error {
const q = `
UPDATE attachments
SET status = 'failed', error_code = $2, locked_until = NULL, updated_at = now()
WHERE id = $1::uuid AND status = 'processing'
`
_, err := r.pool.Exec(ctx, q, id, errorCode)
return mapError(err)
}
func (r *AttachmentRepo) ScheduleRetry(ctx context.Context, id string, nextAttemptAt time.Time, errorCode string) error {
const q = `
UPDATE attachments
SET status = 'queued', error_code = NULL, next_attempt_at = $2, locked_until = NULL, updated_at = now()
WHERE id = $1::uuid AND status = 'processing'
`
_, err := r.pool.Exec(ctx, q, id, nextAttemptAt)
return mapError(err)
}
func (r *AttachmentRepo) ResetForReplay(ctx context.Context, tx domain.Tx, id string) error {
const q = `
UPDATE attachments
SET status = 'queued', attempts = 0, error_code = NULL, locked_until = NULL, next_attempt_at = NULL, updated_at = now()
WHERE id = $1::uuid AND status = 'failed'
`
return tx.Exec(ctx, q, id)
}
// для сверщика.
func (r *AttachmentRepo) ListExpiredLeases(ctx context.Context, limit int) ([]domain.Attachment, error) {
const q = `
SELECT id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, status, error_code, created_at, updated_at,
attempts, next_attempt_at, locked_until, pipeline_version, staging_key
FROM attachments
WHERE status = 'processing' AND locked_until < now()
ORDER BY locked_until
LIMIT $1
`
rows, err := r.pool.Query(ctx, q, limit)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
var out []domain.Attachment
for rows.Next() {
var a domain.Attachment
var status string
err := rows.Scan(&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType,
&a.SizeBytes, &a.SHA256, &a.ObjectKey, &status, &a.ErrorCode,
&a.CreatedAt, &a.UpdatedAt, &a.Attempts, &a.NextAttemptAt, &a.LockedUntil,
&a.PipelineVersion, &a.StagingKey)
if err != nil {
return nil, mapError(err)
}
a.Status = domain.AttachmentStatus(status)
out = append(out, a)
}
return out, mapError(rows.Err())
}
func (r *AttachmentRepo) ResetLease(ctx context.Context, id string) error {
const q = `
UPDATE attachments
SET status = 'queued', locked_until = NULL, updated_at = now()
WHERE id = $1::uuid AND status = 'processing' AND locked_until < now()
`
_, err := r.pool.Exec(ctx, q, id)
return mapError(err)
}
func (r *AttachmentRepo) ListStagingToCleanup(ctx context.Context, limit int) ([]domain.Attachment, error) {
const q = `
SELECT id, staging_key
FROM attachments
WHERE status = 'ready' AND staging_key IS NOT NULL
LIMIT $1
`
rows, err := r.pool.Query(ctx, q, limit)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
var out []domain.Attachment
for rows.Next() {
var a domain.Attachment
if err := rows.Scan(&a.ID, &a.StagingKey); err != nil {
return nil, mapError(err)
}
out = append(out, a)
}
return out, mapError(rows.Err())
}
func (r *AttachmentRepo) ClearStagingKey(ctx context.Context, id string) error {
const q = `UPDATE attachments SET staging_key = NULL WHERE id = $1::uuid`
_, err := r.pool.Exec(ctx, q, id)
return mapError(err)
}
var _ domain.AttachmentRepository = (*AttachmentRepo)(nil)
+195
View File
@@ -0,0 +1,195 @@
package postgres
import (
"context"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type ChatRepo struct {
pool *pgxpool.Pool
}
func NewChatRepo(pool *pgxpool.Pool) *ChatRepo {
return &ChatRepo{pool: pool}
}
// Create атомарно создаёт чат и его участников.
func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error {
tx, err := r.pool.Begin(ctx)
if err != nil {
return mapError(err)
}
defer func() { _ = tx.Rollback(ctx) }()
const qChat = `INSERT INTO chats (id, title, created_at) VALUES ($1::uuid, $2, $3)`
if _, err := tx.Exec(ctx, qChat, chat.ID, chat.Title, chat.CreatedAt); err != nil {
if checkViolation(err) {
return &domain.ValidationError{Field: "chat", Message: "нарушено ограничение целостности"}
}
return mapError(err)
}
const qMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1::uuid, $2::uuid)`
for _, uid := range chat.MemberIDs {
if _, err := tx.Exec(ctx, qMember, chat.ID, uid); err != nil {
if foreignKeyViolation(err) {
return &domain.ValidationError{
Field: "member_ids",
Message: "неизвестный участник " + uid,
}
}
if uniqueViolation(err) {
return &domain.ValidationError{
Field: "member_ids",
Message: "дубликаты запрещены",
}
}
return mapError(err)
}
}
return mapError(tx.Commit(ctx))
}
func (r *ChatRepo) GetByID(ctx context.Context, id string) (*domain.Chat, error) {
const q = `SELECT id, title, created_at FROM chats WHERE id = $1::uuid`
c := &domain.Chat{}
err := r.pool.QueryRow(ctx, q, id).Scan(&c.ID, &c.Title, &c.CreatedAt)
if err != nil {
return nil, notFound(err, "chat", id)
}
members, err := r.loadMembers(ctx, []string{c.ID})
if err != nil {
return nil, err
}
c.MemberIDs = members[c.ID]
if c.MemberIDs == nil {
c.MemberIDs = []string{}
}
return c, nil
}
func (r *ChatRepo) ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) {
scope := "chats:" + userID
var (
afterTime time.Time
afterID string
hasCursor bool
)
if cursor != nil {
t, id, err := decodeCursor(*cursor, scope)
if err != nil {
return nil, nil, err
}
afterTime = t
afterID = id
hasCursor = true
}
var (
rows pgx.Rows
err error
)
if hasCursor {
const q = `
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, $3::uuid)
ORDER BY c.created_at, c.id
LIMIT $4
`
rows, err = r.pool.Query(ctx, q, userID, afterTime, afterID, limit+1)
} else {
const q = `
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
ORDER BY c.created_at, c.id
LIMIT $2
`
rows, err = r.pool.Query(ctx, q, userID, limit+1)
}
if err != nil {
return nil, nil, mapError(err)
}
defer rows.Close()
page := make([]domain.Chat, 0, limit)
for rows.Next() {
var c domain.Chat
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
return nil, nil, mapError(err)
}
page = append(page, c)
}
if err := rows.Err(); err != nil {
return nil, nil, mapError(err)
}
var next *string
if len(page) > limit {
page = page[:limit]
last := page[len(page)-1]
c := encodeCursor(scope, last.CreatedAt, last.ID)
next = &c
}
if len(page) > 0 {
ids := make([]string, len(page))
for i := range page {
ids[i] = page[i].ID
}
members, err := r.loadMembers(ctx, ids)
if err != nil {
return nil, nil, err
}
for i := range page {
if m, ok := members[page[i].ID]; ok {
page[i].MemberIDs = m
} else {
page[i].MemberIDs = []string{}
}
}
}
return page, next, nil
}
// loadMembers одним запросом собирает участников для указанных чатов.
func (r *ChatRepo) loadMembers(ctx context.Context, chatIDs []string) (map[string][]string, error) {
if len(chatIDs) == 0 {
return map[string][]string{}, nil
}
const q = `
SELECT chat_id, user_id
FROM chat_members
WHERE chat_id = ANY($1::uuid[])
ORDER BY chat_id, user_id
`
rows, err := r.pool.Query(ctx, q, chatIDs)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
result := make(map[string][]string, len(chatIDs))
for rows.Next() {
var chatID, userID string
if err := rows.Scan(&chatID, &userID); err != nil {
return nil, mapError(err)
}
result[chatID] = append(result[chatID], userID)
}
return result, mapError(rows.Err())
}
var _ domain.ChatRepository = (*ChatRepo)(nil)
@@ -0,0 +1,46 @@
package postgres
import (
"encoding/base64"
"strings"
"time"
"high-loud-apps-labs/internal/domain"
"github.com/google/uuid"
)
// Взял за основу что в inmemery делал
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) {
data, err := base64.RawURLEncoding.DecodeString(cursor)
if err != nil {
return time.Time{}, "", badCursor()
}
parts := strings.SplitN(string(data), "|", 3)
if len(parts) != 3 {
return time.Time{}, "", badCursor()
}
if parts[0] != expectedScope {
return time.Time{}, "", badCursor()
}
t, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return time.Time{}, "", badCursor()
}
if _, err := uuid.Parse(parts[2]); err != nil {
return time.Time{}, "", badCursor()
}
return t, parts[2], nil
}
func badCursor() error {
return &domain.ValidationError{
Field: "cursor",
Message: "некорректный формат",
}
}
+75
View File
@@ -0,0 +1,75 @@
package postgres
import (
"context"
"fmt"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/jackc/pgx/v5/stdlib"
"github.com/pressly/goose/v3"
"high-loud-apps-labs/migrations"
)
type Config struct {
URL string
MaxConns int32
MinConns int32
MaxConnLifetime time.Duration
MaxConnIdleTime time.Duration
ConnectTimeout time.Duration
}
func Connect(ctx context.Context, cfg Config) (*pgxpool.Pool, error) {
if cfg.URL == "" {
return nil, fmt.Errorf("DATABASE_URL пустой")
}
poolCfg, err := pgxpool.ParseConfig(cfg.URL)
if err != nil {
return nil, fmt.Errorf("разбор DATABASE_URL: %w", err)
}
if cfg.MaxConns > 0 {
poolCfg.MaxConns = cfg.MaxConns
}
if cfg.MinConns > 0 {
poolCfg.MinConns = cfg.MinConns
}
if cfg.MaxConnLifetime > 0 {
poolCfg.MaxConnLifetime = cfg.MaxConnLifetime
}
if cfg.MaxConnIdleTime > 0 {
poolCfg.MaxConnIdleTime = cfg.MaxConnIdleTime
}
if cfg.ConnectTimeout > 0 {
poolCfg.ConnConfig.ConnectTimeout = cfg.ConnectTimeout
}
poolCfg.HealthCheckPeriod = 10 * time.Second
pool, err := pgxpool.NewWithConfig(ctx, poolCfg)
if err != nil {
return nil, fmt.Errorf("создание пула: %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
}
func RunMigrations(ctx context.Context, pool *pgxpool.Pool) error {
db := stdlib.OpenDBFromPool(pool)
goose.SetBaseFS(migrations.FS)
if err := goose.SetDialect("postgres"); err != nil {
return fmt.Errorf("goose dialect: %w", err)
}
if err := goose.UpContext(ctx, db, "."); err != nil {
return fmt.Errorf("применение миграций: %w", err)
}
return nil
}
@@ -0,0 +1,71 @@
package postgres
import (
"context"
"errors"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"high-loud-apps-labs/internal/domain"
)
type coded interface {
Code() domain.ErrorCode
}
// mapError переводит ошибки драйвера в доменные.
func mapError(err error) error {
if err == nil {
return nil
}
var c coded
if errors.As(err, &c) {
return err
}
if errors.Is(err, pgx.ErrNoRows) {
return err
}
if errors.Is(err, context.DeadlineExceeded) {
return &domain.UnavailableError{Reason: "превышено время ожидания БД"}
}
if errors.Is(err, context.Canceled) {
return &domain.UnavailableError{Reason: "запрос отменён"}
}
return &domain.UnavailableError{Reason: err.Error()}
}
func notFound(err error, entity, id string) error {
if err == nil {
return nil
}
if errors.Is(err, pgx.ErrNoRows) {
return &domain.NotFoundError{Entity: entity, ID: id}
}
return mapError(err)
}
func uniqueViolation(err error) bool {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
return pgErr.Code == pgerrcode.UniqueViolation
}
return false
}
func foreignKeyViolation(err error) bool {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
return pgErr.Code == pgerrcode.ForeignKeyViolation
}
return false
}
func checkViolation(err error) bool {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
return pgErr.Code == pgerrcode.CheckViolation
}
return false
}
@@ -0,0 +1,51 @@
package postgres
import (
"context"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type FailedJobRepo struct {
pool *pgxpool.Pool
}
func NewFailedJobRepo(pool *pgxpool.Pool) *FailedJobRepo {
return &FailedJobRepo{pool: pool}
}
func (r *FailedJobRepo) Record(ctx context.Context, f *domain.FailedJob) error {
if f.ID == "" {
f.ID = uuid.NewString()
}
if f.LastErrorAt.IsZero() {
f.LastErrorAt = time.Now().UTC()
}
const q = `
INSERT INTO failed_jobs (id, attachment_id, reason_code, attempts, last_error_at, created_at)
VALUES ($1::uuid, $2::uuid, $3, $4, $5, $5)
`
_, err := r.pool.Exec(ctx, q, f.ID, f.AttachmentID, f.ReasonCode, f.Attempts, f.LastErrorAt)
return mapError(err)
}
func (r *FailedJobRepo) Resolve(ctx context.Context, attachmentID string, resolution string) error {
const q = `UPDATE failed_jobs SET resolved_at = now(), resolution = $2 WHERE attachment_id = $1::uuid AND resolved_at IS NULL`
_, err := r.pool.Exec(ctx, q, attachmentID, resolution)
return mapError(err)
}
func (r *FailedJobRepo) ResolveInTx(ctx context.Context, tx domain.Tx, id string) error {
const q = `
UPDATE failed_jobs
SET resolved_at = now(), resolution = 'manual_replay'
WHERE attachment_id = $1::uuid AND resolved_at IS NULL
`
return tx.Exec(ctx, q, id)
}
var _ domain.FailedJobRepository = (*FailedJobRepo)(nil)
@@ -0,0 +1,321 @@
package postgres
import (
"bytes"
"context"
"net/http"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type MessageRepo struct {
pool *pgxpool.Pool
}
func NewMessageRepo(pool *pgxpool.Pool) *MessageRepo {
return &MessageRepo{pool: pool}
}
func (r *MessageRepo) Create(ctx context.Context, m *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)
`
_, err := r.pool.Exec(ctx, q, m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt)
if err != nil {
if foreignKeyViolation(err) {
return &domain.NotFoundError{Entity: "chat", ID: m.ChatID}
}
if checkViolation(err) {
return &domain.ValidationError{Field: "text", Message: "нарушено ограничение"}
}
return mapError(err)
}
return nil
}
func (r *MessageRepo) CreateIdempotent(
ctx context.Context,
scope domain.IdempotencyScope,
requestHash []byte,
fresh *domain.Message,
freshResponse []byte,
ttl time.Duration,
) (*domain.CreateIdempotentResult, error) {
tx, err := r.pool.Begin(ctx)
if err != nil {
return nil, mapError(err)
}
defer func() { _ = tx.Rollback(ctx) }()
// 1) Убираем просроченную запись, чтобы ON CONFLICT сработал
// только на живой, а не на истёкшей строке.
if _, err := tx.Exec(ctx, `
DELETE FROM idempotency_keys
WHERE user_id = $1::uuid AND method = $2 AND path = $3 AND key = $4
AND expires_at <= now()
`, scope.UserID, scope.Method, scope.Path, scope.Key); err != nil {
return nil, mapError(err)
}
// 2) Резервируем слот. Если параллельная реплика уже вставила —
// Postgres заблокирует конфликтный INSERT и мы увидим RowsAffected=0
// только после того, как конкурент закоммитит или откатится.
expiresAt := time.Now().UTC().Add(ttl)
tag, err := tx.Exec(ctx, `
INSERT INTO idempotency_keys
(user_id, method, path, key, request_hash, response_status, response_body, expires_at)
VALUES ($1::uuid, $2, $3, $4, $5, $6, $7, $8)
ON CONFLICT (user_id, method, path, key) DO NOTHING
`, scope.UserID, scope.Method, scope.Path, scope.Key,
requestHash, http.StatusCreated, freshResponse, expiresAt)
if err != nil {
return nil, mapError(err)
}
// 3) Слот занят — читаем сохранённый ответ в этой же транзакции.
if tag.RowsAffected() == 0 {
var (
storedHash []byte
storedStatus int
storedBody []byte
)
err := tx.QueryRow(ctx, `
SELECT request_hash, response_status, response_body
FROM idempotency_keys
WHERE user_id = $1::uuid AND method = $2 AND path = $3 AND key = $4
`, scope.UserID, scope.Method, scope.Path, scope.Key).
Scan(&storedHash, &storedStatus, &storedBody)
if err != nil {
return nil, mapError(err)
}
if !bytes.Equal(storedHash, requestHash) {
return nil, &domain.IdempotencyConflictError{Key: scope.Key}
}
if err := tx.Commit(ctx); err != nil {
return nil, mapError(err)
}
return &domain.CreateIdempotentResult{
Status: storedStatus,
Body: storedBody,
Replayed: true,
}, nil
}
// 4) Слот наш — валидируем вложения, вставляем сообщение, линкуем
// вложения. Всё в одной транзакции: при ошибке на любом шаге
// откатывается и idempotency-ключ, и сообщение, и связи.
if err := r.validateAttachments(ctx, tx, fresh.ChatID, fresh.AttachmentIDs); err != nil {
return nil, err
}
if _, err := tx.Exec(ctx, `
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5)
`, fresh.ID, fresh.ChatID, fresh.SenderID, fresh.Text, fresh.CreatedAt); err != nil {
if foreignKeyViolation(err) {
return nil, &domain.NotFoundError{Entity: "chat", ID: fresh.ChatID}
}
if checkViolation(err) {
return nil, &domain.ValidationError{Field: "text", Message: "нарушено ограничение"}
}
return nil, mapError(err)
}
if err := r.linkAttachments(ctx, tx, fresh.ID, fresh.AttachmentIDs); err != nil {
return nil, err
}
if err := tx.Commit(ctx); err != nil {
return nil, mapError(err)
}
return &domain.CreateIdempotentResult{
Status: http.StatusCreated,
Body: freshResponse,
Replayed: false,
}, nil
}
func (r *MessageRepo) ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) {
scope := "messages:" + chatID
var (
afterTime time.Time
afterID string
hasCursor bool
)
if cursor != nil {
t, id, err := decodeCursor(*cursor, scope)
if err != nil {
return nil, nil, err
}
afterTime = t
afterID = id
hasCursor = true
}
var (
rows pgx.Rows
err error
)
if hasCursor {
const q = `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1::uuid
AND (created_at, id) > ($2, $3::uuid)
ORDER BY created_at, id
LIMIT $4
`
rows, err = r.pool.Query(ctx, q, chatID, afterTime, afterID, limit+1)
} else {
const q = `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1::uuid
ORDER BY created_at, id
LIMIT $2
`
rows, err = r.pool.Query(ctx, q, chatID, limit+1)
}
if err != nil {
return nil, nil, err
}
defer rows.Close()
page := make([]domain.Message, 0, limit)
for rows.Next() {
var m domain.Message
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
return nil, nil, err
}
page = append(page, m)
}
if err := rows.Err(); err != nil {
return nil, nil, err
}
var next *string
if len(page) > limit {
page = page[:limit]
last := page[len(page)-1]
c := encodeCursor(scope, last.CreatedAt, last.ID)
next = &c
}
if len(page) > 0 {
msgIDs := make([]string, len(page))
for i := range page {
msgIDs[i] = page[i].ID
}
links, err := r.loadAttachmentIDs(ctx, msgIDs)
if err != nil {
return nil, nil, err
}
for i := range page {
if ids, ok := links[page[i].ID]; ok {
page[i].AttachmentIDs = ids
} else {
page[i].AttachmentIDs = []string{}
}
}
}
return page, next, nil
}
func (r *MessageRepo) validateAttachments(ctx context.Context, tx pgx.Tx, chatID string, ids []string) error {
if len(ids) == 0 {
return nil
}
const q = `SELECT id, chat_id, status FROM attachments WHERE id = ANY($1::uuid[])`
rows, err := tx.Query(ctx, q, ids)
if err != nil {
return mapError(err)
}
defer rows.Close()
type info struct {
chatID string
status domain.AttachmentStatus
}
found := make(map[string]info, len(ids))
for rows.Next() {
var id, chID, st string
if err := rows.Scan(&id, &chID, &st); err != nil {
return mapError(err)
}
found[id] = info{chatID: chID, status: domain.AttachmentStatus(st)}
}
if err := rows.Err(); err != nil {
return mapError(err)
}
for _, id := range ids {
a, ok := found[id]
if !ok || a.chatID != chatID {
return &domain.NotFoundError{Entity: "attachment", ID: id}
}
if a.status == domain.AttachmentStatusFailed {
return &domain.ConflictError{Reason: "вложение " + id + " в состоянии failed"}
}
}
return nil
}
func (r *MessageRepo) linkAttachments(ctx context.Context, tx pgx.Tx, messageID string, ids []string) error {
if len(ids) == 0 {
return nil
}
const q = `INSERT INTO message_attachments (message_id, attachment_id, position) VALUES ($1::uuid, $2::uuid, $3)`
for i, id := range ids {
if _, err := tx.Exec(ctx, q, messageID, id, int16(i)); err != nil {
if foreignKeyViolation(err) {
return &domain.NotFoundError{Entity: "attachment", ID: id}
}
if uniqueViolation(err) {
return &domain.ValidationError{Field: "attachment_ids", Message: "дубликаты запрещены"}
}
if checkViolation(err) {
return &domain.ValidationError{Field: "attachment_ids", Message: "нарушено ограничение"}
}
return mapError(err)
}
}
return nil
}
func (r *MessageRepo) loadAttachmentIDs(ctx context.Context, messageIDs []string) (map[string][]string, error) {
if len(messageIDs) == 0 {
return map[string][]string{}, nil
}
const q = `
SELECT message_id, attachment_id
FROM message_attachments
WHERE message_id = ANY($1::uuid[])
ORDER BY message_id, position
`
rows, err := r.pool.Query(ctx, q, messageIDs)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
result := make(map[string][]string, len(messageIDs))
for rows.Next() {
var msgID, attID string
if err := rows.Scan(&msgID, &attID); err != nil {
return nil, mapError(err)
}
result[msgID] = append(result[msgID], attID)
}
return result, mapError(rows.Err())
}
var _ domain.MessageRepository = (*MessageRepo)(nil)
+116
View File
@@ -0,0 +1,116 @@
package postgres
import (
"context"
"time"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type OutboxRepo struct {
pool *pgxpool.Pool
}
func NewOutboxRepo(pool *pgxpool.Pool) *OutboxRepo {
return &OutboxRepo{pool: pool}
}
func (r *OutboxRepo) Enqueue(ctx context.Context, tx domain.Tx, e *domain.OutboxEntry) error {
if e.AggregateType == "" || e.AggregateID == "" || e.EventType == "" {
return &domain.ValidationError{
Field: "outbox",
Message: "aggregate_type, aggregate_id и event_type обязательны",
}
}
if len(e.Payload) == 0 {
return &domain.ValidationError{
Field: "outbox.payload",
Message: "не может быть пустым",
}
}
if e.ID == "" {
e.ID = uuid.NewString()
}
if e.CreatedAt.IsZero() {
e.CreatedAt = time.Now().UTC()
}
const q = `
INSERT INTO outbox
(id, aggregate_type, aggregate_id, event_type, payload, attempts, created_at, published_at)
VALUES ($1::uuid, $2, $3::uuid, $4, $5::jsonb, $6, $7, $8)
`
if err := tx.Exec(ctx, q,
e.ID, e.AggregateType, e.AggregateID, e.EventType,
string(e.Payload), e.Attempts, e.CreatedAt, e.PublishedAt,
); err != nil {
return err
}
return nil
}
func (r *OutboxRepo) ClaimBatch(ctx context.Context, limit int) ([]domain.OutboxEntry, error) {
const q = `
WITH claimed AS (
SELECT id FROM outbox
WHERE published_at IS NULL AND created_at <= now()
ORDER BY created_at
LIMIT $1
FOR UPDATE SKIP LOCKED
)
UPDATE outbox o
SET attempts = attempts + 1
FROM claimed c
WHERE o.id = c.id
RETURNING o.id, o.aggregate_type, o.aggregate_id, o.event_type, o.payload, o.attempts, o.created_at, o.published_at
`
rows, err := r.pool.Query(ctx, q, limit)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
var entries []domain.OutboxEntry
for rows.Next() {
var e domain.OutboxEntry
if err := rows.Scan(
&e.ID, &e.AggregateType, &e.AggregateID, &e.EventType,
&e.Payload, &e.Attempts, &e.CreatedAt, &e.PublishedAt,
); err != nil {
return nil, mapError(err)
}
entries = append(entries, e)
}
return entries, mapError(rows.Err())
}
func (r *OutboxRepo) EnqueueDirect(ctx context.Context, e *domain.OutboxEntry) error {
if e.ID == "" {
e.ID = uuid.NewString()
}
const q = `
INSERT INTO outbox
(id, aggregate_type, aggregate_id, event_type, payload, attempts, created_at, published_at)
VALUES ($1::uuid, $2, $3::uuid, $4, $5::jsonb, $6, $7, $8)
`
_, err := r.pool.Exec(ctx, q,
e.ID, e.AggregateType, e.AggregateID, e.EventType,
string(e.Payload), e.Attempts, e.CreatedAt, e.PublishedAt,
)
return mapError(err)
}
func (r *OutboxRepo) MarkPublished(ctx context.Context, ids []string) error {
if len(ids) == 0 {
return nil
}
const q = `UPDATE outbox SET published_at = now() WHERE id = ANY($1::uuid[])`
_, err := r.pool.Exec(ctx, q, ids)
return mapError(err)
}
var _ domain.OutboxRepository = (*OutboxRepo)(nil)
@@ -0,0 +1,59 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type SessionRepo struct {
pool *pgxpool.Pool
}
func NewSessionRepo(pool *pgxpool.Pool) *SessionRepo {
return &SessionRepo{pool: pool}
}
func (r *SessionRepo) Create(ctx context.Context, s *domain.Session) error {
const q = `
INSERT INTO sessions (token_hash, user_id, expires_at, created_at)
VALUES ($1, $2::uuid, $3, $4)
`
_, err := r.pool.Exec(ctx, q, s.TokenHash, s.UserID, s.ExpiresAt, s.CreatedAt)
if err != nil {
if uniqueViolation(err) {
return &domain.AlreadyExistsError{
Entity: "session",
Field: "token_hash",
Value: "",
}
}
return mapError(err)
}
return nil
}
func (r *SessionRepo) GetByTokenHash(ctx context.Context, tokenHash []byte) (*domain.Session, error) {
const q = `
SELECT token_hash, user_id, expires_at, created_at
FROM sessions
WHERE token_hash = $1
`
s := &domain.Session{}
err := r.pool.QueryRow(ctx, q, tokenHash).
Scan(&s.TokenHash, &s.UserID, &s.ExpiresAt, &s.CreatedAt)
if err != nil {
return nil, notFound(err, "session", "")
}
return s, nil
}
func (r *SessionRepo) DeleteByTokenHash(ctx context.Context, tokenHash []byte) error {
const q = `DELETE FROM sessions WHERE token_hash = $1`
_, err := r.pool.Exec(ctx, q, tokenHash)
return mapError(err)
}
var _ domain.SessionRepository = (*SessionRepo)(nil)
@@ -0,0 +1,22 @@
package postgres
import "github.com/jackc/pgx/v5/pgxpool"
type Storage struct {
pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool) *Storage {
return &Storage{pool: pool}
}
func (s *Storage) Pool() *pgxpool.Pool { return s.pool }
func (s *Storage) Users() *UserRepo { return &UserRepo{pool: s.pool} }
func (s *Storage) Chats() *ChatRepo { return &ChatRepo{pool: s.pool} }
func (s *Storage) Messages() *MessageRepo { return &MessageRepo{pool: s.pool} }
func (s *Storage) Sessions() *SessionRepo { return &SessionRepo{pool: s.pool} }
func (s *Storage) Attachments() *AttachmentRepo { return &AttachmentRepo{pool: s.pool} }
func (s *Storage) Outbox() *OutboxRepo { return &OutboxRepo{pool: s.pool} }
func (s *Storage) Variants() *AttachmentVariantRepo { return &AttachmentVariantRepo{pool: s.pool} }
func (s *Storage) FailedJobs() *FailedJobRepo { return &FailedJobRepo{pool: s.pool} }
+35
View File
@@ -0,0 +1,35 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5"
"high-loud-apps-labs/internal/domain"
)
type pgxTx struct {
tx pgx.Tx
}
func (t *pgxTx) Exec(ctx context.Context, sql string, args ...any) error {
_, err := t.tx.Exec(ctx, sql, args...)
return mapError(err)
}
// WithTx выполняет fn в одной транзакции:
// - commit, если fn вернул nil;
// - rollback, если fn вернул ошибку.
func (s *Storage) WithTx(ctx context.Context, fn func(tx domain.Tx) error) error {
tx, err := s.pool.Begin(ctx)
if err != nil {
return mapError(err)
}
defer func() { _ = tx.Rollback(ctx) }()
if err := fn(&pgxTx{tx: tx}); err != nil {
return err
}
return mapError(tx.Commit(ctx))
}
+76
View File
@@ -0,0 +1,76 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type UserRepo struct {
pool *pgxpool.Pool
}
func NewUserRepo(pool *pgxpool.Pool) *UserRepo {
return &UserRepo{pool: pool}
}
func (r *UserRepo) Create(ctx context.Context, user *domain.User) 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, user.PasswordHash, user.CreatedAt,
)
if err != nil {
if uniqueViolation(err) {
return &domain.AlreadyExistsError{
Entity: "user",
Field: "username",
Value: user.Username,
}
}
if checkViolation(err) {
return &domain.ValidationError{
Field: "user",
Message: "нарушено ограничение целостности",
}
}
return mapError(err)
}
return nil
}
func (r *UserRepo) GetByID(ctx context.Context, id string) (*domain.User, error) {
const q = `
SELECT id, username, display_name, password_hash, created_at
FROM users
WHERE id = $1::uuid
`
u := &domain.User{}
err := r.pool.QueryRow(ctx, q, id).
Scan(&u.ID, &u.Username, &u.DisplayName, &u.PasswordHash, &u.CreatedAt)
if err != nil {
return nil, notFound(err, "user", id)
}
return u, nil
}
func (r *UserRepo) GetByUsername(ctx context.Context, username string) (*domain.User, error) {
const q = `
SELECT id, username, display_name, password_hash, created_at
FROM users
WHERE username = $1
`
u := &domain.User{}
err := r.pool.QueryRow(ctx, q, username).
Scan(&u.ID, &u.Username, &u.DisplayName, &u.PasswordHash, &u.CreatedAt)
if err != nil {
return nil, notFound(err, "user", username)
}
return u, nil
}
var _ domain.UserRepository = (*UserRepo)(nil)
+33
View File
@@ -0,0 +1,33 @@
package redis
import (
"context"
"fmt"
"time"
"github.com/redis/go-redis/v9"
)
func NewClient(url string) (*redis.Client, error) {
opt, err := redis.ParseURL(url)
if err != nil {
return nil, fmt.Errorf("разбор URL: %w", err)
}
opt.DialTimeout = 700 * time.Millisecond
opt.ReadTimeout = 700 * time.Millisecond
opt.WriteTimeout = 700 * time.Millisecond
opt.MaxRetries = 1
opt.PoolSize = 10
opt.ConnMaxIdleTime = time.Minute
client := redis.NewClient(opt)
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
if err := client.Ping(ctx).Err(); err != nil {
_ = client.Close()
return nil, fmt.Errorf("ping: %w", err)
}
return client, nil
}
+31
View File
@@ -0,0 +1,31 @@
package redis
import (
"context"
"errors"
"high-loud-apps-labs/internal/domain"
)
type coded interface {
Code() domain.ErrorCode
}
// mapError переводит ошибки драйвера в доменные.
// Любая недоступность redis (dial/read/write/context) → UnavailableError (503).
func mapError(err error) error {
if err == nil {
return nil
}
var c coded
if errors.As(err, &c) {
return err
}
if errors.Is(err, context.DeadlineExceeded) {
return &domain.UnavailableError{Reason: "превышено время ожидания redis"}
}
if errors.Is(err, context.Canceled) {
return &domain.UnavailableError{Reason: "запрос отменён"}
}
return &domain.UnavailableError{Reason: err.Error()}
}
+80
View File
@@ -0,0 +1,80 @@
package redis
import (
"context"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"time"
"github.com/redis/go-redis/v9"
"high-loud-apps-labs/internal/domain"
)
const sessionKeyPrefix = "session:"
type SessionRepo struct {
client *redis.Client
}
func NewSessionRepo(client *redis.Client) *SessionRepo {
return &SessionRepo{client: client}
}
type sessionValue struct {
UserID string `json:"user_id"`
ExpiresAt time.Time `json:"expires_at"`
CreatedAt time.Time `json:"created_at"`
}
func (r *SessionRepo) key(tokenHash []byte) string {
return sessionKeyPrefix + hex.EncodeToString(tokenHash)
}
func (r *SessionRepo) Create(ctx context.Context, s *domain.Session) error {
ttl := time.Until(s.ExpiresAt)
if ttl <= 0 {
return nil
}
data, err := json.Marshal(sessionValue{
UserID: s.UserID,
ExpiresAt: s.ExpiresAt.UTC(),
CreatedAt: s.CreatedAt.UTC(),
})
if err != nil {
return fmt.Errorf("сериализация сессии: %w", err)
}
return mapError(r.client.Set(ctx, r.key(s.TokenHash), data, ttl).Err())
}
func (r *SessionRepo) GetByTokenHash(ctx context.Context, tokenHash []byte) (*domain.Session, error) {
data, err := r.client.Get(ctx, r.key(tokenHash)).Bytes()
if err != nil {
if errors.Is(err, redis.Nil) {
return nil, &domain.NotFoundError{Entity: "session"}
}
return nil, mapError(err)
}
var sv sessionValue
if err := json.Unmarshal(data, &sv); err != nil {
return nil, fmt.Errorf("разбор сессии: %w", err)
}
return &domain.Session{
TokenHash: tokenHash,
UserID: sv.UserID,
ExpiresAt: sv.ExpiresAt,
CreatedAt: sv.CreatedAt,
}, nil
}
func (r *SessionRepo) DeleteByTokenHash(ctx context.Context, tokenHash []byte) error {
return mapError(r.client.Del(ctx, r.key(tokenHash)).Err())
}
var _ domain.SessionRepository = (*SessionRepo)(nil)
+98
View File
@@ -0,0 +1,98 @@
package s3
import (
"context"
"io"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
"high-loud-apps-labs/internal/domain"
)
type Config struct {
Endpoint string
Bucket string
AccessKey string
SecretKey string
UseSSL bool
Region string
}
type MinioStorage struct {
client *minio.Client
bucket string
}
func New(ctx context.Context, cfg Config) (*MinioStorage, error) {
client, err := minio.New(cfg.Endpoint, &minio.Options{
Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""),
Secure: cfg.UseSSL,
Region: cfg.Region,
})
if err != nil {
return nil, err
}
exists, err := client.BucketExists(ctx, cfg.Bucket)
if err != nil {
return nil, mapError(err)
}
if !exists {
return nil, &domain.UnavailableError{Reason: "s3 bucket отсутствует"}
}
return &MinioStorage{client: client, bucket: cfg.Bucket}, nil
}
func (s *MinioStorage) Ping(ctx context.Context) error {
_, err := s.client.BucketExists(ctx, s.bucket)
return mapError(err)
}
func (s *MinioStorage) 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,
})
return mapError(err)
}
func (s *MinioStorage) Get(ctx context.Context, key string) (io.ReadCloser, int64, string, error) {
obj, err := s.client.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{})
if err != nil {
return nil, 0, "", mapError(err)
}
stat, err := obj.Stat()
if err != nil {
_ = obj.Close()
return nil, 0, "", mapError(err)
}
return obj, stat.Size, stat.ContentType, nil
}
func (s *MinioStorage) Delete(ctx context.Context, key string) error {
err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{})
return mapError(err)
}
func (s *MinioStorage) List(ctx context.Context, prefix string) ([]domain.ObjectInfo, error) {
out := make([]domain.ObjectInfo, 0)
for obj := range s.client.ListObjects(ctx, s.bucket, minio.ListObjectsOptions{
Prefix: prefix,
Recursive: true,
}) {
if obj.Err != nil {
return nil, mapError(obj.Err)
}
out = append(out, domain.ObjectInfo{
Key: obj.Key,
LastModified: obj.LastModified,
Size: obj.Size,
})
}
return out, nil
}
var _ domain.ObjectStorage = (*MinioStorage)(nil)
+42
View File
@@ -0,0 +1,42 @@
package s3
import (
"context"
"errors"
"github.com/minio/minio-go/v7"
"high-loud-apps-labs/internal/domain"
)
type coded interface {
Code() domain.ErrorCode
}
func mapError(err error) error {
if err == nil {
return nil
}
var c coded
if errors.As(err, &c) {
return err
}
var resp minio.ErrorResponse
if errors.As(err, &resp) {
switch resp.Code {
case "NoSuchKey", "NotFound":
return &domain.NotFoundError{Entity: "object"}
case "NoSuchBucket":
return &domain.UnavailableError{Reason: "s3 bucket отсутствует"}
case "AccessDenied", "InvalidAccessKeyId", "SignatureDoesNotMatch":
return &domain.UnavailableError{Reason: "s3 доступ запрещён"}
}
}
if errors.Is(err, context.DeadlineExceeded) {
return &domain.UnavailableError{Reason: "превышено время ожидания s3"}
}
if errors.Is(err, context.Canceled) {
return &domain.UnavailableError{Reason: "запрос отменён"}
}
return &domain.UnavailableError{Reason: err.Error()}
}
+179
View File
@@ -0,0 +1,179 @@
package worker
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"log"
"math/rand"
"time"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/imaging"
)
type Pipeline struct {
jobs domain.AttachmentJobRepository
store domain.ObjectStorage
variants domain.AttachmentVariantRepository
failedJobs domain.FailedJobRepository
outbox domain.OutboxRepository
lease time.Duration
maxRetries int
}
func NewPipeline(
jobs domain.AttachmentJobRepository,
store domain.ObjectStorage,
variants domain.AttachmentVariantRepository,
failedJobs domain.FailedJobRepository,
outbox domain.OutboxRepository,
) *Pipeline {
return &Pipeline{
jobs: jobs,
store: store,
variants: variants,
failedJobs: failedJobs,
outbox: outbox,
lease: 5 * time.Minute,
maxRetries: 5,
}
}
func (p *Pipeline) Process(ctx context.Context, attachmentID string, pipelineVersion int) error {
log.Printf("worker: начало обработки %s (версия пайплайна %d)", attachmentID, pipelineVersion)
jobCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
// 1. Забираем задачу с проверкой версии
a, err := p.jobs.ClaimForProcessing(jobCtx, attachmentID, pipelineVersion, p.lease)
if err != nil {
return fmt.Errorf("захват задачи: %w", err)
}
if a == nil {
log.Printf("worker: задача %s уже взята, выполнена или версия устарела", attachmentID)
return nil // no-op
}
// 2. Скачиваем оригинал из staging
rc, _, _, err := p.store.Get(jobCtx, a.StagingKey)
if err != nil {
return p.handleFailure(a, fmt.Errorf("скачивание staging: %w", err), false)
}
defer rc.Close()
buf, err := io.ReadAll(rc)
if err != nil {
return p.handleFailure(a, fmt.Errorf("чтение staging: %w", err), false)
}
// 3. Генерируем все варианты (Thumbnail, Crop, Optimized)
log.Printf("worker: генерация вариантов для %s", a.ID)
thumbMeta, thumbData, err := imaging.Thumbnail(a.ID, buf)
if err != nil {
return p.handleFailure(a, fmt.Errorf("генерация thumbnail: %w", err), true)
}
cropMeta, cropData, err := imaging.Crop(a.ID, buf)
if err != nil {
return p.handleFailure(a, fmt.Errorf("генерация crop: %w", err), true)
}
webpMeta, webpData, err := imaging.Optimized(a.ID, buf)
if err != nil {
return p.handleFailure(a, fmt.Errorf("генерация webp: %w", err), true)
}
// 4. Сохраняем оригинал в финальный prefix (chats/...)
if err := p.store.Put(jobCtx, a.ObjectKey, bytes.NewReader(buf), int64(len(buf)), a.ContentType); err != nil {
return p.handleFailure(a, fmt.Errorf("загрузка оригинала: %w", err), false)
}
// 5. Загружаем все сгенерированные варианты в S3
variants := []domain.AttachmentVariant{*thumbMeta, *cropMeta, *webpMeta}
for i := range variants {
v := &variants[i]
key := fmt.Sprintf("%s/%s", a.ObjectKey, v.Name)
var data []byte
switch v.Name {
case domain.VariantThumbnail:
data = thumbData
case domain.VariantCrop:
data = cropData
case domain.VariantOptimized:
data = webpData
}
if err := p.store.Put(jobCtx, key, bytes.NewReader(data), v.SizeBytes, v.ContentType); err != nil {
return p.handleFailure(a, fmt.Errorf("загрузка варианта %s: %w", v.Name, err), false)
}
v.ObjectKey = key
}
// 6. Фиксируем результат в БД (переводим в ready)
ok, err := p.jobs.CompleteJob(jobCtx, a.ID, a.PipelineVersion, variants)
if err != nil {
return p.handleFailure(a, fmt.Errorf("фиксация в БД: %w", err), false)
}
if !ok {
log.Printf("worker: версия устарела или статус изменился, пропускаем %s", a.ID)
return nil
}
log.Printf("worker: успешно завершено %s", a.ID)
return nil
}
func (p *Pipeline) handleFailure(a *domain.Attachment, err error, isPermanent bool) error {
// Если исчерпаны попытки или ошибка постоянная (например, битый файл)
if isPermanent || a.Attempts >= p.maxRetries {
reason := domain.JobErrorInternal
if a.Attempts >= p.maxRetries {
reason = domain.JobErrorRetryExhausted
} else if isPermanent {
reason = domain.JobErrorDecodeFailed
}
log.Printf("worker: финальная ошибка для %s (попытка %d): %v", a.ID, a.Attempts, err)
// Используем context.Background(), чтобы запись в БД прошла даже при истекшем jobCtx
_ = p.jobs.FailJob(context.Background(), a.ID, reason)
_ = p.failedJobs.Record(context.Background(), &domain.FailedJob{
AttachmentID: a.ID,
ReasonCode: reason,
Attempts: a.Attempts,
})
return nil
}
// Временная ошибка - делаем Retry с backoff
log.Printf("worker: временная ошибка для %s, попытка %d: %v", a.ID, a.Attempts, err)
// Экспоненциальный backoff: 2^attempts секунд + случайный jitter (0-1000 мс)
backoff := time.Duration(1<<uint(a.Attempts)) * time.Second
jitter := time.Duration(rand.Intn(1000)) * time.Millisecond
nextAt := time.Now().UTC().Add(backoff + jitter)
_ = p.jobs.ScheduleRetry(context.Background(), a.ID, nextAt, "")
// Кладем в Outbox отложенное сообщение
payload, _ := json.Marshal(domain.JobMessage{
AttachmentID: a.ID,
PipelineVersion: a.PipelineVersion,
Attempt: a.Attempts + 1,
})
_ = p.outbox.EnqueueDirect(context.Background(), &domain.OutboxEntry{
AggregateType: domain.OutboxAggregateAttachment,
AggregateID: a.ID,
EventType: domain.OutboxEventProcess,
Payload: payload,
CreatedAt: nextAt,
})
return nil
}
+67
View File
@@ -0,0 +1,67 @@
-- +goose Up
-- +goose StatementBegin
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT users_username_format
CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_not_blank
CHECK (display_name !~ '^[[:space:]]*$'),
CONSTRAINT users_display_name_len
CHECK (char_length(display_name) <= 100),
CONSTRAINT users_password_hash_not_blank
CHECK (length(password_hash) > 0)
);
CREATE UNIQUE INDEX users_username_uniq ON users (username);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT chats_title_not_blank CHECK (title !~ '^[[:space:]]*$'),
CONSTRAINT chats_title_len CHECK (char_length(title) <= 100)
);
CREATE INDEX chats_created_id_idx ON chats (created_at, id);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
joined_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_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) ON DELETE RESTRICT,
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT messages_text_not_blank CHECK (text !~ '^[[:space:]]*$'),
CONSTRAINT messages_text_len CHECK (char_length(text) <= 4000)
);
CREATE INDEX messages_chat_created_id_idx
ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash BYTEA 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(),
CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32)
);
CREATE INDEX sessions_user_idx ON sessions (user_id);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
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;
-- +goose StatementEnd
+35
View File
@@ -0,0 +1,35 @@
-- +goose Up
-- +goose StatementBegin
CREATE TABLE idempotency_keys (
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
method TEXT NOT NULL,
path TEXT NOT NULL,
key TEXT NOT NULL,
request_hash BYTEA NOT NULL,
response_status INT NOT NULL,
response_body BYTEA NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
expires_at TIMESTAMPTZ NOT NULL,
CONSTRAINT idempotency_keys_pkey
PRIMARY KEY (user_id, method, path, key),
CONSTRAINT idempotency_keys_key_len
CHECK (char_length(key) BETWEEN 1 AND 128),
CONSTRAINT idempotency_keys_method_len
CHECK (char_length(method) BETWEEN 1 AND 16),
CONSTRAINT idempotency_keys_path_len
CHECK (char_length(path) BETWEEN 1 AND 2048),
CONSTRAINT idempotency_keys_hash_len
CHECK (octet_length(request_hash) = 32),
CONSTRAINT idempotency_keys_status_range
CHECK (response_status BETWEEN 100 AND 599)
);
CREATE INDEX idempotency_keys_expires_idx
ON idempotency_keys (expires_at);
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP TABLE IF EXISTS idempotency_keys;
-- +goose StatementEnd
+73
View File
@@ -0,0 +1,73 @@
-- +goose Up
-- +goose StatementBegin
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) ON DELETE RESTRICT,
filename TEXT NOT NULL,
content_type TEXT NOT NULL,
size_bytes BIGINT NOT NULL,
sha256 BYTEA NOT NULL,
object_key TEXT NOT NULL,
status TEXT NOT NULL,
error_code TEXT,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT attachments_filename_len
CHECK (char_length(filename) BETWEEN 1 AND 255),
CONSTRAINT attachments_filename_no_slash
CHECK (filename !~ '[/\\]'),
CONSTRAINT attachments_filename_no_ctrl
CHECK (filename !~ '[[:cntrl:]]'),
CONSTRAINT attachments_content_type_chk
CHECK (content_type IN ('image/png', 'image/jpeg')),
CONSTRAINT attachments_size_chk
CHECK (size_bytes > 0 AND size_bytes <= 10485760),
CONSTRAINT attachments_sha256_len
CHECK (octet_length(sha256) = 32),
CONSTRAINT attachments_object_key_len
CHECK (char_length(object_key) BETWEEN 1 AND 1024),
CONSTRAINT attachments_status_chk
CHECK (status IN ('ready', 'pending', 'failed')),
CONSTRAINT attachments_error_code_consistency
CHECK (
(status IN ('ready', 'pending') AND error_code IS NULL) OR
(status = 'failed' AND error_code IS NOT NULL)
)
);
CREATE UNIQUE INDEX attachments_object_key_uniq
ON attachments (object_key);
CREATE INDEX attachments_chat_idx
ON attachments (chat_id, created_at, id);
CREATE INDEX attachments_pending_idx
ON attachments (created_at)
WHERE status = 'pending';
CREATE TABLE message_attachments (
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE RESTRICT,
position SMALLINT NOT NULL,
CONSTRAINT message_attachments_pkey
PRIMARY KEY (message_id, attachment_id),
CONSTRAINT message_attachments_position_range
CHECK (position >= 0 AND position < 10),
CONSTRAINT message_attachments_position_uniq
UNIQUE (message_id, position)
);
CREATE INDEX message_attachments_attachment_idx
ON message_attachments (attachment_id);
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP TABLE IF EXISTS message_attachments;
DROP TABLE IF EXISTS attachments;
-- +goose StatementEnd
@@ -0,0 +1,13 @@
-- +goose Up
-- +goose StatementBegin
ALTER TABLE messages DROP CONSTRAINT IF EXISTS messages_text_not_blank;
ALTER TABLE messages ADD CONSTRAINT messages_text_not_blank
CHECK (text !~ '^[[:space:]]+$');
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
ALTER TABLE messages DROP CONSTRAINT IF EXISTS messages_text_not_blank;
ALTER TABLE messages ADD CONSTRAINT messages_text_not_blank
CHECK (text !~ '^[[:space:]]*$');
-- +goose StatementEnd
+77
View File
@@ -0,0 +1,77 @@
-- +goose Up
-- +goose StatementBegin
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_status_chk;
ALTER TABLE attachments ADD CONSTRAINT attachments_status_chk
CHECK (status IN ('pending', 'queued', 'processing', 'ready', 'failed'));
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_error_code_consistency;
ALTER TABLE attachments ADD CONSTRAINT attachments_error_code_consistency
CHECK (
(status IN ('pending', 'queued', 'processing', 'ready') AND error_code IS NULL) OR
(status = 'failed' AND error_code IS NOT NULL)
);
ALTER TABLE attachments ADD COLUMN attempts INT NOT NULL DEFAULT 0;
ALTER TABLE attachments ADD CONSTRAINT attachments_attempts_nonneg
CHECK (attempts >= 0);
ALTER TABLE attachments ADD COLUMN next_attempt_at TIMESTAMPTZ;
ALTER TABLE attachments ADD COLUMN locked_until TIMESTAMPTZ;
ALTER TABLE attachments ADD COLUMN pipeline_version INT NOT NULL DEFAULT 1;
ALTER TABLE attachments ADD CONSTRAINT attachments_pipeline_version_pos
CHECK (pipeline_version >= 1);
ALTER TABLE attachments ADD COLUMN staging_key TEXT;
ALTER TABLE attachments ADD CONSTRAINT attachments_staging_key_len
CHECK (staging_key IS NULL OR char_length(staging_key) BETWEEN 1 AND 1024);
DROP INDEX IF EXISTS attachments_pending_idx;
CREATE INDEX attachments_active_idx
ON attachments (status, next_attempt_at)
WHERE status IN ('queued', 'processing');
CREATE INDEX attachments_locked_idx
ON attachments (locked_until)
WHERE status = 'processing';
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP INDEX IF EXISTS attachments_locked_idx;
DROP INDEX IF EXISTS attachments_active_idx;
CREATE INDEX attachments_pending_idx
ON attachments (created_at)
WHERE status = 'pending';
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_staging_key_len;
ALTER TABLE attachments DROP COLUMN IF EXISTS staging_key;
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_pipeline_version_pos;
ALTER TABLE attachments DROP COLUMN IF EXISTS pipeline_version;
ALTER TABLE attachments DROP COLUMN IF EXISTS locked_until;
ALTER TABLE attachments DROP COLUMN IF EXISTS next_attempt_at;
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_attempts_nonneg;
ALTER TABLE attachments DROP COLUMN IF EXISTS attempts;
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_error_code_consistency;
ALTER TABLE attachments ADD CONSTRAINT attachments_error_code_consistency
CHECK (
(status IN ('ready', 'pending') AND error_code IS NULL) OR
(status = 'failed' AND error_code IS NOT NULL)
);
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_status_chk;
ALTER TABLE attachments ADD CONSTRAINT attachments_status_chk
CHECK (status IN ('ready', 'pending', 'failed'));
-- +goose StatementEnd
+32
View File
@@ -0,0 +1,32 @@
-- +goose Up
-- +goose StatementBegin
CREATE TABLE outbox (
id UUID PRIMARY KEY,
aggregate_type TEXT NOT NULL,
aggregate_id UUID NOT NULL,
event_type TEXT NOT NULL,
payload JSONB NOT NULL,
attempts INT NOT NULL DEFAULT 0,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
published_at TIMESTAMPTZ,
CONSTRAINT outbox_aggregate_type_len
CHECK (char_length(aggregate_type) BETWEEN 1 AND 64),
CONSTRAINT outbox_event_type_len
CHECK (char_length(event_type) BETWEEN 1 AND 64),
CONSTRAINT outbox_attempts_nonneg
CHECK (attempts >= 0)
);
CREATE INDEX outbox_pending_idx
ON outbox (created_at)
WHERE published_at IS NULL;
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP TABLE IF EXISTS outbox;
-- +goose StatementEnd
+43
View File
@@ -0,0 +1,43 @@
-- +goose Up
-- +goose StatementBegin
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_status_chk;
ALTER TABLE attachments ADD CONSTRAINT attachments_status_chk
CHECK (status IN ('queued', 'processing', 'ready', 'failed'));
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_error_code_consistency;
ALTER TABLE attachments ADD CONSTRAINT attachments_error_code_consistency
CHECK (
(status IN ('queued', 'processing', 'ready') AND error_code IS NULL) OR
(status = 'failed' AND error_code IS NOT NULL)
);
DROP INDEX IF EXISTS attachments_pending_idx;
DROP INDEX IF EXISTS attachments_active_idx;
CREATE INDEX attachments_active_idx
ON attachments (created_at)
WHERE status IN ('queued', 'processing');
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP INDEX IF EXISTS attachments_active_idx;
CREATE INDEX attachments_pending_idx
ON attachments (created_at)
WHERE status = 'pending';
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_error_code_consistency;
ALTER TABLE attachments ADD CONSTRAINT attachments_error_code_consistency
CHECK (
(status IN ('ready', 'pending') AND error_code IS NULL) OR
(status = 'failed' AND error_code IS NOT NULL)
);
ALTER TABLE attachments DROP CONSTRAINT IF EXISTS attachments_status_chk;
ALTER TABLE attachments ADD CONSTRAINT attachments_status_chk
CHECK (status IN ('ready', 'pending', 'failed'));
-- +goose StatementEnd
+26
View File
@@ -0,0 +1,26 @@
-- +goose Up
-- +goose StatementBegin
CREATE TABLE attachment_variants (
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
name TEXT NOT NULL,
object_key TEXT NOT NULL,
content_type TEXT NOT NULL,
size_bytes BIGINT NOT NULL,
width INT NOT NULL,
height INT NOT NULL,
sha256 BYTEA NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT attachment_variants_pkey PRIMARY KEY (attachment_id, name),
CONSTRAINT attachment_variants_name_chk CHECK (name IN ('thumbnail', 'crop', 'optimized')),
CONSTRAINT attachment_variants_size_chk CHECK (size_bytes > 0),
CONSTRAINT attachment_variants_sha256_len CHECK (octet_length(sha256) = 32)
);
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP TABLE IF EXISTS attachment_variants;
-- +goose StatementEnd
+25
View File
@@ -0,0 +1,25 @@
-- +goose Up
-- +goose StatementBegin
CREATE TABLE failed_jobs (
id UUID PRIMARY KEY,
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
reason_code TEXT NOT NULL,
attempts INT NOT NULL,
last_error_at TIMESTAMPTZ NOT NULL DEFAULT now(),
resolved_at TIMESTAMPTZ,
resolution TEXT,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT failed_jobs_reason_len CHECK (char_length(reason_code) BETWEEN 1 AND 64),
CONSTRAINT failed_jobs_attempts_pos CHECK (attempts > 0)
);
CREATE INDEX failed_jobs_unresolved_idx ON failed_jobs (created_at) WHERE resolved_at IS NULL;
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP TABLE IF EXISTS failed_jobs;
-- +goose StatementEnd
+6
View File
@@ -0,0 +1,6 @@
package migrations
import "embed"
//go:embed *.sql
var FS embed.FS
+310
View File
@@ -0,0 +1,310 @@
name: golikovap-messenger-lab5
x-api-resources: &api-resources
limits:
cpus: "${API_CPUS:-0.5}"
memory: "${API_MEMORY:-256M}"
reservations:
cpus: "${API_CPU_RESERVATION:-0.1}"
memory: "${API_MEMORY_RESERVATION:-64M}"
services:
postgres:
image: postgres:16.4-alpine
restart: unless-stopped
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_DB: messenger
secrets:
- postgres_password
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
ports:
- "5432:5432"
deploy:
resources:
limits:
cpus: "${POSTGRES_CPUS:-1.0}"
memory: ${POSTGRES_MEMORY:-1G}
reservations:
cpus: "${POSTGRES_CPU_RESERVATION:-0.25}"
memory: ${POSTGRES_MEMORY_RESERVATION:-256M}
networks:
- internal
redis:
image: redis:7.4-alpine
restart: unless-stopped
command:
- redis-server
- --appendonly
- "yes"
- --appendfsync
- everysec
- --save
- "60 1000"
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
deploy:
resources:
limits:
cpus: "${REDIS_CPUS:-0.5}"
memory: ${REDIS_MEMORY:-256M}
networks:
- internal
rabbitmq:
image: rabbitmq:3.13-management-alpine
restart: unless-stopped
environment:
RABBITMQ_DEFAULT_USER: "messenger"
RABBITMQ_DEFAULT_PASS: "${RABBITMQ_PASSWORD}"
volumes:
- rabbitmq_data:/var/lib/rabbitmq
ports:
- "15672:15672"
- "5672:5672"
healthcheck:
test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
interval: 5s
timeout: 3s
retries: 10
deploy:
resources:
limits:
memory: 256M
networks:
- internal
minio:
image: pgsty/silo:RELEASE.2026-09-16T00-00-00Z
restart: unless-stopped
command: ["server", "/data"]
secrets:
- minio_root_user
- minio_root_password
environment:
MINIO_ROOT_USER_FILE: /run/secrets/minio_root_user
MINIO_ROOT_PASSWORD_FILE: /run/secrets/minio_root_password
MINIO_BROWSER: "off"
volumes:
- minio_data:/data
healthcheck:
test: ["CMD", "mc", "ready", "local"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
deploy:
resources:
limits:
cpus: "${MINIO_CPUS:-0.5}"
memory: ${MINIO_MEMORY:-512M}
networks:
- internal
mc-init:
image: pgsty/silo:RELEASE.2026-09-16T00-00-00Z
restart: "no"
depends_on:
minio:
condition: service_healthy
entrypoint: ["/bin/sh", "/init.sh"]
environment:
MINIO_ENDPOINT: "http://minio:9000"
MINIO_BUCKET: "${S3_BUCKET:-messenger-attachments}"
ROOT_USER_FILE: /run/secrets/minio_root_user
ROOT_PASSWORD_FILE: /run/secrets/minio_root_password
API_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id
API_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
volumes:
- ./infra/minio-init.sh:/init.sh:ro
secrets:
- minio_root_user
- minio_root_password
- s3_access_key_id
- s3_secret_access_key
networks:
- internal
migrate:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger-api:lab3
restart: "no"
command: ["/server", "migrate"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
networks:
- internal
api:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger-api:lab3
restart: unless-stopped
environment:
APP_HOST: "0.0.0.0"
APP_PORT: "8080"
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
SESSION_STORE: "redis"
SESSION_TTL_SECONDS: "${SESSION_TTL_SECONDS:-3600}"
IDEMPOTENCY_TTL_SECONDS: "${IDEMPOTENCY_TTL_SECONDS:-86400}"
SHUTDOWN_DRAIN_SECONDS: "${SHUTDOWN_DRAIN_SECONDS:-3}"
GIN_MODE: "release"
S3_ENDPOINT: "http://minio:9000"
S3_BUCKET: "${S3_BUCKET:-messenger-attachments}"
S3_REGION: "${S3_REGION:-us-east-1}"
S3_USE_SSL: "false"
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}"
RECONCILER_ENABLED: "${RECONCILER_ENABLED:-true}"
RECONCILER_INTERVAL_SECONDS: "${RECONCILER_INTERVAL_SECONDS:-300}"
RECONCILER_GRACE_SECONDS: "${RECONCILER_GRACE_SECONDS:-3600}"
RABBITMQ_URL: "amqp://messenger:${RABBITMQ_PASSWORD}@rabbitmq:5672/"
OUTBOX_INTERVAL_MS: "1000"
secrets:
- database_url
- cache_url
- s3_access_key_id
- s3_secret_access_key
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
rabbitmq:
condition: service_healthy
migrate:
condition: service_completed_successfully
minio:
condition: service_healthy
mc-init:
condition: service_completed_successfully
expose:
- "8080"
stop_grace_period: 15s
healthcheck:
test: ["CMD-SHELL", "wget -q -O - http://127.0.0.1:8080/health/ready >/dev/null || exit 1"]
interval: 5s
timeout: 3s
retries: 5
start_period: 10s
deploy:
replicas: ${API_REPLICAS:-2}
resources: *api-resources
networks:
- internal
worker:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger-api:lab3
command: ["/worker"]
restart: unless-stopped
environment:
DATABASE_URL_FILE: /run/secrets/database_url
S3_ENDPOINT: "http://minio:9000"
S3_BUCKET: "${S3_BUCKET:-messenger-attachments}"
S3_REGION: "${S3_REGION:-us-east-1}"
S3_USE_SSL: "false"
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
RABBITMQ_URL: "amqp://messenger:${RABBITMQ_PASSWORD}@rabbitmq:5672/"
secrets:
- database_url
- s3_access_key_id
- s3_secret_access_key
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
minio:
condition: service_healthy
mc-init:
condition: service_completed_successfully
rabbitmq:
condition: service_healthy
deploy:
replicas: 1
resources:
limits:
memory: 256M
networks:
- internal
lb:
image: nginx:1.27.4-alpine
restart: unless-stopped
ports:
- "${LB_PORT:-8080}:8080"
volumes:
- ./infra/nginx.conf:/etc/nginx/nginx.conf:ro
depends_on:
api:
condition: service_started
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
networks:
- internal
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
minio_root_user:
file: ./secrets/minio_root_user
minio_root_password:
file: ./secrets/minio_root_password
s3_access_key_id:
file: ./secrets/s3_access_key_id
s3_secret_access_key:
file: ./secrets/s3_secret_access_key
volumes:
postgres_data:
redis_data:
minio_data:
rabbitmq_data:
networks:
internal:
driver: bridge
+314
View File
@@ -0,0 +1,314 @@
api-2 | 2026/11/13 18:50:52 outbox: publisher запущен (interval=1s)
api-1 | 2026/11/13 18:50:52 outbox: publisher запущен (interval=1s)
api-1 | 2026/11/13 18:50:52 reconciler: запущен (interval=5m0s, grace=1h0m0s)
api-1 | 2026/11/13 18:50:52 Запускаем на 0.0.0.0:8080 (SESSION_STORE=redis, RECONCILER_ENABLED=true)
api-1 | 2026/11/13 18:50:52 reconciler: очистка завершена (восстановлено_задач=0, удалено_staging=3, удалено_сирот=0)
api-1 | [GIN] 2026/11/13 - 18:50:57 | 200 | 1.33ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:02 | 200 | 1.18ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:05 | 200 | 1.2ms | 172.20.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:06 | 201 | 499.08ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | [GIN] 2026/11/13 - 18:51:07 | 201 | 403.94ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | [GIN] 2026/11/13 - 18:51:07 | 200 | 1.32ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:08 | 201 | 212.15ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | [GIN] 2026/11/13 - 18:51:08 | 201 | 5.93ms | 172.20.0.1 | POST "/api/v1/chats/cd232c5a-e91a-4a17-b89a-80d57b1b4067/messages"
api-1 | [GIN] 2026/11/13 - 18:51:08 | 200 | 2.58ms | 172.20.0.1 | GET "/api/v1/attachments/f328767c-3436-4016-bdcd-c5fea4ecb85c"
api-2 | 2026/11/13 18:50:52 reconciler: запущен (interval=5m0s, grace=1h0m0s)
api-1 | [GIN] 2026/11/13 - 18:51:09 | 200 | 2.08ms | 172.20.0.1 | GET "/api/v1/attachments/f328767c-3436-4016-bdcd-c5fea4ecb85c"
api-1 | 2026/11/13 18:51:09 Получен сигнал завершения; readiness выключен, drain 3s
api-1 | 2026/11/13 18:51:09 reconciler: остановлен
api-2 | 2026/11/13 18:50:52 Запускаем на 0.0.0.0:8080 (SESSION_STORE=redis, RECONCILER_ENABLED=true)
api-2 | [GIN] 2026/11/13 - 18:50:57 | 200 | 1.74ms | 127.0.0.1 | GET "/health/ready"
api-1 | 2026/11/13 18:51:09 outbox: publisher остановлен
api-1 | 2026/11/13 18:51:12 Drain завершён, останавливаем HTTP-сервер...
api-2 | [GIN] 2026/11/13 - 18:51:02 | 200 | 1.12ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:05 | 200 | 29.757µs | 172.20.0.1 | GET "/health/live"
api-2 | [GIN] 2026/11/13 - 18:51:06 | 201 | 433.68ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:51:07 | 201 | 480.7ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:51:07 | 200 | 6.63ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:08 | 201 | 281.45ms | 172.20.0.1 | POST "/api/v1/users"
api-1 | 2026/11/13 18:51:12 Сервер остановлен
api-1 | 2026/11/13 18:51:12 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:51:13 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:51:13 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:51:14 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | [GIN] 2026/11/13 - 18:51:08 | 201 | 5.07ms | 172.20.0.1 | POST "/api/v1/chats"
api-2 | [GIN] 2026/11/13 - 18:51:08 | 202 | 8.53ms | 172.20.0.1 | POST "/api/v1/chats/cd232c5a-e91a-4a17-b89a-80d57b1b4067/attachments?filename=sample.png"
api-2 | [GIN] 2026/11/13 - 18:51:08 | 200 | 2.75ms | 172.20.0.1 | GET "/api/v1/attachments/f328767c-3436-4016-bdcd-c5fea4ecb85c"
api-2 | 2026/11/13 18:51:08 outbox: успешно опубликовано 1 сообщений
api-1 | 2026/11/13 18:51:15 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:51:09 Получен сигнал завершения; readiness выключен, drain 3s
api-2 | 2026/11/13 18:51:09 reconciler: остановлен
api-1 | 2026/11/13 18:51:16 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:51:20 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:51:09 outbox: publisher остановлен
api-2 | 2026/11/13 18:51:12 Drain завершён, останавливаем HTTP-сервер...
api-1 | 2026/11/13 18:51:27 outbox: publisher запущен (interval=1s)
api-2 | 2026/11/13 18:51:12 Сервер остановлен
api-2 | 2026/11/13 18:51:12 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:51:13 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:51:13 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:51:14 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:51:27 reconciler: запущен (interval=5m0s, grace=1h0m0s)
api-1 | 2026/11/13 18:51:27 Запускаем на 0.0.0.0:8080 (SESSION_STORE=redis, RECONCILER_ENABLED=true)
api-1 | [GIN] 2026/11/13 - 18:51:30 | 200 | 1.39ms | 172.20.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:30 | 200 | 6.73ms | 172.20.0.1 | GET "/api/v1/chats/cd232c5a-e91a-4a17-b89a-80d57b1b4067/messages?limit=100"
api-2 | 2026/11/13 18:51:15 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:51:16 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:51:20 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | [GIN] 2026/11/13 - 18:51:32 | 200 | 2.2ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:37 | 200 | 1.25ms | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:51:27 outbox: publisher запущен (interval=1s)
api-2 | 2026/11/13 18:51:27 reconciler: запущен (interval=5m0s, grace=1h0m0s)
api-1 | [GIN] 2026/11/13 - 18:51:42 | 200 | 977.159µs | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:47 | 200 | 1.13ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:52 | 200 | 1.52ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:51:57 | 200 | 1.29ms | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:51:27 Запускаем на 0.0.0.0:8080 (SESSION_STORE=redis, RECONCILER_ENABLED=true)
api-1 | [GIN] 2026/11/13 - 18:52:02 | 200 | 1.37ms | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:51:27 reconciler: очистка завершена (восстановлено_задач=0, удалено_staging=2, удалено_сирот=0)
api-1 | [GIN] 2026/11/13 - 18:52:07 | 200 | 1.42ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:12 | 200 | 1.25ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:17 | 200 | 938.321µs | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:22 | 200 | 1.4ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:30 | 200 | 2.15ms | 172.20.0.1 | GET "/api/v1/users/me"
api-2 | [GIN] 2026/11/13 - 18:51:30 | 503 | 2.28ms | 172.20.0.1 | GET "/api/v1/attachments/f328767c-3436-4016-bdcd-c5fea4ecb85c"
api-1 | [GIN] 2026/11/13 - 18:52:27 | 200 | 1.15ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:33 | 200 | 1.47ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:38 | 200 | 1.21ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:43 | 200 | 1.73ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:32 | 200 | 1.2ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:37 | 200 | 1.25ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:48 | 200 | 1.72ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:53 | 200 | 1.54ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:52:58 | 200 | 1.27ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:42 | 200 | 1.37ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:47 | 200 | 1.18ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:52 | 200 | 1.57ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:51:57 | 200 | 1.02ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:03 | 200 | 1.09ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:08 | 200 | 1.25ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:14 | 200 | 1.57ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:19 | 200 | 1.52ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:02 | 200 | 1.41ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:07 | 200 | 1.45ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:24 | 200 | 1.59ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:29 | 200 | 1.61ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:12 | 200 | 1.31ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:17 | 200 | 1.18ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:34 | 200 | 1.18ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:39 | 200 | 1.21ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:22 | 200 | 1.25ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:27 | 200 | 1.15ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:44 | 200 | 1.54ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:49 | 200 | 1.52ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:33 | 200 | 2.27ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:38 | 200 | 1.09ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:43 | 200 | 1.53ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:48 | 200 | 1.32ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:53 | 200 | 1.32ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:52:58 | 200 | 933.949µs | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:53:03 | 200 | 1.12ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:53:08 | 200 | 1.35ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:53:14 | 200 | 1.42ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:54 | 200 | 1.14ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:57 | 200 | 38.724µs | 172.20.0.1 | GET "/health/live"
api-1 | [GIN] 2026/11/13 - 18:53:57 | 201 | 345.16ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:53:19 | 200 | 1.61ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:53:24 | 200 | 999.43µs | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:53:29 | 200 | 2.7ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:53:34 | 200 | 1.39ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:58 | 201 | 428.24ms | 172.20.0.1 | POST "/api/v1/users"
api-1 | [GIN] 2026/11/13 - 18:53:59 | 201 | 220.38ms | 172.20.0.1 | POST "/api/v1/users"
api-1 | [GIN] 2026/11/13 - 18:53:59 | 201 | 4.54ms | 172.20.0.1 | POST "/api/v1/chats"
api-1 | [GIN] 2026/11/13 - 18:53:59 | 202 | 8.73ms | 172.20.0.1 | POST "/api/v1/chats/7f8e2c9a-bd1a-48b3-8f23-c13151922baf/attachments?filename=sample.png"
api-2 | [GIN] 2026/11/13 - 18:53:39 | 200 | 1.19ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:59 | 200 | 1.28ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:53:59 | 200 | 2.77ms | 172.20.0.1 | GET "/api/v1/attachments/3e8c4363-1eb9-46d1-9b44-613f5f946446"
api-1 | 2026/11/13 18:54:00 Получен сигнал завершения; readiness выключен, drain 3s
api-2 | [GIN] 2026/11/13 - 18:53:44 | 200 | 1.16ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:53:49 | 200 | 1.31ms | 127.0.0.1 | GET "/health/ready"
api-1 | 2026/11/13 18:54:00 reconciler: остановлен
api-1 | 2026/11/13 18:54:00 outbox: publisher остановлен
api-2 | [GIN] 2026/11/13 - 18:53:54 | 200 | 807.794µs | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:53:57 | 200 | 1.03ms | 172.20.0.1 | GET "/health/ready"
api-1 | 2026/11/13 18:54:03 Drain завершён, останавливаем HTTP-сервер...
api-1 | 2026/11/13 18:54:03 Сервер остановлен
api-2 | [GIN] 2026/11/13 - 18:53:58 | 201 | 442.76ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-2 | [GIN] 2026/11/13 - 18:53:59 | 201 | 365.57ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | 2026/11/13 18:54:03 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:04 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:04 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:05 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:06 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:08 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:11 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | [GIN] 2026/11/13 - 18:53:59 | 201 | 176.63ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-2 | [GIN] 2026/11/13 - 18:53:59 | 201 | 6.06ms | 172.20.0.1 | POST "/api/v1/chats/7f8e2c9a-bd1a-48b3-8f23-c13151922baf/messages"
api-1 | 2026/11/13 18:54:18 outbox: publisher запущен (interval=1s)
api-1 | 2026/11/13 18:54:18 reconciler: запущен (interval=5m0s, grace=1h0m0s)
api-2 | [GIN] 2026/11/13 - 18:53:59 | 200 | 3.1ms | 172.20.0.1 | GET "/api/v1/attachments/3e8c4363-1eb9-46d1-9b44-613f5f946446"
api-2 | [GIN] 2026/11/13 - 18:53:59 | 200 | 1.18ms | 127.0.0.1 | GET "/health/ready"
api-1 | 2026/11/13 18:54:18 Запускаем на 0.0.0.0:8080 (SESSION_STORE=redis, RECONCILER_ENABLED=true)
api-1 | [GIN] 2026/11/13 - 18:54:22 | 200 | 1.09ms | 172.20.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:54:00 outbox: успешно опубликовано 1 сообщений
api-2 | [GIN] 2026/11/13 - 18:54:00 | 200 | 1.98ms | 172.20.0.1 | GET "/api/v1/attachments/3e8c4363-1eb9-46d1-9b44-613f5f946446"
api-1 | [GIN] 2026/11/13 - 18:54:22 | 201 | 405.68ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | [GIN] 2026/11/13 - 18:54:23 | 200 | 1.28ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:54:23 | 201 | 425.5ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-2 | 2026/11/13 18:54:00 Получен сигнал завершения; readiness выключен, drain 3s
api-2 | 2026/11/13 18:54:00 outbox: publisher остановлен
api-1 | [GIN] 2026/11/13 - 18:54:24 | 201 | 225.03ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-2 | 2026/11/13 18:54:00 reconciler: остановлен
api-2 | 2026/11/13 18:54:03 Drain завершён, останавливаем HTTP-сервер...
api-1 | [GIN] 2026/11/13 - 18:54:24 | 201 | 6.66ms | 172.20.0.1 | POST "/api/v1/chats/058f30a2-7854-4909-89f2-18a7956b52ee/messages"
api-1 | [GIN] 2026/11/13 - 18:54:24 | 200 | 3.9ms | 172.20.0.1 | GET "/api/v1/attachments/5c05619e-bce6-4ccb-b180-83b80f90dee3"
api-2 | 2026/11/13 18:54:03 Сервер остановлен
api-2 | 2026/11/13 18:54:03 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | [GIN] 2026/11/13 - 18:54:25 | 200 | 1.72ms | 172.20.0.1 | GET "/api/v1/attachments/5c05619e-bce6-4ccb-b180-83b80f90dee3"
api-1 | 2026/11/13 18:54:25 Получен сигнал завершения; readiness выключен, drain 3s
api-2 | 2026/11/13 18:54:04 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:04 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:25 reconciler: остановлен
api-1 | 2026/11/13 18:54:25 outbox: publisher остановлен
api-2 | 2026/11/13 18:54:05 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:06 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:08 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:11 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | [GIN] 2026/11/13 - 18:54:28 | 503 | 124.888µs | 127.0.0.1 | GET "/health/ready"
api-1 | 2026/11/13 18:54:28 Drain завершён, останавливаем HTTP-сервер...
api-2 | 2026/11/13 18:54:18 outbox: publisher запущен (interval=1s)
api-2 | 2026/11/13 18:54:18 reconciler: запущен (interval=5m0s, grace=1h0m0s)
api-1 | 2026/11/13 18:54:28 Сервер остановлен
api-1 | 2026/11/13 18:54:29 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:29 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:29 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:18 Запускаем на 0.0.0.0:8080 (SESSION_STORE=redis, RECONCILER_ENABLED=true)
api-2 | 2026/11/13 18:54:18 reconciler: очистка завершена (восстановлено_задач=0, удалено_staging=1, удалено_сирот=0)
api-2 | [GIN] 2026/11/13 - 18:54:22 | 200 | 69.894µs | 172.20.0.1 | GET "/health/live"
api-2 | [GIN] 2026/11/13 - 18:54:22 | 201 | 398.03ms | 172.20.0.1 | POST "/api/v1/users"
api-1 | 2026/11/13 18:54:30 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:31 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:33 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | 2026/11/13 18:54:36 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | [GIN] 2026/11/13 - 18:54:23 | 200 | 9.18ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:54:23 | 201 | 470.47ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:54:24 | 201 | 261.07ms | 172.20.0.1 | POST "/api/v1/users"
api-1 | 2026/11/13 18:54:43 outbox: publisher запущен (interval=1s)
api-1 | 2026/11/13 18:54:43 reconciler: запущен (interval=5m0s, grace=1h0m0s)
api-2 | [GIN] 2026/11/13 - 18:54:24 | 201 | 4.53ms | 172.20.0.1 | POST "/api/v1/chats"
api-2 | [GIN] 2026/11/13 - 18:54:24 | 202 | 9.35ms | 172.20.0.1 | POST "/api/v1/chats/058f30a2-7854-4909-89f2-18a7956b52ee/attachments?filename=sample.png"
api-1 | 2026/11/13 18:54:43 Запускаем на 0.0.0.0:8080 (SESSION_STORE=redis, RECONCILER_ENABLED=true)
api-1 | 2026/11/13 18:54:43 reconciler: очистка завершена (восстановлено_задач=0, удалено_staging=1, удалено_сирот=0)
api-2 | [GIN] 2026/11/13 - 18:54:24 | 200 | 3.95ms | 172.20.0.1 | GET "/api/v1/attachments/5c05619e-bce6-4ccb-b180-83b80f90dee3"
api-2 | 2026/11/13 18:54:25 outbox: успешно опубликовано 1 сообщений
api-1 | [GIN] 2026/11/13 - 18:54:45 | 200 | 1.91ms | 172.20.0.1 | GET "/api/v1/users/me"
api-1 | [GIN] 2026/11/13 - 18:54:45 | 503 | 1.92ms | 172.20.0.1 | GET "/api/v1/attachments/5c05619e-bce6-4ccb-b180-83b80f90dee3"
api-2 | [GIN] 2026/11/13 - 18:54:25 | 200 | 2.19ms | 172.20.0.1 | GET "/api/v1/attachments/5c05619e-bce6-4ccb-b180-83b80f90dee3"
api-2 | 2026/11/13 18:54:25 Получен сигнал завершения; readiness выключен, drain 3s
api-1 | [GIN] 2026/11/13 - 18:54:48 | 200 | 1.89ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:54:53 | 200 | 1.22ms | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:54:25 reconciler: остановлен
api-2 | 2026/11/13 18:54:25 outbox: publisher остановлен
api-1 | [GIN] 2026/11/13 - 18:54:59 | 200 | 1.18ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:55:04 | 200 | 1.26ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:54:28 | 503 | 265.498µs | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:54:28 Drain завершён, останавливаем HTTP-сервер...
api-1 | [GIN] 2026/11/13 - 18:55:09 | 200 | 1.52ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:55:14 | 200 | 1.03ms | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:54:28 Сервер остановлен
api-2 | 2026/11/13 18:54:29 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | [GIN] 2026/11/13 - 18:55:19 | 200 | 1.14ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:55:24 | 200 | 1.26ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:55:29 | 200 | 1.3ms | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:54:29 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:30 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:30 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | [GIN] 2026/11/13 - 18:55:34 | 200 | 1.52ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:55:39 | 200 | 1.26ms | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:54:31 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:33 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-1 | [GIN] 2026/11/13 - 18:55:44 | 200 | 1.21ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:55:49 | 200 | 1.23ms | 127.0.0.1 | GET "/health/ready"
api-2 | 2026/11/13 18:54:36 rabbitmq: подключение к rabbitmq: dial tcp 172.20.0.3:5672: connect: connection refused
api-2 | 2026/11/13 18:54:43 outbox: publisher запущен (interval=1s)
api-1 | [GIN] 2026/11/13 - 18:55:54 | 200 | 1.16ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:00 | 200 | 1.23ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:03 | 200 | 1.48ms | 172.20.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:04 | 201 | 475.58ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-2 | 2026/11/13 18:54:43 reconciler: запущен (interval=5m0s, grace=1h0m0s)
api-2 | 2026/11/13 18:54:43 Запускаем на 0.0.0.0:8080 (SESSION_STORE=redis, RECONCILER_ENABLED=true)
api-2 | [GIN] 2026/11/13 - 18:54:45 | 200 | 1.22ms | 172.20.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:54:45 | 200 | 5.33ms | 172.20.0.1 | GET "/api/v1/chats/058f30a2-7854-4909-89f2-18a7956b52ee/messages?limit=100"
api-1 | [GIN] 2026/11/13 - 18:56:05 | 201 | 349.47ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | [GIN] 2026/11/13 - 18:56:05 | 200 | 6.69ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:05 | 201 | 360.85ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | [GIN] 2026/11/13 - 18:56:05 | 409 | 241.83ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:54:48 | 200 | 1.28ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:54:53 | 200 | 1.37ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:05 | 404 | 2.37ms | 172.20.0.1 | GET "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1"
api-1 | [GIN] 2026/11/13 - 18:56:05 | 200 | 1.69ms | 172.20.0.1 | GET "/api/v1/chats?limit=100"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 201 | 4.82ms | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 200 | 3.02ms | 172.20.0.1 | GET "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages?limit=1"
api-2 | [GIN] 2026/11/13 - 18:54:59 | 200 | 1.48ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:55:04 | 200 | 1.61ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 400 | 522.712µs | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 400 | 495.985µs | 172.20.0.1 | GET "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages?limit=0"
api-2 | [GIN] 2026/11/13 - 18:55:09 | 200 | 1.22ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:55:14 | 200 | 1.21ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 401 | 37.872µs | 172.20.0.1 | GET "/api/v1/users/me"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 200 | 950.545µs | 172.20.0.1 | GET "/api/v1/users/me"
api-2 | [GIN] 2026/11/13 - 18:55:19 | 200 | 1.29ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:55:24 | 200 | 1.14ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 409 | 2.27ms | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 202 | 9.19ms | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/attachments?filename=sample.png"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 200 | 2.98ms | 172.20.0.1 | GET "/api/v1/attachments/1b706a21-dfa3-4f64-89b9-2815da9bbcb7"
api-2 | [GIN] 2026/11/13 - 18:55:29 | 200 | 1.32ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:55:34 | 200 | 1.33ms | 127.0.0.1 | GET "/health/ready"
api-1 | 2026/11/13 18:56:06 outbox: успешно опубликовано 1 сообщений
api-1 | [GIN] 2026/11/13 - 18:56:06 | 200 | 5.25ms | 172.20.0.1 | GET "/api/v1/attachments/1b706a21-dfa3-4f64-89b9-2815da9bbcb7/content"
api-2 | [GIN] 2026/11/13 - 18:55:39 | 200 | 1.29ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:55:45 | 200 | 1.33ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 404 | 1.78ms | 172.20.0.1 | GET "/api/v1/attachments/1b706a21-dfa3-4f64-89b9-2815da9bbcb7/content"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 204 | 1.11ms | 172.20.0.1 | DELETE "/api/v1/auth/sessions/current"
api-2 | [GIN] 2026/11/13 - 18:55:50 | 200 | 1.25ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:55:55 | 200 | 1.13ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:06 | 401 | 271.021µs | 172.20.0.1 | DELETE "/api/v1/auth/sessions/current"
api-1 | [GIN] 2026/11/13 - 18:56:07 | 200 | 1.28ms | 172.20.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:56:00 | 200 | 1.62ms | 127.0.0.1 | GET "/health/ready"
api-1 | [GIN] 2026/11/13 - 18:56:07 | 201 | 239.96ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-2 | [GIN] 2026/11/13 - 18:56:03 | 200 | 33.363µs | 172.20.0.1 | GET "/health/live"
api-2 | [GIN] 2026/11/13 - 18:56:03 | 201 | 456.43ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:56:04 | 201 | 336.05ms | 172.20.0.1 | POST "/api/v1/users"
api-1 | [GIN] 2026/11/13 - 18:56:08 | 201 | 164.57ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | [GIN] 2026/11/13 - 18:56:08 | 201 | 160.65ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-1 | [GIN] 2026/11/13 - 18:56:08 | 202 | 6.65ms | 172.20.0.1 | POST "/api/v1/chats/e151aa0f-c644-444a-81ab-81a0ada46e37/attachments?filename=sample.png"
api-1 | [GIN] 2026/11/13 - 18:56:08 | 200 | 1.91ms | 172.20.0.1 | GET "/api/v1/attachments/1f9520fe-a094-4a7b-ae7c-700423ce068a"
api-1 | [GIN] 2026/11/13 - 18:56:10 | 200 | 1.17ms | 127.0.0.1 | GET "/health/ready"
api-1 | 2026/11/13 18:56:11 outbox: успешно опубликовано 1 сообщений
api-2 | [GIN] 2026/11/13 - 18:56:05 | 201 | 140.53ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:56:05 | 200 | 1.18ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:56:05 | 201 | 4.81ms | 172.20.0.1 | POST "/api/v1/chats"
api-2 | [GIN] 2026/11/13 - 18:56:05 | 401 | 120.747µs | 172.20.0.1 | GET "/api/v1/users/me"
api-2 | [GIN] 2026/11/13 - 18:56:05 | 200 | 534.087µs | 172.20.0.1 | GET "/api/v1/users/me"
api-2 | [GIN] 2026/11/13 - 18:56:05 | 200 | 1.4ms | 172.20.0.1 | GET "/api/v1/chats?limit=100"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 201 | 5.8ms | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 200 | 3.12ms | 172.20.0.1 | GET "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages?limit=1&cursor=bWVzc2FnZXM6NDliY2YzZDgtNDM5OC00ZjczLWIyYmYtODUwMjk1ZTMzOWIxfDIwMjYtMTEtMTNUMTg6NTY6MDUuOTk5NTk0WnxlNGE5MmMyMi1kYTBiLTRlMjMtODBjNS00NTQ5MTkzNTFlOGU"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 404 | 1.06ms | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 401 | 162.74ms | 172.20.0.1 | POST "/api/v1/auth/sessions"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 401 | 44.184µs | 172.20.0.1 | GET "/api/v1/users/me"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 201 | 2.59ms | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 400 | 514.328µs | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 201 | 5.15ms | 172.20.0.1 | POST "/api/v1/chats/49bcf3d8-4398-4f73-b2bf-850295e339b1/messages"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 200 | 3.3ms | 172.20.0.1 | GET "/api/v1/attachments/1b706a21-dfa3-4f64-89b9-2815da9bbcb7"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 404 | 2.02ms | 172.20.0.1 | GET "/api/v1/attachments/1b706a21-dfa3-4f64-89b9-2815da9bbcb7"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 200 | 3.62ms | 172.20.0.1 | GET "/api/v1/attachments/1b706a21-dfa3-4f64-89b9-2815da9bbcb7/content?variant=thumbnail"
api-2 | [GIN] 2026/11/13 - 18:56:06 | 401 | 309.977µs | 172.20.0.1 | GET "/api/v1/users/me"
api-2 | [GIN] 2026/11/13 - 18:56:07 | 200 | 16.861µs | 172.20.0.1 | GET "/health/live"
api-2 | [GIN] 2026/11/13 - 18:56:07 | 201 | 218.77ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:56:07 | 201 | 139.91ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:56:08 | 201 | 217.51ms | 172.20.0.1 | POST "/api/v1/users"
api-2 | [GIN] 2026/11/13 - 18:56:08 | 201 | 3ms | 172.20.0.1 | POST "/api/v1/chats"
api-2 | [GIN] 2026/11/13 - 18:56:08 | 200 | 1.41ms | 172.20.0.1 | GET "/api/v1/attachments/1f9520fe-a094-4a7b-ae7c-700423ce068a"
api-2 | 2026/11/13 18:56:08 outbox: успешно опубликовано 1 сообщений
api-2 | [GIN] 2026/11/13 - 18:56:10 | 200 | 1.19ms | 127.0.0.1 | GET "/health/ready"
api-2 | [GIN] 2026/11/13 - 18:56:10 | 202 | 7.76ms | 172.20.0.1 | POST "/api/v1/chats/e151aa0f-c644-444a-81ab-81a0ada46e37/attachments?filename=sample.png"
Binary file not shown.
+76
View File
@@ -0,0 +1,76 @@
worker-1 | 2026/11/13 18:50:52 worker: запущен и слушает очередь
worker-1 | 2026/11/13 18:50:52 worker: начало обработки 84fcd359-05ce-42b1-a6bb-6e9a9ead961f (версия пайплайна 1)
worker-1 | 2026/11/13 18:50:52 worker: генерация вариантов для 84fcd359-05ce-42b1-a6bb-6e9a9ead961f
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:50:52 worker: успешно завершено 84fcd359-05ce-42b1-a6bb-6e9a9ead961f
worker-1 | 2026/11/13 18:50:52 worker: начало обработки 31ab08f9-193f-4d5c-b8a0-ed01ddf16f08 (версия пайплайна 1)
worker-1 | 2026/11/13 18:50:52 worker: генерация вариантов для 31ab08f9-193f-4d5c-b8a0-ed01ddf16f08
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:50:52 worker: успешно завершено 31ab08f9-193f-4d5c-b8a0-ed01ddf16f08
worker-1 | 2026/11/13 18:50:52 worker: начало обработки ceb7a516-0e3b-4f47-a6a9-71bb199b5c91 (версия пайплайна 1)
worker-1 | 2026/11/13 18:50:52 worker: генерация вариантов для ceb7a516-0e3b-4f47-a6a9-71bb199b5c91
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:50:52 worker: успешно завершено ceb7a516-0e3b-4f47-a6a9-71bb199b5c91
worker-1 | 2026/11/13 18:50:52 worker: начало обработки 9c78ae63-7ca6-48b2-bb44-1754732da29c (версия пайплайна 1)
worker-1 | 2026/11/13 18:50:52 worker: генерация вариантов для 9c78ae63-7ca6-48b2-bb44-1754732da29c
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:50:52 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:50:52 worker: успешно завершено 9c78ae63-7ca6-48b2-bb44-1754732da29c
worker-1 | 2026/11/13 18:51:08 worker: начало обработки f328767c-3436-4016-bdcd-c5fea4ecb85c (версия пайплайна 1)
worker-1 | 2026/11/13 18:51:08 worker: генерация вариантов для f328767c-3436-4016-bdcd-c5fea4ecb85c
worker-1 | 2026/11/13 18:51:08 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:51:08 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:51:08 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:51:08 worker: успешно завершено f328767c-3436-4016-bdcd-c5fea4ecb85c
worker-1 | 2026/11/13 18:51:09 worker: получен сигнал завершения, останавливаемся...
worker-1 | 2026/11/13 18:51:13 БД: ping БД: failed to connect to `user=messenger database=messenger`: hostname resolving error: lookup postgres on 127.0.0.11:53: no such host
worker-1 | 2026/11/13 18:51:13 worker: ошибка соединения, перезапуск через 5 секунд: dial tcp 172.20.0.3:5672: connect: connection refused
worker-1 | 2026/11/13 18:51:18 worker: ошибка соединения, перезапуск через 5 секунд: dial tcp 172.20.0.3:5672: connect: connection refused
worker-1 | 2026/11/13 18:51:23 worker: запущен и слушает очередь
worker-1 | 2026/11/13 18:54:00 worker: начало обработки 3e8c4363-1eb9-46d1-9b44-613f5f946446 (версия пайплайна 1)
worker-1 | 2026/11/13 18:54:00 worker: генерация вариантов для 3e8c4363-1eb9-46d1-9b44-613f5f946446
worker-1 | 2026/11/13 18:54:00 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:54:00 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:54:00 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:54:00 worker: успешно завершено 3e8c4363-1eb9-46d1-9b44-613f5f946446
worker-1 | 2026/11/13 18:54:00 worker: получен сигнал завершения, останавливаемся...
worker-1 | 2026/11/13 18:54:04 БД: ping БД: failed to connect to `user=messenger database=messenger`: hostname resolving error: lookup postgres on 127.0.0.11:53: no such host
worker-1 | 2026/11/13 18:54:04 worker: ошибка соединения, перезапуск через 5 секунд: dial tcp 172.20.0.3:5672: connect: connection refused
worker-1 | 2026/11/13 18:54:09 worker: ошибка соединения, перезапуск через 5 секунд: dial tcp 172.20.0.3:5672: connect: connection refused
worker-1 | 2026/11/13 18:54:14 worker: запущен и слушает очередь
worker-1 | 2026/11/13 18:54:25 worker: начало обработки 5c05619e-bce6-4ccb-b180-83b80f90dee3 (версия пайплайна 1)
worker-1 | 2026/11/13 18:54:25 worker: генерация вариантов для 5c05619e-bce6-4ccb-b180-83b80f90dee3
worker-1 | 2026/11/13 18:54:25 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:54:25 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:54:25 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:54:25 worker: успешно завершено 5c05619e-bce6-4ccb-b180-83b80f90dee3
worker-1 | 2026/11/13 18:54:25 worker: получен сигнал завершения, останавливаемся...
worker-1 | 2026/11/13 18:54:29 БД: ping БД: failed to connect to `user=messenger database=messenger`: hostname resolving error: lookup postgres on 127.0.0.11:53: no such host
worker-1 | 2026/11/13 18:54:29 worker: ошибка соединения, перезапуск через 5 секунд: dial tcp 172.20.0.3:5672: connect: connection refused
worker-1 | 2026/11/13 18:54:34 worker: ошибка соединения, перезапуск через 5 секунд: dial tcp 172.20.0.3:5672: connect: connection refused
worker-1 | 2026/11/13 18:54:39 worker: запущен и слушает очередь
worker-1 | 2026/11/13 18:56:06 worker: начало обработки 1b706a21-dfa3-4f64-89b9-2815da9bbcb7 (версия пайплайна 1)
worker-1 | 2026/11/13 18:56:06 worker: генерация вариантов для 1b706a21-dfa3-4f64-89b9-2815da9bbcb7
worker-1 | 2026/11/13 18:56:06 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:56:06 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:56:06 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:56:06 worker: успешно завершено 1b706a21-dfa3-4f64-89b9-2815da9bbcb7
worker-1 | 2026/11/13 18:56:08 worker: начало обработки 1f9520fe-a094-4a7b-ae7c-700423ce068a (версия пайплайна 1)
worker-1 | 2026/11/13 18:56:08 worker: генерация вариантов для 1f9520fe-a094-4a7b-ae7c-700423ce068a
worker-1 | 2026/11/13 18:56:08 CompleteJob: успешно добавлен вариант thumbnail
worker-1 | 2026/11/13 18:56:08 CompleteJob: успешно добавлен вариант crop
worker-1 | 2026/11/13 18:56:08 CompleteJob: успешно добавлен вариант optimized
worker-1 | 2026/11/13 18:56:08 worker: успешно завершено 1f9520fe-a094-4a7b-ae7c-700423ce068a
worker-1 | 2026/11/13 18:56:08 worker: начало обработки 1f9520fe-a094-4a7b-ae7c-700423ce068a (версия пайплайна 1)
worker-1 | 2026/11/13 18:56:08 worker: задача 1f9520fe-a094-4a7b-ae7c-700423ce068a уже взята, выполнена или версия устарела
worker-1 | 2026/11/13 18:56:11 worker: начало обработки d3a3f248-7053-4368-a42a-63f2168288bb (версия пайплайна 1)
worker-1 | 2026/11/13 18:56:11 worker: задача d3a3f248-7053-4368-a42a-63f2168288bb уже взята, выполнена или версия устарела
worker-1 | 2026/11/13 18:56:11 worker: начало обработки d3a3f248-7053-4368-a42a-63f2168288bb (версия пайплайна 1)
worker-1 | 2026/11/13 18:56:11 worker: задача d3a3f248-7053-4368-a42a-63f2168288bb уже взята, выполнена или версия устарела
+48
View File
@@ -0,0 +1,48 @@
#!/bin/sh
set -eu
: "${MINIO_ENDPOINT:?MINIO_ENDPOINT не задан}"
: "${MINIO_BUCKET:?MINIO_BUCKET не задан}"
: "${ROOT_USER_FILE:?ROOT_USER_FILE не задан}"
: "${ROOT_PASSWORD_FILE:?ROOT_PASSWORD_FILE не задан}"
: "${API_ACCESS_KEY_ID_FILE:?API_ACCESS_KEY_ID_FILE не задан}"
: "${API_SECRET_ACCESS_KEY_FILE:?API_SECRET_ACCESS_KEY_FILE не задан}"
ROOT_USER="$(cat "$ROOT_USER_FILE")"
ROOT_PASS="$(cat "$ROOT_PASSWORD_FILE")"
API_ID="$(cat "$API_ACCESS_KEY_ID_FILE")"
API_SECRET="$(cat "$API_SECRET_ACCESS_KEY_FILE")"
mc alias set bootstrap "$MINIO_ENDPOINT" "$ROOT_USER" "$ROOT_PASS" --api S3v4 >/dev/null
mc mb --ignore-existing "bootstrap/$MINIO_BUCKET"
if ! mc admin user info bootstrap "$API_ID" >/dev/null 2>&1; then
mc admin user add bootstrap "$API_ID" "$API_SECRET"
fi
POLICY_FILE="/tmp/minio-policy.json"
trap 'rm -f "$POLICY_FILE"' EXIT
cat >"$POLICY_FILE" <<EOF
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
"Resource": ["arn:aws:s3:::${MINIO_BUCKET}/*"]
},
{
"Effect": "Allow",
"Action": ["s3:ListBucket", "s3:GetBucketLocation"],
"Resource": ["arn:aws:s3:::${MINIO_BUCKET}"]
}
]
}
EOF
mc admin policy create bootstrap messenger-api "$POLICY_FILE" 2>/dev/null || true
mc admin policy attach bootstrap messenger-api --user "$API_ID" 2>/dev/null || true
echo "minio bootstrap в норме: bucket=${MINIO_BUCKET} user=${API_ID}"
+48
View File
@@ -0,0 +1,48 @@
worker_processes auto;
events {
worker_connections 1024;
}
http {
access_log /dev/stdout;
error_log /dev/stderr warn;
client_max_body_size 12m;
resolver 127.0.0.11 valid=10s ipv6=off;
upstream backend {
zone backend 64k;
server api:8080 resolve max_fails=2 fail_timeout=5s;
keepalive 32;
keepalive_requests 1000;
keepalive_timeout 60s;
}
server {
listen 8080;
server_tokens off;
location / {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 2s;
proxy_send_timeout 30s;
proxy_read_timeout 30s;
proxy_next_upstream error timeout;
proxy_next_upstream_tries 2;
}
}
}
+42
View File
@@ -0,0 +1,42 @@
import sys
import time
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent / 'tests'))
from client import Client, arguments
def main():
args = arguments('Генерация упавшей задачи для failed_jobs')
c = Client(args.base_url, args.ca_file)
print("Создаем тестовых пользователей и чат...")
alice, bob, eve, chat = c.bootstrap()
print("Генерируем битый PNG (берем начало от настоящей картинки)...")
sample = Path("tests/fixtures/sample.png").read_bytes()
broken_png = sample[:100]
print("Загружаем битый файл через API...")
# Добавили schema='Attachment', чтобы клиент распарсил JSON
r = c.call(
'POST',
f"/api/v1/chats/{chat['id']}/attachments?filename=broken.png",
202,
actor=alice,
raw=broken_png,
headers={'Content-Type': 'image/png'},
schema='Attachment'
)
att_id = r['json']['id']
print(f"Файл принят! ID: {att_id}, статус: {r['json']['status']}")
print("Ждем 5 секунд, пока Worker попытается его обработать и упадет...")
time.sleep(5)
# Проверяем статус
att = c.call('GET', f'/api/v1/attachments/{att_id}', actor=alice, schema='Attachment')['json']
print(f"Итоговый статус: {att['status']}, ошибка: {att['error_code']}")
if __name__ == '__main__':
main()
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
echo "Убиваем воркер (SIGKILL) для симуляции падения..."
docker compose kill -s SIGKILL worker
echo "Воркер убит. Задача должна зависнуть в статусе 'processing', пока Reconciler не вернет её в очередь."
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
echo "Ставим MinIO (S3) на паузу на 15 секунд для симуляции временной ошибки..."
docker compose pause minio
sleep 15
echo "Возобновляем работу MinIO..."
docker compose unpause minio
+3
View File
@@ -0,0 +1,3 @@
@echo off
bash "%~dp0restart.sh"
exit /b %errorlevel%
+25
View File
@@ -0,0 +1,25 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# Перезапускаем state stores, API и Worker
docker compose restart postgres redis minio rabbitmq api worker
i=0
while [ "$i" -lt 90 ]; do
# Проверяем статус всех нужных сервисов
unhealthy=$(docker compose ps --format '{{.Service}} {{.Health}}' \
| awk '$1 ~ /^(postgres|redis|minio|rabbitmq|api-[0-9]+)$/ && $2 != "healthy" {print $1}')
if [ -z "$unhealthy" ]; then
# Даем базе и пулам соединений 5 секунд стабилизироваться
sleep 5
exit 0
fi
i=$((i+1))
sleep 1
done
echo "основные сервисы не прошли проверку здоровья за 90 секунд: $unhealthy" >&2
docker compose ps >&2
exit 1
+2
View File
@@ -0,0 +1,2 @@
@echo off
bash "%~dp0stop-one.sh"

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