Реализовать lab4: вложения S3/MinIO, уровень 4 и трек 2 reconciler.
Метаданные в PostgreSQL, байты в приватном bucket; sync upload 201 ready; компенсация orphan и cmd/reconcile с dry-run/apply и grace period.
This commit is contained in:
+32
-12
@@ -1,20 +1,40 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
APP_ACCESS_LOG=1
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
S3_ENDPOINT=http://s3: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
|
||||
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=messenger
|
||||
POSTGRES_DB=messenger
|
||||
|
||||
# Внутри сети Compose. Хосту для student-tests — localhost после проброса портов.
|
||||
DATABASE_URL=postgres://messenger:messenger@postgres:5432/messenger?sslmode=disable
|
||||
REDIS_URL=redis://redis:6379/0
|
||||
SESSION_STORE=redis
|
||||
|
||||
# Число API-реплик за LB. Поднимать: scripts/up.sh или compose --scale api=N
|
||||
API_REPLICAS=2
|
||||
# Лимиты одной API-реплики.
|
||||
API_CPUS=0.50
|
||||
API_MEMORY=256M
|
||||
# Пул соединений на одну реплику. Суммарно ≈ API_REPLICAS * DB_MAX_CONNS.
|
||||
DB_MAX_CONNS=5
|
||||
|
||||
# Лимиты вложений (контракт lab4).
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
|
||||
# MinIO (S3). Root — только для bootstrap (minio-init). API использует app-ключи.
|
||||
MINIO_ROOT_USER=minioadmin
|
||||
MINIO_ROOT_PASSWORD=minioadmin-secret
|
||||
S3_ENDPOINT=minio:9000
|
||||
S3_USE_SSL=0
|
||||
S3_REGION=us-east-1
|
||||
S3_BUCKET=messenger-attachments
|
||||
S3_ACCESS_KEY_ID=messenger-app
|
||||
S3_SECRET_ACCESS_KEY=messenger-app-secret
|
||||
# Grace period reconciler (секунды): свежие orphan/missing не трогаем.
|
||||
S3_RECONCILE_GRACE_SECONDS=60
|
||||
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
# syntax=docker/dockerfile:1.7
|
||||
FROM golang:1.24.2-bookworm AS build
|
||||
WORKDIR /src
|
||||
COPY go.mod go.sum ./
|
||||
RUN go mod download
|
||||
COPY cmd ./cmd
|
||||
COPY internal ./internal
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/server ./cmd/server
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/reconcile ./cmd/reconcile
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/s3bootstrap ./cmd/s3bootstrap
|
||||
|
||||
FROM gcr.io/distroless/static-debian12:nonroot
|
||||
COPY --from=build /out/server /server
|
||||
COPY --from=build /out/reconcile /reconcile
|
||||
COPY --from=build /out/s3bootstrap /s3bootstrap
|
||||
USER nonroot:nonroot
|
||||
EXPOSE 8080
|
||||
ENV APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080 \
|
||||
APP_ENV=lab \
|
||||
SESSION_TTL_SECONDS=3600
|
||||
HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=5 \
|
||||
CMD ["/server", "-healthcheck"]
|
||||
ENTRYPOINT ["/server"]
|
||||
@@ -4,10 +4,10 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
.PHONY: help check validate test load test-persistence test-failover up down student-test private-bucket concurrent reconcile-demo
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "check: offline structure; validate: full OpenAPI; test: smoke; up/down: compose stand"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -28,3 +28,23 @@ test-persistence:
|
||||
test-failover:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
up:
|
||||
bash scripts/up.sh
|
||||
|
||||
down:
|
||||
docker compose --env-file .env down
|
||||
|
||||
student-test:
|
||||
DATABASE_URL=postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable \
|
||||
REDIS_URL=redis://127.0.0.1:6379/0 \
|
||||
go test ./student-tests/ -count=1 -v
|
||||
|
||||
private-bucket:
|
||||
bash scripts/check-private-bucket.sh
|
||||
|
||||
concurrent:
|
||||
bash scripts/concurrent-uploads.sh
|
||||
|
||||
reconcile-demo:
|
||||
bash scripts/reconcile-demo.sh
|
||||
|
||||
@@ -1,37 +1,81 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Белоусов Анатолий Фахраддинович, БПИ2303
|
||||
- Целевая оценка; выбранный трек 5: **5, трек 2** (согласованность двух хранилищ / reconciler)
|
||||
- Commit/PR: ветка `solution/bpi2303-belousov`
|
||||
- Использованные источники, библиотеки и помощь ИИ: Go `net/http`, `pgx` v5, `go-redis` v9, `minio-go` v7, `madmin-go` v3, `golang.org/x/crypto/argon2`, `google/uuid`; MinIO community-образ `ghcr.io/coollabsio/minio` (официальные `minio/minio` сняты с Docker Hub); HAProxy 2.9; публичные `tests/`; Cursor/Composer. База — реализация lab3.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Docker, Go 1.24+ (student-tests), Python 3.9+.
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
bash scripts/up.sh
|
||||
# postgres+redis+minio → s3bootstrap → migrate → API×N → LB :8080
|
||||
make test
|
||||
make student-test
|
||||
make private-bucket
|
||||
make concurrent
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
bash scripts/restore-one.sh # после failover
|
||||
make reconcile-demo # трек 5: dry-run → apply → fresh skip
|
||||
```
|
||||
|
||||
Остановка без удаления данных: `docker compose --env-file .env stop`.
|
||||
Удаление учебных volumes: `docker compose --env-file .env down -v`.
|
||||
|
||||
Образы: сборка `golang:1.24.2-bookworm`, runtime `gcr.io/distroless/static-debian12:nonroot`, PostgreSQL `postgres:16.6`, Redis `redis:7.4.1` (AOF), HAProxy `haproxy:2.9.14-alpine`, MinIO `ghcr.io/coollabsio/minio:RELEASE.2025-10-15T17-29-55Z`. Консоль MinIO не публикуется; API S3 — только `127.0.0.1:9000` для локальной проверки private bucket.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Клиент → HAProxy → API×2+ → PostgreSQL (метаданные) + Redis (сессии) + приватный MinIO (байты).
|
||||
|
||||
Вложение: сервер назначает ключ `originals/<uuid>`; `filename` только в метаданных. Порядок записи — **сначала S3 PUT, потом INSERT**; 201 только после обоих. Ошибка INSERT → немедленный Delete объекта; если Delete не удался — orphan подберёт reconciler после grace.
|
||||
|
||||
Загрузка: spool во временный файл (не `ReadAll`), лимит `MaxUploadBytes+1`, MIME по содержимому, размеры PNG/JPEG из заголовка до декодирования пикселей, структурная проверка CRC/EOI. Download — proxy через API (проверка членства), без редиректа на S3.
|
||||
|
||||
Перенесено из lab3: LB, Idempotency-Key, X-Instance-Id, Redis-сессии, failover hooks. Добавлено: миграция `003_attachments.sql`, routes attachments, `cmd/reconcile`, `cmd/s3bootstrap`, MinIO в compose.
|
||||
|
||||
Переменные `.env.example` → compose `x-api-env` / Load / LoadS3: `DATABASE_URL`, `REDIS_URL`, `S3_*`, `MAX_UPLOAD_*`, `S3_RECONCILE_GRACE_SECONDS`.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke (checksum, ACL) | `make test` | PASS lab4 public API scenario | `evidence/smoke.txt` |
|
||||
| Offline contract | `make check` | PASS | (stdout) |
|
||||
| Student-tests вложений/негативы/S3↓ | `make student-test` | PASS | `evidence/student-tests.txt` |
|
||||
| Private bucket | `make private-bucket` | anonymous GET → HTTP 403 | `evidence/private-bucket.txt` |
|
||||
| Persistence + оригинал | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS (restart postgres redis minio api lb) | `evidence/persistence.txt` |
|
||||
| Failover API + download через другую реплику | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | PASS; 2 instance ids до отказа | `evidence/failover.txt` |
|
||||
| ≥10 concurrent uploads + RSS | `make concurrent` | 12×201; RSS API до/пик/после | `evidence/concurrent-uploads.txt` |
|
||||
| Трек 2 reconciler | `make reconcile-demo` | orphan deleted; missing unreferenced deleted; referenced kept; fresh skipped | `evidence/reconcile.txt` |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
**Гипотеза (трек 2):** при grace period reconciler безопасно удаляет только «старые» orphan-объекты и нессылаемые missing-строки; повторный apply идемпотентен; свежий orphan не трогается.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
Методика: `scripts/reconcile-demo.sh` — SigV4 PUT orphan root-ключом; SQL INSERT missing без объекта; dry-run/`-apply` с `-grace-seconds=0`; затем fresh orphan и dry-run с grace=60s.
|
||||
|
||||
Результаты (локальный прогон): orphan удалён; 2 missing без ссылок удалены; 2 missing с `message_attachments` сохранены; fresh orphan → `orphan_skip_fresh`. Обход: List S3 O(n) + keyset по attachments; elapsed dry-run ~10–30 ms на учебном объёме.
|
||||
|
||||
**Concurrent uploads:** 12 параллельных PNG по ~3.0 MiB (1024², zlib level 0), spool в `/tmp`.
|
||||
RSS суммарно по API-репликам: before ≈96 MiB, peak ≈98 MiB, after ≈97 MiB — пик не масштабируется
|
||||
как `N × размер файла` (нет `ReadAll` в кучу). См. `evidence/concurrent-uploads.txt`.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Восстановление |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `docker stop` одной API | LB уводит трафик; download с другой реплики | PASS failover | `scripts/restore-one.sh` |
|
||||
| `restart` всех хранилищ+API | сессия и файл на месте | PASS persistence | volumes сохранены |
|
||||
| Anonymous GET MinIO | не 200 | 403 | — |
|
||||
| S3 down (unit) | ready/upload 503 | PASS student-test | — |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- Официальные образы MinIO/Docker Hub недоступны; закреплён community-образ coollabsio того же RELEASE — риск расхождения с upstream.
|
||||
- Reconciler не чинит referenced missing (нет исходных байтов) — только детектит; восстановление из бэкапа S3 вне скоупа.
|
||||
- Student-tests с in-memory blob пишут метаданные в общий Postgres без объектов в MinIO; на учебном стенде их подбирает reconciler (referenced → keep).
|
||||
- Presigned direct upload (трек 1) не реализован — выбран трек 2.
|
||||
- Учебные секреты в `.env.example`; в Git не коммитить `.env`.
|
||||
|
||||
@@ -0,0 +1,221 @@
|
||||
// Reconciler lab4 (трек 5 / согласованность двух хранилищ).
|
||||
//
|
||||
// Сверяет PostgreSQL (attachments) и приватный S3-bucket (префикс originals/).
|
||||
// По умолчанию dry-run: только отчёт. Флаг -apply выполняет безопасные правки.
|
||||
//
|
||||
// Классы расхождений:
|
||||
//
|
||||
// orphan — объект в S3 без строки в БД. После grace period удаляется (-apply).
|
||||
// missing — строка в БД без объекта. Если на вложение нет ссылок из сообщений
|
||||
// и строка старше grace — удаляется. Ссылаемые (в сообщениях) только
|
||||
// логируются: удалять их нельзя, файл уже «в истории».
|
||||
//
|
||||
// Свежие объекты/строки (моложе grace) не трогаются: гонка «PUT прошёл, INSERT ещё нет»
|
||||
// не должна приводить к удалению чужой успешной загрузки.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026lab4/internal/auth"
|
||||
"mtusi2026lab4/internal/blob"
|
||||
"mtusi2026lab4/internal/config"
|
||||
"mtusi2026lab4/internal/store"
|
||||
)
|
||||
|
||||
func main() {
|
||||
apply := flag.Bool("apply", false, "apply safe fixes (default: dry-run)")
|
||||
graceSec := flag.Int64("grace-seconds", -1, "override S3_RECONCILE_GRACE_SECONDS (-1 = from env)")
|
||||
pageSize := flag.Int("page-size", 200, "DB page size for attachment refs")
|
||||
flag.Parse()
|
||||
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
log.Fatalf("config: %v", err)
|
||||
}
|
||||
grace := cfg.ReconcileGrace
|
||||
if *graceSec >= 0 {
|
||||
grace = time.Duration(*graceSec) * time.Second
|
||||
}
|
||||
s3cfg, err := config.LoadS3()
|
||||
if err != nil {
|
||||
log.Fatalf("s3 config: %v", err)
|
||||
}
|
||||
|
||||
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
|
||||
defer stop()
|
||||
|
||||
hasher, err := auth.NewHasher()
|
||||
if err != nil {
|
||||
log.Fatalf("hasher: %v", err)
|
||||
}
|
||||
st, err := store.Open(ctx, cfg.DatabaseURL, hasher, cfg.MaxConns)
|
||||
if err != nil {
|
||||
log.Fatalf("postgres: %v", err)
|
||||
}
|
||||
defer st.Close()
|
||||
|
||||
bl, err := blob.New(blob.Config{
|
||||
Endpoint: s3cfg.Endpoint,
|
||||
UseSSL: s3cfg.UseSSL,
|
||||
Region: s3cfg.Region,
|
||||
Bucket: s3cfg.Bucket,
|
||||
AccessKey: s3cfg.AccessKey,
|
||||
SecretKey: s3cfg.SecretKey,
|
||||
})
|
||||
if err != nil {
|
||||
log.Fatalf("s3: %v", err)
|
||||
}
|
||||
if err := bl.Ping(ctx); err != nil {
|
||||
log.Fatalf("s3 ping: %v", err)
|
||||
}
|
||||
|
||||
mode := "dry-run"
|
||||
if *apply {
|
||||
mode = "apply"
|
||||
}
|
||||
log.Printf("reconcile start mode=%s grace=%s bucket=%s page=%d", mode, grace, s3cfg.Bucket, *pageSize)
|
||||
|
||||
started := time.Now()
|
||||
rep, err := run(ctx, st, bl, grace, *pageSize, *apply)
|
||||
if err != nil {
|
||||
log.Fatalf("reconcile: %v", err)
|
||||
}
|
||||
elapsed := time.Since(started)
|
||||
|
||||
fmt.Printf("reconcile_report mode=%s elapsed_ms=%d\n", mode, elapsed.Milliseconds())
|
||||
fmt.Printf("s3_objects=%d db_rows=%d\n", rep.S3Objects, rep.DBRows)
|
||||
fmt.Printf("orphans_found=%d orphans_deleted=%d orphans_skipped_fresh=%d\n",
|
||||
rep.OrphansFound, rep.OrphansDeleted, rep.OrphansSkippedFresh)
|
||||
fmt.Printf("missing_found=%d missing_deleted=%d missing_referenced=%d missing_skipped_fresh=%d\n",
|
||||
rep.MissingFound, rep.MissingDeleted, rep.MissingReferenced, rep.MissingSkippedFresh)
|
||||
for _, line := range rep.Details {
|
||||
fmt.Println(line)
|
||||
}
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
type report struct {
|
||||
S3Objects int
|
||||
DBRows int
|
||||
OrphansFound int
|
||||
OrphansDeleted int
|
||||
OrphansSkippedFresh int
|
||||
MissingFound int
|
||||
MissingDeleted int
|
||||
MissingReferenced int
|
||||
MissingSkippedFresh int
|
||||
Details []string
|
||||
}
|
||||
|
||||
func run(ctx context.Context, st *store.Store, bl *blob.Client, grace time.Duration, pageSize int, apply bool) (*report, error) {
|
||||
if pageSize < 1 || pageSize > 1000 {
|
||||
pageSize = 200
|
||||
}
|
||||
rep := &report{}
|
||||
cutoff := time.Now().UTC().Add(-grace)
|
||||
|
||||
objs, err := bl.ListKeys(ctx, blob.KeyPrefix)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list s3: %w", err)
|
||||
}
|
||||
rep.S3Objects = len(objs)
|
||||
byKey := make(map[string]blob.ObjectInfo, len(objs))
|
||||
for _, o := range objs {
|
||||
byKey[o.Key] = o
|
||||
}
|
||||
|
||||
dbKeys := make(map[string]store.AttachmentRef)
|
||||
var after uuid.UUID
|
||||
for {
|
||||
page, err := st.ListAttachmentRefs(ctx, after, pageSize)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list db: %w", err)
|
||||
}
|
||||
if len(page) == 0 {
|
||||
break
|
||||
}
|
||||
for _, r := range page {
|
||||
dbKeys[r.ObjectKey] = r
|
||||
rep.DBRows++
|
||||
after = r.ID
|
||||
}
|
||||
if len(page) < pageSize {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
// orphan: S3 без строки
|
||||
for key, o := range byKey {
|
||||
if _, ok := dbKeys[key]; ok {
|
||||
continue
|
||||
}
|
||||
rep.OrphansFound++
|
||||
if o.LastModified.After(cutoff) {
|
||||
rep.OrphansSkippedFresh++
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("orphan_skip_fresh key=%s age<%s", key, grace))
|
||||
continue
|
||||
}
|
||||
// Повторная проверка: загрузка могла успеть записать строку после ListKeys.
|
||||
exists, err := st.AttachmentKeyExists(ctx, key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if exists {
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("orphan_race_gone key=%s", key))
|
||||
continue
|
||||
}
|
||||
if apply {
|
||||
if err := bl.Delete(ctx, key); err != nil {
|
||||
return nil, fmt.Errorf("delete orphan %s: %w", key, err)
|
||||
}
|
||||
rep.OrphansDeleted++
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("orphan_deleted key=%s size=%d", key, o.Size))
|
||||
} else {
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("orphan_would_delete key=%s size=%d", key, o.Size))
|
||||
}
|
||||
}
|
||||
|
||||
// missing: строка без объекта
|
||||
for key, ref := range dbKeys {
|
||||
if _, ok := byKey[key]; ok {
|
||||
continue
|
||||
}
|
||||
rep.MissingFound++
|
||||
if ref.CreatedAt.After(cutoff) {
|
||||
rep.MissingSkippedFresh++
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("missing_skip_fresh id=%s key=%s", ref.ID, key))
|
||||
continue
|
||||
}
|
||||
if ref.Referenced {
|
||||
rep.MissingReferenced++
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("missing_referenced id=%s key=%s (kept)", ref.ID, key))
|
||||
continue
|
||||
}
|
||||
if apply {
|
||||
ok, err := st.DeleteUnreferencedAttachment(ctx, ref.ID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("delete missing meta %s: %w", ref.ID, err)
|
||||
}
|
||||
if ok {
|
||||
rep.MissingDeleted++
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("missing_deleted id=%s key=%s", ref.ID, key))
|
||||
} else {
|
||||
rep.MissingReferenced++
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("missing_race_referenced id=%s key=%s", ref.ID, key))
|
||||
}
|
||||
} else {
|
||||
rep.Details = append(rep.Details, fmt.Sprintf("missing_would_delete id=%s key=%s", ref.ID, key))
|
||||
}
|
||||
}
|
||||
return rep, nil
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
// Одноразовый bootstrap приватного S3-bucket и app-пользователя с ограниченной политикой.
|
||||
// Нужен, потому что публичные образы minio/mc с Docker Hub сняты; admin API вызываем из Go.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/minio/madmin-go/v3"
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/credentials"
|
||||
)
|
||||
|
||||
func main() {
|
||||
endpoint := env("MINIO_ENDPOINT", "minio:9000")
|
||||
endpoint = strings.TrimPrefix(strings.TrimPrefix(endpoint, "https://"), "http://")
|
||||
rootUser := mustEnv("MINIO_ROOT_USER")
|
||||
rootPass := mustEnv("MINIO_ROOT_PASSWORD")
|
||||
bucket := env("S3_BUCKET", "messenger-attachments")
|
||||
appKey := mustEnv("S3_ACCESS_KEY_ID")
|
||||
appSecret := mustEnv("S3_SECRET_ACCESS_KEY")
|
||||
useSSL := env("S3_USE_SSL", "0") == "1" || strings.EqualFold(env("S3_USE_SSL", "0"), "true")
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
||||
defer cancel()
|
||||
|
||||
mc, err := minio.New(endpoint, &minio.Options{
|
||||
Creds: credentials.NewStaticV4(rootUser, rootPass, ""),
|
||||
Secure: useSSL,
|
||||
})
|
||||
if err != nil {
|
||||
log.Fatalf("minio client: %v", err)
|
||||
}
|
||||
|
||||
deadline := time.Now().Add(90 * time.Second)
|
||||
for {
|
||||
ok, err := mc.BucketExists(ctx, bucket)
|
||||
if err == nil {
|
||||
if !ok {
|
||||
if err := mc.MakeBucket(ctx, bucket, minio.MakeBucketOptions{}); err != nil {
|
||||
code := minio.ToErrorResponse(err).Code
|
||||
if code != "BucketAlreadyOwnedByYou" && code != "BucketAlreadyExists" {
|
||||
log.Fatalf("make bucket: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
}
|
||||
if time.Now().After(deadline) {
|
||||
log.Fatalf("minio not ready: %v", err)
|
||||
}
|
||||
log.Printf("waiting for minio: %v", err)
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
|
||||
// Явно запрещаем анонимный доступ (на случай, если кто-то выставил public).
|
||||
if err := mc.SetBucketPolicy(ctx, bucket, ""); err != nil {
|
||||
log.Printf("clear bucket policy: %v (продолжаем)", err)
|
||||
}
|
||||
|
||||
admin, err := madmin.NewWithOptions(endpoint, &madmin.Options{
|
||||
Creds: credentials.NewStaticV4(rootUser, rootPass, ""),
|
||||
Secure: useSSL,
|
||||
})
|
||||
if err != nil {
|
||||
log.Fatalf("madmin: %v", err)
|
||||
}
|
||||
|
||||
policyName := "app-attachments"
|
||||
policy := fmt.Sprintf(`{
|
||||
"Version": "2012-10-17",
|
||||
"Statement": [
|
||||
{
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:ListBucket"],
|
||||
"Resource": ["arn:aws:s3:::%s"]
|
||||
},
|
||||
{
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
|
||||
"Resource": ["arn:aws:s3:::%s/*"]
|
||||
}
|
||||
]
|
||||
}`, bucket, bucket)
|
||||
|
||||
if err := admin.AddCannedPolicy(ctx, policyName, []byte(policy)); err != nil {
|
||||
// Уже существует — ок.
|
||||
log.Printf("add policy: %v", err)
|
||||
}
|
||||
if err := admin.AddUser(ctx, appKey, appSecret); err != nil {
|
||||
log.Printf("add user: %v", err)
|
||||
}
|
||||
if _, err := admin.AttachPolicy(ctx, madmin.PolicyAssociationReq{
|
||||
Policies: []string{policyName},
|
||||
User: appKey,
|
||||
}); err != nil {
|
||||
// Старые версии madmin: SetPolicy
|
||||
if err2 := admin.SetPolicy(ctx, policyName, appKey, false); err2 != nil {
|
||||
log.Fatalf("attach policy: %v / set policy: %v", err, err2)
|
||||
}
|
||||
}
|
||||
|
||||
log.Printf("bootstrap ok bucket=%s app_user=%s private=yes", bucket, appKey)
|
||||
}
|
||||
|
||||
func env(k, def string) string {
|
||||
if v := strings.TrimSpace(os.Getenv(k)); v != "" {
|
||||
return v
|
||||
}
|
||||
return def
|
||||
}
|
||||
|
||||
func mustEnv(k string) string {
|
||||
v := strings.TrimSpace(os.Getenv(k))
|
||||
if v == "" {
|
||||
log.Fatalf("missing %s", k)
|
||||
}
|
||||
return v
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
// Точка входа HTTP API и одноразового мигратора lab4.
|
||||
//
|
||||
// Режимы:
|
||||
//
|
||||
// (по умолчанию) — API-реплика: Postgres + Redis + S3, миграции НЕ применяет;
|
||||
// -migrate — применить SQL и выйти (S3 не нужен);
|
||||
// -healthcheck — локальный probe /health/ready.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"mtusi2026lab4/internal/api"
|
||||
"mtusi2026lab4/internal/auth"
|
||||
"mtusi2026lab4/internal/blob"
|
||||
"mtusi2026lab4/internal/config"
|
||||
"mtusi2026lab4/internal/session"
|
||||
"mtusi2026lab4/internal/store"
|
||||
)
|
||||
|
||||
func main() {
|
||||
healthcheck := flag.Bool("healthcheck", false, "probe local /health/ready and exit")
|
||||
migrateOnly := flag.Bool("migrate", false, "apply SQL migrations and exit")
|
||||
flag.Parse()
|
||||
if *healthcheck {
|
||||
os.Exit(runHealthcheck())
|
||||
}
|
||||
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
log.Fatalf("config: %v", err)
|
||||
}
|
||||
hasher, err := auth.NewHasher()
|
||||
if err != nil {
|
||||
log.Fatalf("password hasher: %v", err)
|
||||
}
|
||||
|
||||
rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
|
||||
defer stop()
|
||||
|
||||
st, err := waitPostgres(rootCtx, cfg.DatabaseURL, hasher, cfg.MaxConns)
|
||||
if err != nil {
|
||||
log.Fatalf("postgres: %v", err)
|
||||
}
|
||||
defer st.Close()
|
||||
|
||||
if *migrateOnly || cfg.RunMigrations {
|
||||
if err := st.Migrate(rootCtx); err != nil {
|
||||
log.Fatalf("migrate: %v", err)
|
||||
}
|
||||
log.Printf("migrations applied")
|
||||
if *migrateOnly {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
sessions, err := waitRedis(rootCtx, cfg.RedisURL, cfg.SessionTTL)
|
||||
if err != nil {
|
||||
log.Fatalf("redis: %v", err)
|
||||
}
|
||||
defer sessions.Close()
|
||||
|
||||
s3cfg, err := config.LoadS3()
|
||||
if err != nil {
|
||||
log.Fatalf("s3 config: %v", err)
|
||||
}
|
||||
blobs, err := waitS3(rootCtx, s3cfg)
|
||||
if err != nil {
|
||||
log.Fatalf("s3: %v", err)
|
||||
}
|
||||
|
||||
srvAPI := api.New(st, sessions, blobs, cfg.InstanceID)
|
||||
srvAPI.MaxUploadBytes = cfg.MaxUploadBytes
|
||||
srvAPI.MaxImagePixels = cfg.MaxImagePixels
|
||||
|
||||
httpServer := &http.Server{
|
||||
Addr: cfg.Addr(),
|
||||
Handler: srvAPI.Handler(),
|
||||
ReadHeaderTimeout: 5 * time.Second,
|
||||
// Upload до 10 MiB: даём запас на медленный клиент.
|
||||
ReadTimeout: 60 * time.Second,
|
||||
WriteTimeout: 60 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
}
|
||||
|
||||
errCh := make(chan error, 1)
|
||||
go func() {
|
||||
log.Printf("listening on %s env=%s instance=%s session_ttl=%s db_max_conns=%d bucket=%s",
|
||||
cfg.Addr(), cfg.Env, cfg.InstanceID, cfg.SessionTTL, cfg.MaxConns, s3cfg.Bucket)
|
||||
if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
||||
errCh <- err
|
||||
}
|
||||
}()
|
||||
|
||||
select {
|
||||
case err := <-errCh:
|
||||
log.Fatalf("listen: %v", err)
|
||||
case <-rootCtx.Done():
|
||||
}
|
||||
log.Printf("shutting down instance=%s", cfg.InstanceID)
|
||||
srvAPI.BeginDrain()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
if err := httpServer.Shutdown(ctx); err != nil {
|
||||
log.Printf("shutdown error: %v", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
log.Printf("shutdown complete")
|
||||
}
|
||||
|
||||
func waitPostgres(ctx context.Context, dsn string, hasher *auth.Hasher, maxConns int32) (*store.Store, error) {
|
||||
deadline := time.Now().Add(45 * time.Second)
|
||||
var last error
|
||||
for {
|
||||
st, err := store.Open(ctx, dsn, hasher, maxConns)
|
||||
if err == nil {
|
||||
return st, nil
|
||||
}
|
||||
last = err
|
||||
if ctx.Err() != nil || time.Now().After(deadline) {
|
||||
return nil, last
|
||||
}
|
||||
log.Printf("postgres not ready, retrying")
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
case <-time.After(time.Second):
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func waitRedis(ctx context.Context, redisURL string, ttl time.Duration) (*session.Store, error) {
|
||||
deadline := time.Now().Add(45 * time.Second)
|
||||
var last error
|
||||
for {
|
||||
st, err := session.Open(redisURL, ttl)
|
||||
if err == nil {
|
||||
return st, nil
|
||||
}
|
||||
last = err
|
||||
if ctx.Err() != nil || time.Now().After(deadline) {
|
||||
return nil, last
|
||||
}
|
||||
log.Printf("redis not ready, retrying")
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
case <-time.After(time.Second):
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func waitS3(ctx context.Context, cfg config.S3) (*blob.Client, error) {
|
||||
deadline := time.Now().Add(45 * time.Second)
|
||||
var last error
|
||||
for {
|
||||
c, err := blob.New(blob.Config{
|
||||
Endpoint: cfg.Endpoint,
|
||||
UseSSL: cfg.UseSSL,
|
||||
Region: cfg.Region,
|
||||
Bucket: cfg.Bucket,
|
||||
AccessKey: cfg.AccessKey,
|
||||
SecretKey: cfg.SecretKey,
|
||||
})
|
||||
if err == nil {
|
||||
if err = c.Ping(ctx); err == nil {
|
||||
return c, nil
|
||||
}
|
||||
last = err
|
||||
} else {
|
||||
last = err
|
||||
}
|
||||
if ctx.Err() != nil || time.Now().After(deadline) {
|
||||
return nil, last
|
||||
}
|
||||
log.Printf("s3 not ready, retrying")
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
case <-time.After(time.Second):
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func runHealthcheck() int {
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
host := cfg.Host
|
||||
if host == "0.0.0.0" || host == "::" {
|
||||
host = "127.0.0.1"
|
||||
}
|
||||
client := &http.Client{Timeout: 2 * time.Second}
|
||||
resp, err := client.Get(fmt.Sprintf("http://%s:%d/health/ready", host, cfg.Port))
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
_, _ = io.Copy(io.Discard, resp.Body)
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
+203
@@ -0,0 +1,203 @@
|
||||
# Локальный стенд lab4: Клиент → HAProxy → API×N → PostgreSQL + Redis + приватный MinIO.
|
||||
# Публикуется только LB (:8080). Порты API наружу не публикуются.
|
||||
# MinIO API на 127.0.0.1:9000 — только для локальной проверки private bucket; консоль не публикуется.
|
||||
# Запуск: bash scripts/up.sh
|
||||
x-api-env: &api-env
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: 8080
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
APP_ACCESS_LOG: ${APP_ACCESS_LOG:-1}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
DB_MAX_CONNS: ${DB_MAX_CONNS:-5}
|
||||
DATABASE_URL: postgres://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-messenger}@postgres:5432/${POSTGRES_DB:-messenger}?sslmode=disable
|
||||
REDIS_URL: redis://redis:6379/0
|
||||
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
|
||||
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
|
||||
S3_ENDPOINT: ${S3_ENDPOINT:-minio:9000}
|
||||
S3_USE_SSL: ${S3_USE_SSL:-0}
|
||||
S3_REGION: ${S3_REGION:-us-east-1}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-messenger-app}
|
||||
S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-messenger-app-secret}
|
||||
S3_RECONCILE_GRACE_SECONDS: ${S3_RECONCILE_GRACE_SECONDS:-60}
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.6
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-messenger}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
ports:
|
||||
- "127.0.0.1:5432:5432"
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
stop_grace_period: 10s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
|
||||
redis:
|
||||
image: redis:7.4.1
|
||||
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
|
||||
volumes:
|
||||
- redisdata:/data
|
||||
ports:
|
||||
- "127.0.0.1:6379:6379"
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
stop_grace_period: 10s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 256M
|
||||
|
||||
# Публичные minio/minio с Docker Hub сняты (2026). Собираем из community-образа
|
||||
# ghcr.io/coollabsio/minio — бинарь последнего community RELEASE.
|
||||
minio:
|
||||
image: ghcr.io/coollabsio/minio:RELEASE.2025-10-15T17-29-55Z
|
||||
command: ["server", "/data", "--address", ":9000", "--console-address", ":9001"]
|
||||
environment:
|
||||
MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
|
||||
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin-secret}
|
||||
volumes:
|
||||
- miniodata:/data
|
||||
ports:
|
||||
- "127.0.0.1:9000:9000"
|
||||
# Консоль :9001 намеренно не публикуется (уровень 4).
|
||||
# В образе нет curl; TCP-probe + bootstrap ретраит MakeBucket.
|
||||
healthcheck:
|
||||
test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/9000"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
start_period: 10s
|
||||
stop_grace_period: 10s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 512M
|
||||
|
||||
# Bootstrap без mc: бинарь /s3bootstrap из нашего образа (minio-go + madmin).
|
||||
minio-init:
|
||||
build: .
|
||||
entrypoint: ["/s3bootstrap"]
|
||||
environment:
|
||||
MINIO_ENDPOINT: minio:9000
|
||||
MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
|
||||
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin-secret}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-messenger-app}
|
||||
S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-messenger-app-secret}
|
||||
S3_USE_SSL: ${S3_USE_SSL:-0}
|
||||
depends_on:
|
||||
minio:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
healthcheck:
|
||||
disable: true
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
command: ["-migrate"]
|
||||
environment:
|
||||
<<: *api-env
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
healthcheck:
|
||||
disable: true
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 256M
|
||||
|
||||
api:
|
||||
build: .
|
||||
environment:
|
||||
<<: *api-env
|
||||
expose:
|
||||
- "8080"
|
||||
depends_on:
|
||||
redis:
|
||||
condition: service_healthy
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
minio:
|
||||
condition: service_healthy
|
||||
minio-init:
|
||||
condition: service_completed_successfully
|
||||
healthcheck:
|
||||
test: ["CMD", "/server", "-healthcheck"]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 10
|
||||
start_period: 15s
|
||||
stop_grace_period: 10s
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: ${API_CPUS:-0.50}
|
||||
memory: ${API_MEMORY:-256M}
|
||||
|
||||
reconcile:
|
||||
build: .
|
||||
entrypoint: ["/reconcile"]
|
||||
environment:
|
||||
<<: *api-env
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
minio:
|
||||
condition: service_healthy
|
||||
minio-init:
|
||||
condition: service_completed_successfully
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 256M
|
||||
|
||||
lb:
|
||||
image: haproxy:2.9.14-alpine
|
||||
volumes:
|
||||
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
|
||||
interval: 10s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
start_period: 5s
|
||||
stop_grace_period: 10s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 128M
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
redisdata:
|
||||
miniodata:
|
||||
@@ -0,0 +1,8 @@
|
||||
concurrent=12
|
||||
upload_bytes=3147060
|
||||
ok_201=12
|
||||
results=[201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201]
|
||||
elapsed_s=1.717
|
||||
api_rss_kb_before=96654
|
||||
api_rss_kb_peak=98006
|
||||
api_rss_kb_after=97197
|
||||
@@ -0,0 +1,4 @@
|
||||
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
|
||||
{"observed_instances_before": 2, "successful_writes": 112, "failed_attempts": 1, "first_recovery_seconds": 2.928}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1,3 @@
|
||||
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1,2 @@
|
||||
GET http://127.0.0.1:9000/messenger-attachments/originals/does-not-exist → HTTP 403 body_bytes=381
|
||||
PASS: anonymous access denied (HTTP 403)
|
||||
@@ -0,0 +1,129 @@
|
||||
=== seed orphan object via root PutObject (python/minio not required: curl+aws style via go) ===
|
||||
orphan_put 200
|
||||
=== seed missing metadata (DB row, no S3 object) ===
|
||||
DO
|
||||
=== dry-run grace=0 ===
|
||||
#1 [internal] load local bake definitions
|
||||
#1 reading from stdin 683B done
|
||||
#1 DONE 0.0s
|
||||
|
||||
#2 [internal] load build definition from Dockerfile
|
||||
#2 transferring dockerfile: 927B done
|
||||
#2 DONE 0.0s
|
||||
|
||||
#3 resolve image config for docker-image://docker.io/docker/dockerfile:1.7
|
||||
#3 DONE 1.0s
|
||||
|
||||
#4 docker-image://docker.io/docker/dockerfile:1.7@sha256:a57df69d0ea827fb7266491f2813635de6f17269be881f696fbfdf2d83dda33e
|
||||
#4 resolve docker.io/docker/dockerfile:1.7@sha256:a57df69d0ea827fb7266491f2813635de6f17269be881f696fbfdf2d83dda33e done
|
||||
#4 CACHED
|
||||
|
||||
#5 [internal] load metadata for docker.io/library/golang:1.24.2-bookworm
|
||||
#5 DONE 0.6s
|
||||
|
||||
#6 [internal] load metadata for gcr.io/distroless/static-debian12:nonroot
|
||||
#6 DONE 0.7s
|
||||
|
||||
#7 [internal] load .dockerignore
|
||||
#7 transferring context: 196B done
|
||||
#7 DONE 0.0s
|
||||
|
||||
#8 [stage-1 1/4] FROM gcr.io/distroless/static-debian12:nonroot@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab
|
||||
#8 resolve gcr.io/distroless/static-debian12:nonroot@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab 0.0s done
|
||||
#8 DONE 0.0s
|
||||
|
||||
#9 [build 1/9] FROM docker.io/library/golang:1.24.2-bookworm@sha256:79390b5e5af9ee6e7b1173ee3eac7fadf6751a545297672916b59bfa0ecf6f71
|
||||
#9 resolve docker.io/library/golang:1.24.2-bookworm@sha256:79390b5e5af9ee6e7b1173ee3eac7fadf6751a545297672916b59bfa0ecf6f71 0.0s done
|
||||
#9 DONE 0.0s
|
||||
|
||||
#10 [internal] load build context
|
||||
#10 transferring context: 1.21kB 0.0s done
|
||||
#10 DONE 0.0s
|
||||
|
||||
#11 [stage-1 2/4] COPY --from=build /out/server /server
|
||||
#11 CACHED
|
||||
|
||||
#12 [stage-1 3/4] COPY --from=build /out/reconcile /reconcile
|
||||
#12 CACHED
|
||||
|
||||
#13 [build 6/9] COPY internal ./internal
|
||||
#13 CACHED
|
||||
|
||||
#14 [build 4/9] RUN go mod download
|
||||
#14 CACHED
|
||||
|
||||
#15 [build 2/9] WORKDIR /src
|
||||
#15 CACHED
|
||||
|
||||
#16 [build 8/9] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/reconcile ./cmd/reconcile
|
||||
#16 CACHED
|
||||
|
||||
#17 [build 9/9] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/s3bootstrap ./cmd/s3bootstrap
|
||||
#17 CACHED
|
||||
|
||||
#18 [build 3/9] COPY go.mod go.sum ./
|
||||
#18 CACHED
|
||||
|
||||
#19 [build 5/9] COPY cmd ./cmd
|
||||
#19 CACHED
|
||||
|
||||
#20 [build 7/9] RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/server ./cmd/server
|
||||
#20 CACHED
|
||||
|
||||
#21 [stage-1 4/4] COPY --from=build /out/s3bootstrap /s3bootstrap
|
||||
#21 CACHED
|
||||
|
||||
#22 exporting to image
|
||||
#22 exporting layers 0.0s done
|
||||
#22 exporting manifest sha256:b3e7db748d123d1baf965ab1e27b5d2a2bea64f3e68fe93798166da5c67b58f3 0.1s done
|
||||
#22 exporting config sha256:76f75b546642e6ee2a4f055c5a45f1f406f5698112cd37c26b7301bcdcf8839f
|
||||
#22 exporting config sha256:76f75b546642e6ee2a4f055c5a45f1f406f5698112cd37c26b7301bcdcf8839f 0.0s done
|
||||
#22 exporting attestation manifest sha256:a877a0a7985478d45981bc5e291b0bc16bf401bfedfe03691ee01f5f50cf1606
|
||||
#22 exporting attestation manifest sha256:a877a0a7985478d45981bc5e291b0bc16bf401bfedfe03691ee01f5f50cf1606 0.0s done
|
||||
#22 exporting manifest list sha256:e53705a39a996dc932198dc966f069d8bb83bba703dbcb6db0fe25d733a4fab7 0.0s done
|
||||
#22 naming to docker.io/library/mtusi2026lab4-reconcile:latest done
|
||||
#22 unpacking to docker.io/library/mtusi2026lab4-reconcile:latest done
|
||||
#22 DONE 0.4s
|
||||
|
||||
#23 resolving provenance for metadata file
|
||||
#23 DONE 0.0s
|
||||
2026/11/12 15:06:31 reconcile start mode=dry-run grace=0s bucket=messenger-attachments page=200
|
||||
reconcile_report mode=dry-run elapsed_ms=33
|
||||
s3_objects=16 db_rows=19
|
||||
orphans_found=1 orphans_deleted=0 orphans_skipped_fresh=0
|
||||
missing_found=4 missing_deleted=0 missing_referenced=2 missing_skipped_fresh=0
|
||||
orphan_would_delete key=originals/00000000-0000-4000-8000-0000000000aa size=12
|
||||
missing_referenced id=867bc3f8-3656-4138-a787-b5fc8fc85498 key=originals/867bc3f8-3656-4138-a787-b5fc8fc85498 (kept)
|
||||
missing_referenced id=cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b key=originals/cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b (kept)
|
||||
missing_would_delete id=ad7a23e7-aa2a-4c95-8d17-52394f8ebfd2 key=originals/ad7a23e7-aa2a-4c95-8d17-52394f8ebfd2
|
||||
missing_would_delete id=11111111-1111-4111-8111-111111111111 key=originals/11111111-1111-4111-8111-111111111111
|
||||
=== apply grace=0 ===
|
||||
2026/11/12 15:06:33 reconcile start mode=apply grace=0s bucket=messenger-attachments page=200
|
||||
reconcile_report mode=apply elapsed_ms=17
|
||||
s3_objects=16 db_rows=19
|
||||
orphans_found=1 orphans_deleted=1 orphans_skipped_fresh=0
|
||||
missing_found=4 missing_deleted=2 missing_referenced=2 missing_skipped_fresh=0
|
||||
orphan_deleted key=originals/00000000-0000-4000-8000-0000000000aa size=12
|
||||
missing_referenced id=867bc3f8-3656-4138-a787-b5fc8fc85498 key=originals/867bc3f8-3656-4138-a787-b5fc8fc85498 (kept)
|
||||
missing_deleted id=ad7a23e7-aa2a-4c95-8d17-52394f8ebfd2 key=originals/ad7a23e7-aa2a-4c95-8d17-52394f8ebfd2
|
||||
missing_referenced id=cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b key=originals/cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b (kept)
|
||||
missing_deleted id=11111111-1111-4111-8111-111111111111 key=originals/11111111-1111-4111-8111-111111111111
|
||||
=== second apply (idempotent) ===
|
||||
2026/11/12 15:06:34 reconcile start mode=apply grace=0s bucket=messenger-attachments page=200
|
||||
reconcile_report mode=apply elapsed_ms=7
|
||||
s3_objects=15 db_rows=17
|
||||
orphans_found=0 orphans_deleted=0 orphans_skipped_fresh=0
|
||||
missing_found=2 missing_deleted=0 missing_referenced=2 missing_skipped_fresh=0
|
||||
missing_referenced id=cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b key=originals/cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b (kept)
|
||||
missing_referenced id=867bc3f8-3656-4138-a787-b5fc8fc85498 key=originals/867bc3f8-3656-4138-a787-b5fc8fc85498 (kept)
|
||||
=== fresh orphan skipped with default grace ===
|
||||
fresh_put 200
|
||||
2026/11/12 15:06:35 reconcile start mode=dry-run grace=1m0s bucket=messenger-attachments page=200
|
||||
reconcile_report mode=dry-run elapsed_ms=13
|
||||
s3_objects=16 db_rows=17
|
||||
orphans_found=1 orphans_deleted=0 orphans_skipped_fresh=1
|
||||
missing_found=2 missing_deleted=0 missing_referenced=0 missing_skipped_fresh=2
|
||||
orphan_skip_fresh key=originals/00000000-0000-4000-8000-0000000000bb age<1m0s
|
||||
missing_skip_fresh id=cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b key=originals/cd3c2ce1-b4fb-4229-99e7-356d5ffb4d8b
|
||||
missing_skip_fresh id=867bc3f8-3656-4138-a787-b5fc8fc85498 key=originals/867bc3f8-3656-4138-a787-b5fc8fc85498
|
||||
wrote evidence/reconcile.txt
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,250 @@
|
||||
DATABASE_URL=postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable \
|
||||
REDIS_URL=redis://127.0.0.1:6379/0 \
|
||||
go test ./student-tests/ -count=1 -v
|
||||
=== RUN TestMalformedJSONAndValidation
|
||||
api_test.go:76: → битый JSON, хвост после объекта, лишнее поле, пустой текст, чужой чат
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=400 request_id=8c1902bd-a429-4b6c-9a41-39b3dc20c4e8 duration_ms=0
|
||||
api_test.go:79: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"8c1902bd-a429-4b6c-9a41-39b3dc20c4e8"}}
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=400 request_id=f01f3adb-78bb-4722-8c40-fcb5939899ec duration_ms=0
|
||||
api_test.go:86: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"f01f3adb-78bb-4722-8c40-fcb5939899ec"}}
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=50bdc461-ab51-4108-9e5c-58495ab5edeb duration_ms=52
|
||||
api_test.go:91: создан ok_user_327b0fdb id=926f8271-4f8e-4379-b69b-e424e83919d7
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=4483c457-abce-4d52-9d97-df7fe1ceed40 duration_ms=39
|
||||
api_test.go:92: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/chats status=201 request_id=5ee4d4df-80bf-4212-9b11-15a8beaa22d8 duration_ms=8
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/chats/85991ce8-09f4-48c6-80eb-171e80d344d4/messages status=400 request_id=788d8cb8-5474-470e-b39c-d7fce6962987 duration_ms=3
|
||||
api_test.go:99: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"788d8cb8-5474-470e-b39c-d7fce6962987"}}
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/chats/85991ce8-09f4-48c6-80eb-171e80d344d4/messages status=400 request_id=d4632ebb-a886-4338-8372-5d73e2239842 duration_ms=0
|
||||
api_test.go:99: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"d4632ebb-a886-4338-8372-5d73e2239842"}}
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/chats/85991ce8-09f4-48c6-80eb-171e80d344d4/messages status=400 request_id=09b6498f-3e15-49b7-9266-ecf84d2a7916 duration_ms=0
|
||||
api_test.go:106: status=400 body={"error":{"code":"invalid_request","message":"invalid text","request_id":"09b6498f-3e15-49b7-9266-ecf84d2a7916"}}
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=87a631af-6c30-46eb-a783-5b81d3db8d7e duration_ms=36
|
||||
api_test.go:111: создан outsider_24331385 id=225d868f-362a-41d4-996b-1881ccf6cd8a
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=168ea6f0-a4b0-44fa-b272-3ca6fa92fdb8 duration_ms=35
|
||||
api_test.go:112: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/chats/85991ce8-09f4-48c6-80eb-171e80d344d4/messages status=404 request_id=d6eebb84-6115-4163-9d68-0a5f4870ac33 duration_ms=5
|
||||
api_test.go:114: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"d6eebb84-6115-4163-9d68-0a5f4870ac33"}}
|
||||
api_test.go:118: ✓ валидация JSON, хвоста, пустого текста и чужого чата
|
||||
--- PASS: TestMalformedJSONAndValidation (0.19s)
|
||||
=== RUN TestMessageTextPreservedAndLengthOnOriginal
|
||||
api_test.go:124: → пробелы по краям сохраняются; длина считается по исходному тексту
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=35882536-5698-47e4-aa4d-b26ca05eccf2 duration_ms=28
|
||||
api_test.go:125: создан text_user_b0b3691c id=4d721a90-d23e-4812-bc50-4b91b972f4a9
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=68fe42a9-aa1d-4219-89d0-0bea4485c691 duration_ms=52
|
||||
api_test.go:126: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/chats status=201 request_id=d2fdb0f8-f7e6-4a7a-906e-bd5a7575c658 duration_ms=73
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/chats/5af6de80-5d24-4e1c-85ba-6064483eee06/messages status=201 request_id=e87c5fb7-9da0-4db4-b3d3-5c2fde5a1f9c duration_ms=31
|
||||
api_test.go:133: status=201 body={"attachment_ids":[],"chat_id":"5af6de80-5d24-4e1c-85ba-6064483eee06","created_at":"2026-11-12T15:06:18.586Z","id":"fb22f748-419d-4e21-bad1-15eefd3541fc","sender_id":"4d721a90-d23e-4812-bc50-4b91b972f4a9","text":" строка\nс пробелами "}
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/chats/5af6de80-5d24-4e1c-85ba-6064483eee06/messages status=400 request_id=fb0600ea-7684-4546-948c-758bd6de9fe7 duration_ms=0
|
||||
api_test.go:145: status=400 body={"error":{"code":"invalid_request","message":"invalid text","request_id":"fb0600ea-7684-4546-948c-758bd6de9fe7"}}
|
||||
api_test.go:149: ✓ текст сохранён целиком, обход лимита через TrimSpace закрыт
|
||||
--- PASS: TestMessageTextPreservedAndLengthOnOriginal (0.19s)
|
||||
=== RUN TestSessionRejectsJSONBody
|
||||
api_test.go:155: → POST /auth/sessions с телом должен быть 400 даже при верном Basic
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=fb41ef9f-6a7e-40d9-9a7b-1a6b999f146a duration_ms=33
|
||||
api_test.go:156: создан body_user_f034de4e id=34ffe3cc-0fad-43ef-9c71-167de51999db
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=400 request_id=64964195-0966-4ef3-a09e-90cc2feddbe4 duration_ms=0
|
||||
api_test.go:160: status=400 body={"error":{"code":"invalid_request","message":"session create must not have a body","request_id":"64964195-0966-4ef3-a09e-90cc2feddbe4"}}
|
||||
api_test.go:164: ✓ вход без JSON body
|
||||
--- PASS: TestSessionRejectsJSONBody (0.04s)
|
||||
=== RUN TestWrongPasswordLogoutAndIgnoredUserHeader
|
||||
api_test.go:170: → неверный пароль, Basic на бизнес-методе, X-User-Id, logout
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=db2797ae-6acd-42c7-a935-5180d9f3f9c7 duration_ms=34
|
||||
api_test.go:171: создан auth_user_ceeda3df id=9a73b5de-ea1c-452d-a52a-ceada48a8bcb
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=4abdf37f-d666-4ffa-aca5-96358c777f19 duration_ms=35
|
||||
api_test.go:172: создан auth_other_029a2c01 id=84485afe-e12b-4811-abd5-6a323a4a11b0
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=401 request_id=561b7123-f836-4e1b-86e5-3202dd168c02 duration_ms=40
|
||||
api_test.go:177: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"561b7123-f836-4e1b-86e5-3202dd168c02"}}
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=ff0c1cd3-6893-498b-8a85-1ddcfaea198e duration_ms=37
|
||||
api_test.go:182: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:18 method=GET path=/api/v1/users/me status=401 request_id=fa44aa80-40c9-460c-8318-fbcdd6127ef5 duration_ms=0
|
||||
api_test.go:186: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"fa44aa80-40c9-460c-8318-fbcdd6127ef5"}}
|
||||
2026/11/12 18:06:18 method=GET path=/api/v1/users/me status=401 request_id=f76f04a1-a69e-4d4a-b6d9-6cefff6de333 duration_ms=0
|
||||
api_test.go:192: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"f76f04a1-a69e-4d4a-b6d9-6cefff6de333"}}
|
||||
2026/11/12 18:06:18 method=GET path=/api/v1/users/me status=200 request_id=57b7a10b-bcce-4f69-b4eb-84d7dbfe333d duration_ms=5
|
||||
api_test.go:201: status=200 body={"created_at":"2026-11-12T15:06:18.678Z","display_name":"Студент","id":"9a73b5de-ea1c-452d-a52a-ceada48a8bcb","username":"auth_user_ceeda3df"}
|
||||
2026/11/12 18:06:18 method=DELETE path=/api/v1/auth/sessions/current status=204 request_id=ed4b6610-d10e-4f08-933c-0da4c63e1db5 duration_ms=1
|
||||
api_test.go:207: logout status=204
|
||||
2026/11/12 18:06:18 method=GET path=/api/v1/users/me status=401 request_id=c51a2f42-758f-4a9d-9995-28d1fb1bd0e1 duration_ms=0
|
||||
2026/11/12 18:06:18 method=DELETE path=/api/v1/auth/sessions/current status=401 request_id=800ac6d0-86dd-46eb-baab-24c6f45c4993 duration_ms=1
|
||||
api_test.go:219: ✓ пароль, заголовки и отзыв сессии
|
||||
--- PASS: TestWrongPasswordLogoutAndIgnoredUserHeader (0.17s)
|
||||
=== RUN TestSessionExpiry
|
||||
api_test.go:225: → SESSION_TTL=2s: тот же токен после паузы должен стать 401, TTL рестартом API не продлевается
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/users status=201 request_id=bcb1c96f-65df-40a8-bdac-94727a1cb041 duration_ms=35
|
||||
api_test.go:226: создан ttl_user_325de81d id=484fbed9-09a4-4166-8f92-4f69a1fc1689
|
||||
2026/11/12 18:06:18 method=POST path=/api/v1/auth/sessions status=201 request_id=2088a908-3d83-4faf-bd43-84ee481db9cb duration_ms=25
|
||||
api_test.go:227: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:21 method=GET path=/api/v1/users/me status=401 request_id=0ba4365e-3bb4-4f55-886d-31698f49dc34 duration_ms=2
|
||||
api_test.go:230: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"0ba4365e-3bb4-4f55-886d-31698f49dc34"}}
|
||||
api_test.go:234: ✓ истёкшая сессия отклонена
|
||||
--- PASS: TestSessionExpiry (2.58s)
|
||||
=== RUN TestDuplicateUsernameRace
|
||||
api_test.go:241: → 8 параллельных регистраций username=race_6ed0656c
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=5402c615-aab8-4b07-a21d-46946f22785b duration_ms=83
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=e860a8f7-fd25-4c0d-abd9-31b50a08db96 duration_ms=85
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=dd17c014-02b9-4fb0-9481-7d4d3d840193 duration_ms=90
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=9a31aa27-6548-4e36-8505-5ec0334ebd76 duration_ms=92
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=d841c975-d516-4b63-b699-661a26ec2175 duration_ms=90
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=c2bf9c03-a386-4ad2-a49d-2749a633654a duration_ms=94
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=cf6d6c68-1668-4991-ab7b-ae77cc69aa47 duration_ms=98
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=409 request_id=025c3a4d-21c6-48ff-89e6-03e6b8f69f62 duration_ms=99
|
||||
api_test.go:266: created=1 conflict=7
|
||||
api_test.go:270: ✓ UNIQUE username выдержал гонку
|
||||
--- PASS: TestDuplicateUsernameRace (0.12s)
|
||||
=== RUN TestChatCreateRollsBack
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=57132288-7a2a-49e0-91d3-1b3b2ad8ad5b duration_ms=35
|
||||
api_test.go:276: создан roll_user_55538244 id=510834db-6bf3-44ce-9c3e-bc5a3654ffd7
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=2d0bfbec-5b2f-435d-90f4-183fed112d83 duration_ms=30
|
||||
api_test.go:277: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
api_test.go:280: → создание чата с несуществующим участником должно откатиться, title=rollback-2162ebe8-7d02-467d-a256-23b859075201
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats status=400 request_id=21f2b61a-aa7d-4c17-9190-50a2070ca522 duration_ms=5
|
||||
api_test.go:283: status=400 body={"error":{"code":"invalid_request","message":"unknown member","request_id":"21f2b61a-aa7d-4c17-9190-50a2070ca522"}}
|
||||
api_test.go:291: строк chats с этим title после ошибки: 0
|
||||
api_test.go:295: ✓ транзакция создания чата откатилась
|
||||
--- PASS: TestChatCreateRollsBack (0.08s)
|
||||
=== RUN TestPaginationPages
|
||||
api_test.go:301: → три сообщения, две страницы limit=2, затем последняя
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=0a6b83e1-0421-4574-811e-4da75eb44a3f duration_ms=26
|
||||
api_test.go:302: создан page_user_0c9c3ed1 id=687fac60-91d1-42d3-84fc-4a49378c362c
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=646ba194-eeb2-45d8-b535-6afed48abf8d duration_ms=25
|
||||
api_test.go:303: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats status=201 request_id=a3495c84-c564-4d1c-af3b-374ac0c843e7 duration_ms=2
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=201 request_id=4cff46d2-34c6-4473-93f0-7473eaccda7a duration_ms=7
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=201 request_id=54dcd688-e45f-405f-a849-4c9b540c558b duration_ms=2
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=201 request_id=4b4c1969-acd3-4785-b0a3-a7e1fc6f3d9b duration_ms=2
|
||||
2026/11/12 18:06:21 method=GET path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=200 request_id=490be6d4-e04b-49d2-8f10-d45cbbc013df duration_ms=2
|
||||
api_test.go:313: status=200 body={"items":[{"attachment_ids":[],"chat_id":"019d7107-c47f-4cc7-9341-3a71f44a1eac","created_at":"2026-11-12T15:06:21.645Z","id":"6e24502d-79d4-4f6c-be3d-ba3480fb7608","sender_id":"687fac60-91d1-42d3-84fc-4a49378c362c","text":"раз"},{"attachment_ids":[],"chat_id":"019d7107-c47f-4cc7-9341-3a71f44a1eac","created_at":"2026-11-12T15:06:21.649Z","id":"88e5a96b-e468-473a-9c4b-92e6ba4f4329","sender_id":"6...
|
||||
2026/11/12 18:06:21 method=GET path=/api/v1/chats/019d7107-c47f-4cc7-9341-3a71f44a1eac/messages status=200 request_id=1c4e85bf-6325-48e0-81a3-cbd6daeed98b duration_ms=1
|
||||
api_test.go:321: status=200 body={"items":[{"attachment_ids":[],"chat_id":"019d7107-c47f-4cc7-9341-3a71f44a1eac","created_at":"2026-11-12T15:06:21.652Z","id":"0f9e9233-a586-4204-a5d8-71afd9d314be","sender_id":"687fac60-91d1-42d3-84fc-4a49378c362c","text":"три"}],"next_cursor":null}
|
||||
api_test.go:327: ✓ keyset обошёл историю без зависания cursor
|
||||
--- PASS: TestPaginationPages (0.07s)
|
||||
=== RUN TestRedisDownIsNotAnonymous
|
||||
api_test.go:331: → закрытый клиент Redis: вход и Bearer дают 503, а не 200 от анонима
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=beeadeed-af0b-47b4-b0e4-7e6421f1f496 duration_ms=25
|
||||
api_test.go:343: создан redis_down_bef9688c id=89644793-1ece-4a4a-a601-a29a56d1a4d8
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=503 request_id=9762b8fa-434c-445c-823f-0acc5704f4be duration_ms=24
|
||||
api_test.go:347: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"9762b8fa-434c-445c-823f-0acc5704f4be"}}
|
||||
2026/11/12 18:06:21 method=GET path=/api/v1/users/me status=503 request_id=badd3986-bcb8-41c6-a0ba-618ffac05af1 duration_ms=0
|
||||
api_test.go:354: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"badd3986-bcb8-41c6-a0ba-618ffac05af1"}}
|
||||
api_test.go:358: ✓ сбой Redis не стал анонимным доступом
|
||||
--- PASS: TestRedisDownIsNotAnonymous (0.05s)
|
||||
=== RUN TestPostgresDownIsNotAnonymous
|
||||
api_test.go:362: → закрытый пул PostgreSQL: ready/me/login дают 503, без тела пользователя
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=a021c019-6aa8-41ce-a7d5-42b488cb43d9 duration_ms=26
|
||||
api_test.go:365: создан pg_down_2520dcae id=20f9f190-3b5a-4ff7-ae47-2897b7f18ea4
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=fea01055-7d40-4324-9aed-ca5fc456adfd duration_ms=26
|
||||
api_test.go:366: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:21 method=GET path=/health/ready status=503 request_id=32035732-a60e-4d41-b9df-0f94ff733650 duration_ms=0
|
||||
api_test.go:387: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"32035732-a60e-4d41-b9df-0f94ff733650"}}
|
||||
2026/11/12 18:06:21 method=GET path=/api/v1/users/me status=503 request_id=0193b1dd-49dd-4647-9a44-5cdca3091ed0 duration_ms=0
|
||||
api_test.go:394: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"0193b1dd-49dd-4647-9a44-5cdca3091ed0"}}
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=503 request_id=f6fbf5d1-9f1c-452d-951a-3ee09749f6cd duration_ms=0
|
||||
api_test.go:401: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"f6fbf5d1-9f1c-452d-951a-3ee09749f6cd"}}
|
||||
api_test.go:405: ✓ сбой PostgreSQL не стал анонимным доступом
|
||||
--- PASS: TestPostgresDownIsNotAnonymous (0.09s)
|
||||
=== RUN TestIdempotencyReplayAndConflict
|
||||
api_test.go:412: → повтор того же Idempotency-Key возвращает то же сообщение; другой body — 409
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=ba481c3a-d59e-4f1c-b109-273d9cf8f376 duration_ms=27
|
||||
api_test.go:413: создан idem_user_5e962710 id=3b9c80ec-af5b-4fcb-8612-df5adf66e7b0
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=c7504a83-5f6a-40fd-a47a-6f7a5e611f88 duration_ms=25
|
||||
api_test.go:414: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats status=201 request_id=6fecfacf-5cf0-42fc-8ae6-cd3499868da5 duration_ms=2
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/bf42b0ff-2d72-4083-888f-d46b0d4bba6b/messages status=201 request_id=ebb16497-7dc3-4b1d-a352-2ec117b1c588 duration_ms=2
|
||||
api_test.go:422: status=201 body={"attachment_ids":[],"chat_id":"bf42b0ff-2d72-4083-888f-d46b0d4bba6b","created_at":"2026-11-12T15:06:21.861Z","id":"76a0823b-deb0-4087-820f-6d8d5d955062","sender_id":"3b9c80ec-af5b-4fcb-8612-df5adf66e7b0","text":"один раз"}
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/bf42b0ff-2d72-4083-888f-d46b0d4bba6b/messages status=201 request_id=3b737653-a43e-4b6b-901b-80de4724d31b duration_ms=1
|
||||
api_test.go:428: status=201 body={"attachment_ids":[],"chat_id":"bf42b0ff-2d72-4083-888f-d46b0d4bba6b","created_at":"2026-11-12T15:06:21.861Z","id":"76a0823b-deb0-4087-820f-6d8d5d955062","sender_id":"3b9c80ec-af5b-4fcb-8612-df5adf66e7b0","text":"один раз"}
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/bf42b0ff-2d72-4083-888f-d46b0d4bba6b/messages status=409 request_id=5be94615-9308-4e4f-9b02-04ca003f6e16 duration_ms=1
|
||||
api_test.go:437: status=409 body={"error":{"code":"conflict","message":"idempotency key reused with different body","request_id":"5be94615-9308-4e4f-9b02-04ca003f6e16"}}
|
||||
api_test.go:441: ✓ replay и conflict по Idempotency-Key
|
||||
--- PASS: TestIdempotencyReplayAndConflict (0.06s)
|
||||
=== RUN TestIdempotencyKeyRequiredAndConcurrent
|
||||
api_test.go:447: → нет ключа → 400; 8 параллельных POST с одним ключом → ровно одно сообщение
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=2ab93c5e-9ffd-4260-a5dc-b04f6ae5660b duration_ms=25
|
||||
api_test.go:448: создан idem_race_f0f21140 id=53f6a58c-3ce4-410c-bf6d-088084ebf4c2
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/auth/sessions status=201 request_id=45711062-65f8-4aac-8563-4790fdc89a3b duration_ms=25
|
||||
api_test.go:449: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats status=201 request_id=2df6eccd-30af-4e17-80e0-4b52fb771e18 duration_ms=4
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=400 request_id=26e381a2-4bc0-4eee-b668-9816b9ad2839 duration_ms=0
|
||||
api_test.go:467: status=400 body={"error":{"code":"invalid_request","message":"invalid or missing Idempotency-Key","request_id":"26e381a2-4bc0-4eee-b668-9816b9ad2839"}}
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=88713995-6e81-4644-8e0b-7b4c394ca9af duration_ms=7
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=baaee528-b553-4633-b6f4-2f09abb4b01a duration_ms=10
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=e283a5e9-ce51-44b2-9a7c-23edbb41b3ba duration_ms=12
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=68be161c-a944-4b64-ad56-8f14c3068b6e duration_ms=14
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=45041db6-7633-438e-8e6e-3657e6a4a915 duration_ms=16
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=191a3c6d-26ac-4359-88e7-d04bf59e7367 duration_ms=17
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=2c81685c-5ee7-4d2e-81ab-5153014708d3 duration_ms=19
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/chats/041835f4-09c3-49eb-aedb-a561d3ce7e92/messages status=201 request_id=5f23de1d-3352-4864-a40d-fa959abd420e duration_ms=20
|
||||
api_test.go:499: unique message ids=1
|
||||
api_test.go:503: ✓ ключ обязателен; конкурентный повтор не плодит дубли
|
||||
--- PASS: TestIdempotencyKeyRequiredAndConcurrent (0.08s)
|
||||
=== RUN TestInstanceIDHeaderPresent
|
||||
api_test.go:509: → каждый ответ содержит непустой X-Instance-Id
|
||||
api_test.go:511: status=200 body={"status":"ok"}
|
||||
api_test.go:515: ✓ X-Instance-Id=test-instance
|
||||
--- PASS: TestInstanceIDHeaderPresent (0.00s)
|
||||
=== RUN TestAttachmentUploadDownloadAndACL
|
||||
attachments_test.go:38: → upload PNG → 201 ready → download checksum; посторонний — 404
|
||||
2026/11/12 18:06:21 method=POST path=/api/v1/users status=201 request_id=50e4a1af-fd0c-4f79-8dda-70a15bb9acd4 duration_ms=28
|
||||
attachments_test.go:40: создан att_owner_26e19e85 id=2aaf31d8-5457-4aa8-97fd-5e30ab916418
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=c7bf2c56-6b37-46c0-b26a-9fdea9c650c2 duration_ms=27
|
||||
attachments_test.go:41: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/users status=201 request_id=a1edcb49-d0cd-40fa-af3a-0d67d0b2ea8b duration_ms=27
|
||||
attachments_test.go:42: создан att_stranger_bb876443 id=88bd447e-69a4-448f-96d2-f359e2bfdfe3
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=2249a833-a589-425a-aab2-76eb560ae04d duration_ms=27
|
||||
attachments_test.go:43: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats status=201 request_id=f46c6061-855f-4113-afc6-1c5735e5f0d1 duration_ms=5
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/0dacdbe6-5b95-41e8-817d-6b31549a20c9/attachments status=201 request_id=c74261b2-25cc-4995-a15e-8dff9f19f456 duration_ms=3
|
||||
2026/11/12 18:06:22 method=GET path=/api/v1/attachments/867bc3f8-3656-4138-a787-b5fc8fc85498 status=200 request_id=210ea277-a957-43d8-a45b-529cafc1ecd0 duration_ms=1
|
||||
attachments_test.go:50: status=200 body={"chat_id":"0dacdbe6-5b95-41e8-817d-6b31549a20c9","content_type":"image/png","created_at":"2026-11-12T15:06:22.067Z","error_code":null,"filename":"pic.png","id":"867bc3f8-3656-4138-a787-b5fc8fc85498","owner_id":"2aaf31d8-5457-4aa8-97fd-5e30ab916418","sha256":"2e9b06dc65a4dec84a3eb3124553ec93ca27c78221e64ab2177d0f1412cfcb20","size_bytes":69,"status":"ready","updated_at":"2026-11-12T15:06:22.067Z","...
|
||||
2026/11/12 18:06:22 method=GET path=/api/v1/attachments/867bc3f8-3656-4138-a787-b5fc8fc85498/content status=200 request_id=d52949e3-d49d-4cc6-a0ae-d406e07a4db1 duration_ms=0
|
||||
2026/11/12 18:06:22 method=GET path=/api/v1/attachments/867bc3f8-3656-4138-a787-b5fc8fc85498 status=404 request_id=1e7cf8e4-64dd-4542-a225-01ae04bbd5ae duration_ms=0
|
||||
attachments_test.go:74: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"1e7cf8e4-64dd-4542-a225-01ae04bbd5ae"}}
|
||||
2026/11/12 18:06:22 method=GET path=/api/v1/attachments/867bc3f8-3656-4138-a787-b5fc8fc85498/content status=404 request_id=51e58b03-52c7-4ad1-b15f-56a49c443ec1 duration_ms=0
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/0dacdbe6-5b95-41e8-817d-6b31549a20c9/messages status=201 request_id=ae5b57bc-14b1-4d8a-a40d-a71cb4f71935 duration_ms=5
|
||||
attachments_test.go:86: status=201 body={"attachment_ids":["867bc3f8-3656-4138-a787-b5fc8fc85498"],"chat_id":"0dacdbe6-5b95-41e8-817d-6b31549a20c9","created_at":"2026-11-12T15:06:22.074Z","id":"0ea80b9c-c870-4e74-a23a-2a3b804970af","sender_id":"2aaf31d8-5457-4aa8-97fd-5e30ab916418","text":"с файлом"}
|
||||
attachments_test.go:95: ✓ upload/download/ACL и message.attachment_ids
|
||||
--- PASS: TestAttachmentUploadDownloadAndACL (0.13s)
|
||||
=== RUN TestAttachmentRejectsBadInput
|
||||
attachments_test.go:102: → битый PNG, подмена MIME, опасный filename, чужой чат → 4xx не 500
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/users status=201 request_id=4c3e8cba-a49e-417b-8a4d-da66dc3cdf18 duration_ms=28
|
||||
attachments_test.go:104: создан att_bad_21539b6c id=f5e5ea5c-5c89-4aba-8393-1d418136d0d7
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=db8cea49-9800-450d-8c80-cd85f21fef4c duration_ms=27
|
||||
attachments_test.go:105: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats status=201 request_id=c37b00b8-95e8-466b-b0bb-c90397b4913c duration_ms=5
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/attachments status=400 request_id=791df656-1869-4832-8e16-d145f3e12568 duration_ms=1
|
||||
attachments_test.go:109: status=400 body={"error":{"code":"invalid_request","message":"invalid filename","request_id":"791df656-1869-4832-8e16-d145f3e12568"}}
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/attachments status=415 request_id=f8d9fdcc-524a-4c81-a08d-b72803745bdc duration_ms=3
|
||||
attachments_test.go:115: status=415 body={"error":{"code":"unsupported_media_type","message":"invalid or unsupported image","request_id":"f8d9fdcc-524a-4c81-a08d-b72803745bdc"}}
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/attachments status=415 request_id=6da7b2bc-c552-4885-bd4c-dd888b3a6a4b duration_ms=1
|
||||
attachments_test.go:121: status=415 body={"error":{"code":"unsupported_media_type","message":"invalid or unsupported image","request_id":"6da7b2bc-c552-4885-bd4c-dd888b3a6a4b"}}
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/attachments status=413 request_id=55dfe90c-9de2-4a34-942d-5e29abb6a181 duration_ms=1
|
||||
attachments_test.go:138: status=413 body={"error":{"code":"payload_too_large","message":"file is too large","request_id":"55dfe90c-9de2-4a34-942d-5e29abb6a181"}}
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/users status=201 request_id=c4d7a58a-254b-49c8-954d-f69c37badb7b duration_ms=28
|
||||
attachments_test.go:143: создан att_other_f29f128d id=3186c693-b42d-4040-82b2-aa46cdf35c10
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=17898378-42f5-4bac-a69e-d3673070bc82 duration_ms=28
|
||||
attachments_test.go:144: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats status=201 request_id=106a6135-6033-49d0-a3af-cdffa50138f3 duration_ms=2
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/48d9e9da-2e02-4663-941b-b1e8fe8f587a/attachments status=404 request_id=a1749a57-1189-4505-b6c7-26726bab488b duration_ms=0
|
||||
attachments_test.go:147: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"a1749a57-1189-4505-b6c7-26726bab488b"}}
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/48d9e9da-2e02-4663-941b-b1e8fe8f587a/attachments status=201 request_id=75b83de8-96a1-4b6d-88f3-8c47d1d337d8 duration_ms=1
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/b88e5748-ce97-4b19-a045-fe10fbf88af3/messages status=404 request_id=9202daed-c840-4dad-aaad-57c641b5b60e duration_ms=1
|
||||
attachments_test.go:156: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"9202daed-c840-4dad-aaad-57c641b5b60e"}}
|
||||
attachments_test.go:160: ✓ негативные сценарии вложений → клиентские 4xx
|
||||
--- PASS: TestAttachmentRejectsBadInput (0.14s)
|
||||
=== RUN TestAttachmentS3DownIs503
|
||||
attachments_test.go:168: → S3 недоступен: ready и upload → 503
|
||||
2026/11/12 18:06:22 method=GET path=/health/ready status=503 request_id=3d89fdba-9a9c-4584-a4c6-3f80db705e0a duration_ms=0
|
||||
attachments_test.go:171: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"3d89fdba-9a9c-4584-a4c6-3f80db705e0a"}}
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/users status=201 request_id=4e83fd55-0b6c-4d86-9af6-f2fa3c2bdbf2 duration_ms=25
|
||||
attachments_test.go:176: создан s3_down_e2a7e91a id=54340923-2d7d-4a06-b2e2-ffaa7d8740bd
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/auth/sessions status=201 request_id=0e4ab943-38bb-4a14-a97f-63fbb3290957 duration_ms=25
|
||||
attachments_test.go:177: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats status=201 request_id=71b90d66-3e07-4558-b3a8-9e7b53dd2692 duration_ms=3
|
||||
2026/11/12 18:06:22 request_id=f6f288b3-755c-458e-8d82-ab72fafb64f8 s3_unavailable
|
||||
2026/11/12 18:06:22 method=POST path=/api/v1/chats/83ee260c-6369-47be-a18e-7fc24884dc4e/attachments status=503 request_id=f6f288b3-755c-458e-8d82-ab72fafb64f8 duration_ms=1
|
||||
attachments_test.go:180: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"f6f288b3-755c-458e-8d82-ab72fafb64f8"}}
|
||||
attachments_test.go:184: ✓ падение S3 → 503
|
||||
--- PASS: TestAttachmentS3DownIs503 (0.06s)
|
||||
PASS
|
||||
ok mtusi2026lab4/student-tests 4.450s
|
||||
@@ -0,0 +1,54 @@
|
||||
module mtusi2026lab4
|
||||
|
||||
go 1.24.0
|
||||
|
||||
require (
|
||||
github.com/google/uuid v1.6.0
|
||||
github.com/jackc/pgx/v5 v5.7.4
|
||||
github.com/minio/madmin-go/v3 v3.0.107
|
||||
github.com/minio/minio-go/v7 v7.0.90
|
||||
github.com/redis/go-redis/v9 v9.7.3
|
||||
golang.org/x/crypto v0.37.0
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/cespare/xxhash/v2 v2.3.0 // indirect
|
||||
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
|
||||
github.com/dustin/go-humanize v1.0.1 // indirect
|
||||
github.com/go-ini/ini v1.67.0 // indirect
|
||||
github.com/go-ole/go-ole v1.3.0 // indirect
|
||||
github.com/goccy/go-json v0.10.5 // indirect
|
||||
github.com/golang-jwt/jwt/v4 v4.5.2 // indirect
|
||||
github.com/golang/protobuf v1.5.4 // indirect
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.2 // indirect
|
||||
github.com/klauspost/compress v1.18.0 // indirect
|
||||
github.com/klauspost/cpuid/v2 v2.2.10 // indirect
|
||||
github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // indirect
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
|
||||
github.com/minio/crc64nvme v1.0.1 // indirect
|
||||
github.com/minio/md5-simd v1.1.2 // indirect
|
||||
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
|
||||
github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect
|
||||
github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
|
||||
github.com/prometheus/client_model v0.6.2 // indirect
|
||||
github.com/prometheus/common v0.63.0 // indirect
|
||||
github.com/prometheus/procfs v0.16.0 // indirect
|
||||
github.com/prometheus/prom2json v1.4.2 // indirect
|
||||
github.com/prometheus/prometheus v0.303.0 // indirect
|
||||
github.com/rs/xid v1.6.0 // indirect
|
||||
github.com/safchain/ethtool v0.5.10 // indirect
|
||||
github.com/secure-io/sio-go v0.3.1 // indirect
|
||||
github.com/shirou/gopsutil/v3 v3.24.5 // indirect
|
||||
github.com/shoenig/go-m1cpu v0.1.6 // indirect
|
||||
github.com/tinylib/msgp v1.2.5 // indirect
|
||||
github.com/tklauser/go-sysconf v0.3.15 // indirect
|
||||
github.com/tklauser/numcpus v0.10.0 // indirect
|
||||
github.com/yusufpapurcu/wmi v1.2.4 // indirect
|
||||
golang.org/x/net v0.39.0 // indirect
|
||||
golang.org/x/sync v0.13.0 // indirect
|
||||
golang.org/x/sys v0.32.0 // indirect
|
||||
golang.org/x/text v0.24.0 // indirect
|
||||
google.golang.org/protobuf v1.36.6 // indirect
|
||||
)
|
||||
@@ -0,0 +1,128 @@
|
||||
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
|
||||
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
|
||||
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
|
||||
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
|
||||
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
|
||||
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
|
||||
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
|
||||
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
|
||||
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
|
||||
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
|
||||
github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
|
||||
github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
|
||||
github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
|
||||
github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
|
||||
github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
|
||||
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
|
||||
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
|
||||
github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI=
|
||||
github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
|
||||
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
|
||||
github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
|
||||
github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
|
||||
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
|
||||
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
|
||||
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
|
||||
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
|
||||
github.com/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.4 h1:9wKznZrhWa2QiHL+NjTSPP6yjl3451BX3imWDnokYlg=
|
||||
github.com/jackc/pgx/v5 v5.7.4/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
|
||||
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
|
||||
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
|
||||
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
|
||||
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
|
||||
github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
|
||||
github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
|
||||
github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 h1:PpXWgLPs+Fqr325bN2FD2ISlRRztXibcX6e8f5FR5Dc=
|
||||
github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
|
||||
github.com/minio/crc64nvme v1.0.1 h1:DHQPrYPdqK7jQG/Ls5CTBZWeex/2FMS3G5XGkycuFrY=
|
||||
github.com/minio/crc64nvme v1.0.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg=
|
||||
github.com/minio/madmin-go/v3 v3.0.107 h1:MZNlPmJWsbxIvgIACSxmMq4T3PXK9/wil3pMSaTz5HI=
|
||||
github.com/minio/madmin-go/v3 v3.0.107/go.mod h1:WOe2kYmYl1OIlY2DSRHVQ8j1v4OItARQ6jGyQqcCud8=
|
||||
github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
|
||||
github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
|
||||
github.com/minio/minio-go/v7 v7.0.90 h1:TmSj1083wtAD0kEYTx7a5pFsv3iRYMsOJ6A4crjA1lE=
|
||||
github.com/minio/minio-go/v7 v7.0.90/go.mod h1:uvMUcGrpgeSAAI6+sD3818508nUyMULw94j2Nxku/Go=
|
||||
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
|
||||
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
|
||||
github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY=
|
||||
github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
|
||||
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU=
|
||||
github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
|
||||
github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
|
||||
github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
|
||||
github.com/prometheus/common v0.63.0 h1:YR/EIY1o3mEFP/kZCD7iDMnLPlGyuU2Gb3HIcXnA98k=
|
||||
github.com/prometheus/common v0.63.0/go.mod h1:VVFF/fBIoToEnWRVkYoXEkq3R3paCoxG9PXP74SnV18=
|
||||
github.com/prometheus/procfs v0.16.0 h1:xh6oHhKwnOJKMYiYBDWmkHqQPyiY40sny36Cmx2bbsM=
|
||||
github.com/prometheus/procfs v0.16.0/go.mod h1:8veyXUu3nGP7oaCxhX6yeaM5u4stL2FeMXnCqhDthZg=
|
||||
github.com/prometheus/prom2json v1.4.2 h1:PxCTM+Whqi/eykO1MKsEL0p/zMpxp9ybpsmdFamw6po=
|
||||
github.com/prometheus/prom2json v1.4.2/go.mod h1:zuvPm7u3epZSbXPWHny6G+o8ETgu6eAK3oPr6yFkRWE=
|
||||
github.com/prometheus/prometheus v0.303.0 h1:wsNNsbd4EycMCphYnTmNY9JASBVbp7NWwJna857cGpA=
|
||||
github.com/prometheus/prometheus v0.303.0/go.mod h1:8PMRi+Fk1WzopMDeb0/6hbNs9nV6zgySkU/zds5Lu3o=
|
||||
github.com/redis/go-redis/v9 v9.7.3 h1:YpPyAayJV+XErNsatSElgRZZVCwXX9QzkKYNvO7x0wM=
|
||||
github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA=
|
||||
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
|
||||
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
|
||||
github.com/safchain/ethtool v0.5.10 h1:Im294gZtuf4pSGJRAOGKaASNi3wMeFaGaWuSaomedpc=
|
||||
github.com/safchain/ethtool v0.5.10/go.mod h1:w9jh2Lx7YBR4UwzLkzCmWl85UY0W2uZdd7/DckVE5+c=
|
||||
github.com/secure-io/sio-go v0.3.1 h1:dNvY9awjabXTYGsTF1PiCySl9Ltofk9GA3VdWlo7rRc=
|
||||
github.com/secure-io/sio-go v0.3.1/go.mod h1:+xbkjDzPjwh4Axd07pRKSNriS9SCiYksWnZqdnfpQxs=
|
||||
github.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI=
|
||||
github.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk=
|
||||
github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
|
||||
github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
|
||||
github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU=
|
||||
github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
|
||||
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
|
||||
github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po=
|
||||
github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0=
|
||||
github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
|
||||
github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
|
||||
github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
|
||||
github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
|
||||
github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
|
||||
github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
|
||||
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
|
||||
golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
|
||||
golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
|
||||
golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
|
||||
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
|
||||
golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
|
||||
golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
|
||||
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
|
||||
golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
|
||||
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
|
||||
golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
|
||||
golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
|
||||
google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
|
||||
google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
+7
-6
@@ -1,7 +1,8 @@
|
||||
# Инфраструктура студента
|
||||
# Инфраструктура lab4
|
||||
|
||||
Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли.
|
||||
|
||||
В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд.
|
||||
|
||||
Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику.
|
||||
- `haproxy/haproxy.cfg` — LB перед API-репликами (lab3).
|
||||
- MinIO: образ `ghcr.io/coollabsio/minio:RELEASE.2025-10-15T17-29-55Z` (официальные
|
||||
`minio/minio` с Docker Hub сняты в 2026; community-сборка того же RELEASE).
|
||||
- Bootstrap bucket/app-user: бинарь `/s3bootstrap` в образе API (minio-go + madmin),
|
||||
без зависимости от снятого `minio/mc`. Политика — только List/Get/Put/Delete на
|
||||
`messenger-attachments`. Консоль MinIO (`:9001`) **не публикуется**.
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
# HAProxy — единственная публичная точка входа lab3.
|
||||
#
|
||||
# Backend-адреса берутся из Docker DNS имени сервиса `api` (A-записи всех реплик).
|
||||
# server-template + resolvers перечитывает DNS; option httpchk снимает реплику,
|
||||
# у которой /health/ready != 200 (в т.ч. после BeginDrain на SIGTERM).
|
||||
#
|
||||
# Оценка обнаружения отказа:
|
||||
# inter 1s * fall 2 = ~2s по healthcheck + hold valid 2s у DNS ≈ до ~4s.
|
||||
# Краткие 502/503 в это окно допустимы контрактом failover-теста.
|
||||
|
||||
global
|
||||
log stdout format raw local0
|
||||
maxconn 512
|
||||
|
||||
defaults
|
||||
log global
|
||||
mode http
|
||||
option httplog
|
||||
option dontlognull
|
||||
timeout connect 2s
|
||||
timeout client 15s
|
||||
timeout server 15s
|
||||
timeout check 1s
|
||||
timeout http-keep-alive 10s
|
||||
retries 2
|
||||
|
||||
resolvers docker
|
||||
nameserver dns 127.0.0.11:53
|
||||
resolve_retries 3
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
hold valid 2s
|
||||
hold other 2s
|
||||
hold refused 2s
|
||||
hold nx 2s
|
||||
hold timeout 2s
|
||||
hold obsolete 2s
|
||||
|
||||
frontend fe_http
|
||||
bind *:8080
|
||||
default_backend be_api
|
||||
|
||||
backend be_api
|
||||
balance roundrobin
|
||||
option httpchk
|
||||
option redispatch
|
||||
retry-on conn-failure empty-response response-timeout
|
||||
http-check send meth GET uri /health/ready
|
||||
http-check expect status 200
|
||||
# До 8 слотов под --scale api=N. init-addr last,libc,none ждёт DNS при старте.
|
||||
# fall 3: чуть терпимее к краткому DNS-мерцанию при docker stop одной реплики.
|
||||
server-template api 8 api:8080 check inter 1s fall 3 rise 1 resolvers docker resolve-prefer ipv4 init-addr last,libc,none
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"Version": "2012-10-17",
|
||||
"Statement": [
|
||||
{
|
||||
"Sid": "ListBucket",
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:ListBucket"],
|
||||
"Resource": ["arn:aws:s3:::messenger-attachments"]
|
||||
},
|
||||
{
|
||||
"Sid": "ObjectRW",
|
||||
"Effect": "Allow",
|
||||
"Action": ["s3:GetObject", "s3:PutObject", "s3:DeleteObject"],
|
||||
"Resource": ["arn:aws:s3:::messenger-attachments/*"]
|
||||
}
|
||||
]
|
||||
}
|
||||
Executable
+32
@@ -0,0 +1,32 @@
|
||||
#!/bin/sh
|
||||
# Идемпотентный bootstrap приватного bucket и app-пользователя с ограниченной политикой.
|
||||
# Root-ключи только здесь; API работает от S3_ACCESS_KEY_ID / S3_SECRET_ACCESS_KEY.
|
||||
set -eu
|
||||
|
||||
echo "waiting for minio..."
|
||||
i=0
|
||||
until mc alias set local "http://${MINIO_ENDPOINT}" "${MINIO_ROOT_USER}" "${MINIO_ROOT_PASSWORD}" >/dev/null 2>&1; do
|
||||
i=$((i + 1))
|
||||
if [ "$i" -gt 60 ]; then
|
||||
echo "minio not ready" >&2
|
||||
exit 1
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
|
||||
mc mb -p "local/${S3_BUCKET}" || true
|
||||
mc anonymous set none "local/${S3_BUCKET}"
|
||||
|
||||
# Пользователь приложения: повторный add не обязан быть успешен.
|
||||
if ! mc admin user info local "${S3_ACCESS_KEY_ID}" >/dev/null 2>&1; then
|
||||
mc admin user add local "${S3_ACCESS_KEY_ID}" "${S3_SECRET_ACCESS_KEY}"
|
||||
fi
|
||||
# Политика: create падает, если уже есть — это ок.
|
||||
mc admin policy create local app-attachments /policy.json 2>/dev/null || \
|
||||
mc admin policy add local app-attachments /policy.json 2>/dev/null || true
|
||||
mc admin policy attach local app-attachments --user "${S3_ACCESS_KEY_ID}" 2>/dev/null || \
|
||||
mc admin policy set local app-attachments user="${S3_ACCESS_KEY_ID}" 2>/dev/null || true
|
||||
|
||||
echo "bucket=${S3_BUCKET} private=yes app_user=${S3_ACCESS_KEY_ID}"
|
||||
mc anonymous get "local/${S3_BUCKET}" || true
|
||||
echo "bootstrap done"
|
||||
@@ -0,0 +1,448 @@
|
||||
package api
|
||||
|
||||
// Вложения lab4: загрузка, метаданные, скачивание.
|
||||
//
|
||||
// Загрузка (POST /chats/{id}/attachments?filename=...) идёт строго по шагам, и каждый шаг
|
||||
// отсекает запрос как можно раньше и дешевле:
|
||||
//
|
||||
// 1. Bearer-аутентификация (requireUser), затем членство в чате: посторонний получает 404;
|
||||
// 2. filename: 1–255 code points, без «/», «\», NUL и управляющих символов — иначе 400;
|
||||
// 3. заявленный Content-Type — только image/png или image/jpeg, иначе 415;
|
||||
// 4. тело копируется в спул (временный файл, при его отказе — память) с одновременным SHA-256
|
||||
// и жёстким лимитом MaxUploadBytes+1: больше лимита — 413. Тело не буферизуется целиком
|
||||
// в куче через ReadAll, поэтому пик RAM на загрузку — буфер копирования, а не размер файла;
|
||||
// 5. тип по содержимому (http.DetectContentType) обязан совпасть с заявленным, иначе 415 (подмена MIME);
|
||||
// 6. размеры берутся из заголовка PNG/JPEG БЕЗ декодирования пикселей; больше
|
||||
// MaxImagePixels — 413. Это делается до любой «распаковки»: bomb 60000×60000 весит килобайты;
|
||||
// 7. дешёвая структурная проверка (PNG: CRC всех чанков и IEND, JPEG: EOI) ловит обрезанные
|
||||
// и повреждённые файлы — 415;
|
||||
// 8. PUT в S3 по серверному ключу originals/<uuid>, затем INSERT метаданных. Только после
|
||||
// обоих шагов — 201. Если INSERT не удался, объект удаляется сразу, а при отказе удаления
|
||||
// его подберёт reconciler (cmd/reconcile) после grace period.
|
||||
//
|
||||
// До шага 8 в S3 ничего не пишется, поэтому оборванная загрузка клиента не оставляет объектов.
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/binary"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"hash/crc32"
|
||||
"image"
|
||||
_ "image/jpeg" // регистрирует декодер JPEG для image.DecodeConfig
|
||||
"io"
|
||||
"log"
|
||||
"mime"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026lab4/internal/blob"
|
||||
"mtusi2026lab4/internal/store"
|
||||
)
|
||||
|
||||
const (
|
||||
maxMessageAttachments = 10
|
||||
maxFilenameRunes = 255
|
||||
// После превышения лимита дочитываем (и выбрасываем) не больше этого объёма:
|
||||
// клиент успевает получить 413, а не «connection reset» посреди своей отправки.
|
||||
drainOnOverflow = 64 << 20
|
||||
)
|
||||
|
||||
var (
|
||||
errBadImage = errors.New("not a valid png/jpeg image")
|
||||
errTooManyPixels = errors.New("image has too many pixels")
|
||||
errTooLarge = errors.New("upload exceeds size limit")
|
||||
)
|
||||
|
||||
func (s *Server) handleUploadAttachment(w http.ResponseWriter, r *http.Request) {
|
||||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||||
return
|
||||
}
|
||||
uid := userFrom(r)
|
||||
if err := s.Store.EnsureChatMember(r.Context(), chatID, uid); err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
|
||||
filename := r.URL.Query().Get("filename")
|
||||
if !validFilename(filename) {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid filename")
|
||||
return
|
||||
}
|
||||
declared, ok := declaredImageType(r.Header.Get("Content-Type"))
|
||||
if !ok {
|
||||
writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "only image/png and image/jpeg are accepted")
|
||||
return
|
||||
}
|
||||
// Клиент заранее заявил размер сильно больше лимита — не читаем ни байта.
|
||||
if r.ContentLength > s.MaxUploadBytes+drainOnOverflow {
|
||||
writeError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "file is too large")
|
||||
return
|
||||
}
|
||||
|
||||
sp, err := spoolBody(r.Body, s.MaxUploadBytes)
|
||||
if err != nil {
|
||||
switch {
|
||||
case errors.Is(err, errTooLarge):
|
||||
writeError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "file is too large")
|
||||
default:
|
||||
// Обрыв чтения тела или таймаут клиента. Ничего не записано ни в S3, ни в БД.
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "could not read request body")
|
||||
}
|
||||
return
|
||||
}
|
||||
defer sp.Close()
|
||||
|
||||
if err := inspectImage(sp.reader(), sp.size, declared, s.MaxImagePixels); err != nil {
|
||||
switch {
|
||||
case errors.Is(err, errTooManyPixels):
|
||||
writeError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "image has too many pixels")
|
||||
default:
|
||||
writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "invalid or unsupported image")
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
id := uuid.New()
|
||||
att := &store.Attachment{
|
||||
ID: id,
|
||||
ChatID: chatID,
|
||||
OwnerID: uid,
|
||||
Filename: filename,
|
||||
ContentType: declared,
|
||||
SizeBytes: sp.size,
|
||||
SHA256: sp.sum,
|
||||
ObjectKey: blob.KeyPrefix + id.String(),
|
||||
}
|
||||
|
||||
// 1) S3. Тело отдаём как ReadSeeker: minio-go шлёт один PUT без буферизации в памяти.
|
||||
if err := s.Blob.Put(r.Context(), att.ObjectKey, sp.reader(), sp.size, declared); err != nil {
|
||||
s.writeBlobErr(w, r, err)
|
||||
return
|
||||
}
|
||||
// 2) PostgreSQL. Ошибка здесь оставила бы объект без строки — убираем его сразу.
|
||||
if err := s.Store.CreateAttachment(r.Context(), att); err != nil {
|
||||
s.compensateOrphan(r, att.ObjectKey)
|
||||
s.writeStoreErr(w, r, err, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, attachmentDTO(att))
|
||||
}
|
||||
|
||||
// compensateOrphan удаляет объект, для которого не удалось записать метаданные.
|
||||
// Контекст отвязан от запроса: клиент мог отключиться, а чистить всё равно нужно.
|
||||
// Если и удаление не удалось (S3 мигнул), объект останется до reconciler — это допустимо.
|
||||
func (s *Server) compensateOrphan(r *http.Request, key string) {
|
||||
ctx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), 5*time.Second)
|
||||
defer cancel()
|
||||
if err := s.Blob.Delete(ctx, key); err != nil {
|
||||
log.Printf("request_id=%s orphan_cleanup_failed key=%s (reconciler will remove after grace)", requestID(r), key)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Server) handleGetAttachment(w http.ResponseWriter, r *http.Request) {
|
||||
att, ok := s.loadAttachment(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, attachmentDTO(att))
|
||||
}
|
||||
|
||||
// handleDownloadAttachment отдаёт оригинал побайтно через API, без редиректа на S3:
|
||||
// приватный bucket сам по себе не заменяет проверку членства в чате.
|
||||
func (s *Server) handleDownloadAttachment(w http.ResponseWriter, r *http.Request) {
|
||||
att, ok := s.loadAttachment(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
// variant по умолчанию original. В lab4 вариантов нет (variants=[]), значит любой
|
||||
// другой — «отсутствующий вариант ready-объекта», то есть 404.
|
||||
if v := r.URL.Query().Get("variant"); v != "" && v != "original" {
|
||||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
switch att.Status {
|
||||
case "ready":
|
||||
default:
|
||||
writeError(w, r, http.StatusConflict, "conflict", "attachment is not ready")
|
||||
return
|
||||
}
|
||||
rc, err := s.Blob.Get(r.Context(), att.ObjectKey)
|
||||
if err != nil {
|
||||
if errors.Is(err, blob.ErrNotFound) {
|
||||
// Строка есть, объекта нет — несогласованность, её чинит reconciler.
|
||||
log.Printf("request_id=%s attachment_object_missing id=%s", requestID(r), att.ID)
|
||||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
s.writeBlobErr(w, r, err)
|
||||
return
|
||||
}
|
||||
defer rc.Close()
|
||||
h := w.Header()
|
||||
h.Set("Content-Type", att.ContentType)
|
||||
h.Set("Content-Length", strconv.FormatInt(att.SizeBytes, 10))
|
||||
h.Set("X-Content-Type-Options", "nosniff")
|
||||
h.Set("Cache-Control", "private, no-store")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
if _, err := io.Copy(w, rc); err != nil {
|
||||
// Заголовки уже ушли; клиент увидит обрыв. В лог — без деталей S3.
|
||||
log.Printf("request_id=%s attachment_stream_error id=%s", requestID(r), att.ID)
|
||||
}
|
||||
}
|
||||
|
||||
// loadAttachment разбирает {attachment_id} и проверяет членство в чате вложения.
|
||||
func (s *Server) loadAttachment(w http.ResponseWriter, r *http.Request) (*store.Attachment, bool) {
|
||||
id, err := uuid.Parse(r.PathValue("attachment_id"))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id")
|
||||
return nil, false
|
||||
}
|
||||
att, err := s.Store.GetAttachment(r.Context(), id, userFrom(r))
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusNotFound, "not_found", "object not found")
|
||||
return nil, false
|
||||
}
|
||||
return att, true
|
||||
}
|
||||
|
||||
// writeBlobErr: недоступный S3 — 503, остальное — 500. Текст ошибки клиенту не уходит.
|
||||
func (s *Server) writeBlobErr(w http.ResponseWriter, r *http.Request, err error) {
|
||||
if errors.Is(err, blob.ErrUnavailable) {
|
||||
log.Printf("request_id=%s s3_unavailable", requestID(r))
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
log.Printf("request_id=%s blob_error_type=%T", requestID(r), err)
|
||||
writeError(w, r, http.StatusInternalServerError, "internal_error", "internal error")
|
||||
}
|
||||
|
||||
func attachmentDTO(a *store.Attachment) map[string]any {
|
||||
var errCode any
|
||||
if a.ErrorCode != nil {
|
||||
errCode = *a.ErrorCode
|
||||
}
|
||||
return map[string]any{
|
||||
"id": a.ID.String(),
|
||||
"chat_id": a.ChatID.String(),
|
||||
"owner_id": a.OwnerID.String(),
|
||||
"filename": a.Filename,
|
||||
"content_type": a.ContentType,
|
||||
"size_bytes": a.SizeBytes,
|
||||
"sha256": a.SHA256,
|
||||
"status": a.Status,
|
||||
"variants": []any{},
|
||||
"error_code": errCode,
|
||||
"created_at": formatTime(a.CreatedAt),
|
||||
"updated_at": formatTime(a.UpdatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
// validFilename: 1–255 code points, валидный UTF-8, не «пустой» после TrimSpace.
|
||||
// «/», «\», NUL и управляющие символы запрещены: имя только отображается и никогда не
|
||||
// становится путём или ключом S3. «.» и «..» отвергаются как заведомо опасные.
|
||||
func validFilename(name string) bool {
|
||||
if !utf8.ValidString(name) || strings.TrimSpace(name) == "" {
|
||||
return false
|
||||
}
|
||||
if n := utf8.RuneCountInString(name); n < 1 || n > maxFilenameRunes {
|
||||
return false
|
||||
}
|
||||
if name == "." || name == ".." {
|
||||
return false
|
||||
}
|
||||
for _, c := range name {
|
||||
if c == '/' || c == '\\' || c == 0 || unicode.IsControl(c) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// declaredImageType возвращает заявленный Content-Type без параметров, если он разрешён.
|
||||
func declaredImageType(header string) (string, bool) {
|
||||
mt, _, err := mime.ParseMediaType(header)
|
||||
if err != nil {
|
||||
return "", false
|
||||
}
|
||||
switch mt {
|
||||
case "image/png", "image/jpeg":
|
||||
return mt, true
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
|
||||
// spooled — принятое тело: размер, SHA-256 и произвольный доступ для проверок и PUT.
|
||||
type spooled struct {
|
||||
ra io.ReaderAt
|
||||
size int64
|
||||
sum string
|
||||
cleanup func()
|
||||
}
|
||||
|
||||
func (s *spooled) reader() *io.SectionReader { return io.NewSectionReader(s.ra, 0, s.size) }
|
||||
func (s *spooled) Close() { s.cleanup() }
|
||||
|
||||
// spoolBody читает тело не больше max байт. Временный файл защищает кучу от 10 одновременных
|
||||
// загрузок по 10 MiB; если /tmp недоступен, откатываемся на память (всё равно ограниченную max).
|
||||
func spoolBody(body io.Reader, max int64) (*spooled, error) {
|
||||
h := sha256.New()
|
||||
f, ferr := os.CreateTemp("", "upload-*")
|
||||
var (
|
||||
dst io.Writer
|
||||
buf *bytes.Buffer
|
||||
cleanup = func() {}
|
||||
)
|
||||
if ferr == nil {
|
||||
cleanup = func() { _ = f.Close(); _ = os.Remove(f.Name()) }
|
||||
dst = io.MultiWriter(f, h)
|
||||
} else {
|
||||
buf = &bytes.Buffer{}
|
||||
dst = io.MultiWriter(buf, h)
|
||||
}
|
||||
n, err := io.Copy(dst, io.LimitReader(body, max+1))
|
||||
if err != nil {
|
||||
cleanup()
|
||||
return nil, err
|
||||
}
|
||||
if n > max {
|
||||
cleanup()
|
||||
_, _ = io.CopyN(io.Discard, body, drainOnOverflow)
|
||||
return nil, errTooLarge
|
||||
}
|
||||
sp := &spooled{size: n, sum: hex.EncodeToString(h.Sum(nil)), cleanup: cleanup}
|
||||
if f != nil && ferr == nil {
|
||||
sp.ra = f
|
||||
} else {
|
||||
sp.ra = bytes.NewReader(buf.Bytes())
|
||||
}
|
||||
return sp, nil
|
||||
}
|
||||
|
||||
// inspectImage проверяет содержимое. Порядок важен: тип → размеры из заголовка (лимит
|
||||
// пикселей до любой распаковки) → структура файла.
|
||||
func inspectImage(sr *io.SectionReader, size int64, declared string, maxPixels int64) error {
|
||||
head := make([]byte, 512)
|
||||
n, _ := sr.ReadAt(head, 0)
|
||||
detected := ""
|
||||
if n > 0 {
|
||||
detected = http.DetectContentType(head[:n])
|
||||
}
|
||||
if size < 1 || (detected != "image/png" && detected != "image/jpeg") || detected != declared {
|
||||
return errBadImage
|
||||
}
|
||||
|
||||
var w, h int64
|
||||
switch detected {
|
||||
case "image/png":
|
||||
// IHDR всегда первый чанк: 8 байт сигнатуры, 4 длина, 4 тип, затем width/height.
|
||||
// Читаем сами: image/png.DecodeConfig отвергает файл с битым CRC раньше, чем
|
||||
// мы успели бы честно ответить «слишком много пикселей».
|
||||
if n < 24 || string(head[12:16]) != "IHDR" || binary.BigEndian.Uint32(head[8:12]) != 13 {
|
||||
return errBadImage
|
||||
}
|
||||
w = int64(binary.BigEndian.Uint32(head[16:20]))
|
||||
h = int64(binary.BigEndian.Uint32(head[20:24]))
|
||||
case "image/jpeg":
|
||||
cfg, _, err := image.DecodeConfig(io.NewSectionReader(sr, 0, size))
|
||||
if err != nil {
|
||||
return errBadImage
|
||||
}
|
||||
w, h = int64(cfg.Width), int64(cfg.Height)
|
||||
}
|
||||
if w < 1 || h < 1 {
|
||||
return errBadImage
|
||||
}
|
||||
if w*h > maxPixels {
|
||||
return errTooManyPixels
|
||||
}
|
||||
|
||||
if detected == "image/png" {
|
||||
return verifyPNG(io.NewSectionReader(sr, 0, size), size)
|
||||
}
|
||||
return verifyJPEGTail(sr, size)
|
||||
}
|
||||
|
||||
// verifyPNG обходит чанки и проверяет их CRC без декомпрессии IDAT: обрезанный или
|
||||
// испорченный PNG отвергается за один линейный проход по файлу.
|
||||
func verifyPNG(r io.Reader, size int64) error {
|
||||
br := bufio.NewReaderSize(r, 64<<10)
|
||||
if _, err := br.Discard(8); err != nil { // сигнатура уже проверена DetectContentType
|
||||
return errBadImage
|
||||
}
|
||||
consumed := int64(8)
|
||||
var (
|
||||
hdr [8]byte
|
||||
crcBuf [4]byte
|
||||
first = true
|
||||
sawIDAT bool
|
||||
sawIEND bool
|
||||
crcHasher = crc32.NewIEEE()
|
||||
)
|
||||
for !sawIEND {
|
||||
if _, err := io.ReadFull(br, hdr[:]); err != nil {
|
||||
return errBadImage
|
||||
}
|
||||
length := int64(binary.BigEndian.Uint32(hdr[0:4]))
|
||||
ctype := string(hdr[4:8])
|
||||
if length > size-consumed-12 {
|
||||
return errBadImage
|
||||
}
|
||||
if first && ctype != "IHDR" {
|
||||
return errBadImage
|
||||
}
|
||||
first = false
|
||||
crcHasher.Reset()
|
||||
_, _ = crcHasher.Write(hdr[4:8])
|
||||
if _, err := io.CopyN(crcHasher, br, length); err != nil {
|
||||
return errBadImage
|
||||
}
|
||||
if _, err := io.ReadFull(br, crcBuf[:]); err != nil {
|
||||
return errBadImage
|
||||
}
|
||||
if crcHasher.Sum32() != binary.BigEndian.Uint32(crcBuf[:]) {
|
||||
return errBadImage
|
||||
}
|
||||
consumed += 12 + length
|
||||
switch ctype {
|
||||
case "IDAT":
|
||||
sawIDAT = true
|
||||
case "IEND":
|
||||
sawIEND = true
|
||||
}
|
||||
}
|
||||
// Данные после IEND — признак полиглота или склейки файлов, не принимаем.
|
||||
if !sawIDAT || consumed != size {
|
||||
return errBadImage
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// verifyJPEGTail требует маркер конца изображения EOI (FF D9) в хвосте файла.
|
||||
// Допускаются нулевые/мусорные байты выравнивания после него (до 1 KiB).
|
||||
func verifyJPEGTail(sr *io.SectionReader, size int64) error {
|
||||
tailLen := int64(1024)
|
||||
if size < tailLen {
|
||||
tailLen = size
|
||||
}
|
||||
tail := make([]byte, tailLen)
|
||||
if _, err := sr.ReadAt(tail, size-tailLen); err != nil && !errors.Is(err, io.EOF) {
|
||||
return errBadImage
|
||||
}
|
||||
if bytes.LastIndex(tail, []byte{0xFF, 0xD9}) < 0 {
|
||||
return errBadImage
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,780 @@
|
||||
// Package api — HTTP-слой lab4 (поверх lab3: LB, идемпотентность, сессии в Redis).
|
||||
//
|
||||
// Порядок обработки запроса:
|
||||
// 1. X-Request-Id и X-Instance-Id на каждый ответ, включая ошибки;
|
||||
// 2. журнал method/path/status без текста сообщений и без токена;
|
||||
// 3. маршрут;
|
||||
// 4. для защищённых маршрутов — только Bearer. Basic и X-User-Id доступ не дают.
|
||||
//
|
||||
// /health/live отвечает, пока процесс жив. /health/ready ещё проверяет PostgreSQL, Redis и S3:
|
||||
// без них нельзя честно принять запись или узнать, кто делает запрос.
|
||||
//
|
||||
// POST сообщения требует Idempotency-Key; результат хранится в общей БД, а не в памяти реплики.
|
||||
//
|
||||
// Вложения (attachments.go): сырой PNG/JPEG в теле POST, байты в приватном S3, метаданные в
|
||||
// PostgreSQL. Скачивание — только через этот API, без редиректа на S3.
|
||||
package api
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026lab4/internal/blob"
|
||||
"mtusi2026lab4/internal/session"
|
||||
"mtusi2026lab4/internal/store"
|
||||
)
|
||||
|
||||
type ctxKey int
|
||||
|
||||
const (
|
||||
userKey ctxKey = iota
|
||||
tokenKey
|
||||
requestIDKey
|
||||
)
|
||||
|
||||
const (
|
||||
challengeBasic = `Basic realm="messenger", charset="UTF-8"`
|
||||
challengeBearer = `Bearer realm="messenger"`
|
||||
)
|
||||
|
||||
// Лимиты вложений по контракту lab4.
|
||||
const (
|
||||
DefaultMaxUploadBytes int64 = 10 << 20 // 10 MiB = 10 485 760
|
||||
DefaultMaxImagePixels int64 = 40_000_000
|
||||
)
|
||||
|
||||
// BlobStore — то, что API требует от S3-клиента. *blob.Client его реализует;
|
||||
// интерфейс нужен, чтобы тест мог подставить недоступное хранилище.
|
||||
type BlobStore interface {
|
||||
Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error
|
||||
Get(ctx context.Context, key string) (io.ReadCloser, error)
|
||||
Delete(ctx context.Context, key string) error
|
||||
Ping(ctx context.Context) error
|
||||
}
|
||||
|
||||
var _ BlobStore = (*blob.Client)(nil)
|
||||
|
||||
// Server связывает HTTP с PostgreSQL, Redis и S3.
|
||||
type Server struct {
|
||||
Store *store.Store
|
||||
Sessions *session.Store
|
||||
Blob BlobStore
|
||||
InstanceID string
|
||||
// Лимиты загрузки. По умолчанию контрактные; main.go может только ужесточить.
|
||||
MaxUploadBytes int64
|
||||
MaxImagePixels int64
|
||||
ready atomic.Bool
|
||||
}
|
||||
|
||||
// New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready.
|
||||
// instanceID попадает в X-Instance-Id каждого ответа и стабилен на жизнь процесса.
|
||||
func New(st *store.Store, sessions *session.Store, bl BlobStore, instanceID string) *Server {
|
||||
s := &Server{
|
||||
Store: st, Sessions: sessions, Blob: bl, InstanceID: instanceID,
|
||||
MaxUploadBytes: DefaultMaxUploadBytes,
|
||||
MaxImagePixels: DefaultMaxImagePixels,
|
||||
}
|
||||
s.ready.Store(true)
|
||||
return s
|
||||
}
|
||||
|
||||
// BeginDrain вызывается на SIGTERM: новые клиенты видят 503 на /health/ready.
|
||||
// HAProxy/Traefik с httpchk на /health/ready перестаёт слать трафик на эту реплику.
|
||||
func (s *Server) BeginDrain() { s.ready.Store(false) }
|
||||
|
||||
// Handler собирает маршруты lab4.
|
||||
func (s *Server) Handler() http.Handler {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("GET /health/live", s.handleLive)
|
||||
mux.HandleFunc("GET /health/ready", s.handleReady)
|
||||
mux.HandleFunc("POST /api/v1/users", s.handleCreateUser)
|
||||
mux.HandleFunc("POST /api/v1/auth/sessions", s.handleCreateSession)
|
||||
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", s.requireUser(s.handleRevokeSession))
|
||||
mux.HandleFunc("GET /api/v1/users/me", s.requireUser(s.handleMe))
|
||||
mux.HandleFunc("POST /api/v1/chats", s.requireUser(s.handleCreateChat))
|
||||
mux.HandleFunc("GET /api/v1/chats", s.requireUser(s.handleListChats))
|
||||
mux.HandleFunc("GET /api/v1/chats/{chat_id}", s.requireUser(s.handleGetChat))
|
||||
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleCreateMessage))
|
||||
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleListMessages))
|
||||
mux.HandleFunc("POST /api/v1/chats/{chat_id}/attachments", s.requireUser(s.handleUploadAttachment))
|
||||
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}", s.requireUser(s.handleGetAttachment))
|
||||
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}/content", s.requireUser(s.handleDownloadAttachment))
|
||||
return s.withInstanceID(s.withRequestID(s.withAccessLog(mux)))
|
||||
}
|
||||
|
||||
func (s *Server) handleLive(w http.ResponseWriter, r *http.Request) {
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (s *Server) handleReady(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.ready.Load() {
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "service is shutting down")
|
||||
return
|
||||
}
|
||||
// S3 — обязательная зависимость синхронного пути (загрузка и скачивание вложений).
|
||||
if err := s.Store.Ping(r.Context()); err != nil || s.Sessions.Ping(r.Context()) != nil ||
|
||||
s.Blob.Ping(r.Context()) != nil {
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateUser(w http.ResponseWriter, r *http.Request) {
|
||||
var body struct {
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
if err := decodeStrict(r, &body); err != nil {
|
||||
writeDecodeErr(w, r, err)
|
||||
return
|
||||
}
|
||||
if !validUsername(body.Username) {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username")
|
||||
return
|
||||
}
|
||||
display := strings.TrimSpace(body.DisplayName)
|
||||
if display == "" || utf8.RuneCountInString(display) > 100 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name")
|
||||
return
|
||||
}
|
||||
if n := utf8.RuneCountInString(body.Password); n < 12 || n > 128 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid password")
|
||||
return
|
||||
}
|
||||
u, err := s.Store.CreateUser(r.Context(), body.Username, display, body.Password)
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusConflict, "conflict", "username already taken")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, userDTO(u))
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateSession(w http.ResponseWriter, r *http.Request) {
|
||||
// Контракт: только Basic, без JSON body. Любые байты в теле — 400, не тихий игнор.
|
||||
rawBody, err := io.ReadAll(io.LimitReader(r.Body, 4096))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid body")
|
||||
return
|
||||
}
|
||||
if len(bytes.TrimSpace(rawBody)) != 0 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "session create must not have a body")
|
||||
return
|
||||
}
|
||||
username, password, ok := parseBasic(r.Header.Get("Authorization"))
|
||||
if !ok || !validUsername(username) {
|
||||
writeAuthError(w, r, challengeBasic)
|
||||
return
|
||||
}
|
||||
if n := utf8.RuneCountInString(password); n < 12 || n > 128 {
|
||||
writeAuthError(w, r, challengeBasic)
|
||||
return
|
||||
}
|
||||
u, err := s.Store.Authenticate(r.Context(), username, password)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeAuthError(w, r, challengeBasic)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, 0, "", "")
|
||||
return
|
||||
}
|
||||
token, exp, err := s.Sessions.Issue(r.Context(), u.ID)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, map[string]any{
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": formatTime(exp),
|
||||
"user": userDTO(u),
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) handleRevokeSession(w http.ResponseWriter, r *http.Request) {
|
||||
token, _ := r.Context().Value(tokenKey).(string)
|
||||
if err := s.Sessions.Revoke(r.Context(), token); err != nil {
|
||||
if errors.Is(err, session.ErrUnauthorized) {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
|
||||
func (s *Server) handleMe(w http.ResponseWriter, r *http.Request) {
|
||||
u, err := s.Store.GetUser(r.Context(), userFrom(r))
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusUnauthorized, "unauthorized", "authentication required")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, userDTO(u))
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateChat(w http.ResponseWriter, r *http.Request) {
|
||||
var body struct {
|
||||
Title string `json:"title"`
|
||||
MemberIDs []string `json:"member_ids"`
|
||||
}
|
||||
if err := decodeStrict(r, &body); err != nil {
|
||||
writeDecodeErr(w, r, err)
|
||||
return
|
||||
}
|
||||
title := strings.TrimSpace(body.Title)
|
||||
if title == "" || utf8.RuneCountInString(title) > 100 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title")
|
||||
return
|
||||
}
|
||||
if len(body.MemberIDs) < 1 || len(body.MemberIDs) > 100 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids")
|
||||
return
|
||||
}
|
||||
uid := userFrom(r)
|
||||
seen := make(map[uuid.UUID]struct{}, len(body.MemberIDs))
|
||||
ids := make([]uuid.UUID, 0, len(body.MemberIDs))
|
||||
callerPresent := false
|
||||
for _, raw := range body.MemberIDs {
|
||||
id, err := uuid.Parse(raw)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member id")
|
||||
return
|
||||
}
|
||||
if _, dup := seen[id]; dup {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate member id")
|
||||
return
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
if id == uid {
|
||||
callerPresent = true
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
if !callerPresent {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "caller must be a member")
|
||||
return
|
||||
}
|
||||
chat, err := s.Store.CreateChat(r.Context(), title, ids)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "unknown member")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, 0, "", "")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, chatDTO(chat))
|
||||
}
|
||||
|
||||
func (s *Server) handleListChats(w http.ResponseWriter, r *http.Request) {
|
||||
uid := userFrom(r)
|
||||
limit, after, err := parsePage(r, "chats:"+uid.String())
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
|
||||
return
|
||||
}
|
||||
items, next, err := s.Store.ListChats(r.Context(), uid, limit, after)
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||||
return
|
||||
}
|
||||
out := make([]any, len(items))
|
||||
for i := range items {
|
||||
out[i] = chatDTO(&items[i])
|
||||
}
|
||||
var cursor *store.PageCursor
|
||||
if next != nil {
|
||||
cursor = &store.PageCursor{Scope: "chats:" + uid.String(), CreatedAt: next.CreatedAt, ID: next.ID}
|
||||
}
|
||||
writeJSON(w, http.StatusOK, pageDTO(out, cursor))
|
||||
}
|
||||
|
||||
func (s *Server) handleGetChat(w http.ResponseWriter, r *http.Request) {
|
||||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||||
return
|
||||
}
|
||||
chat, err := s.Store.GetChat(r.Context(), chatID, userFrom(r))
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, 0, "", "")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, chatDTO(chat))
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateMessage(w http.ResponseWriter, r *http.Request) {
|
||||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||||
return
|
||||
}
|
||||
idemKey := r.Header.Get("Idempotency-Key")
|
||||
if !validIdempotencyKey(idemKey) {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid or missing Idempotency-Key")
|
||||
return
|
||||
}
|
||||
var body struct {
|
||||
Text string `json:"text"`
|
||||
AttachmentIDs []string `json:"attachment_ids"`
|
||||
}
|
||||
if err := decodeStrict(r, &body); err != nil {
|
||||
writeDecodeErr(w, r, err)
|
||||
return
|
||||
}
|
||||
// attachment_ids: 0–10 уникальных UUID; отсутствующий ключ, null и [] равны для хэша.
|
||||
if len(body.AttachmentIDs) > maxMessageAttachments {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "too many attachments")
|
||||
return
|
||||
}
|
||||
attachmentIDs := make([]uuid.UUID, 0, len(body.AttachmentIDs))
|
||||
canonicalIDs := make([]string, 0, len(body.AttachmentIDs))
|
||||
seenAtt := make(map[uuid.UUID]struct{}, len(body.AttachmentIDs))
|
||||
for _, raw := range body.AttachmentIDs {
|
||||
id, err := uuid.Parse(raw)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id")
|
||||
return
|
||||
}
|
||||
if _, dup := seenAtt[id]; dup {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate attachment id")
|
||||
return
|
||||
}
|
||||
seenAtt[id] = struct{}{}
|
||||
attachmentIDs = append(attachmentIDs, id)
|
||||
canonicalIDs = append(canonicalIDs, id.String())
|
||||
}
|
||||
// Длина — по исходному тексту. Непустота — по TrimSpace, но только если вложений нет:
|
||||
// text="" с хотя бы одним вложением разрешён контрактом lab4.
|
||||
// Пробелы по краям сохраняются как есть, иначе «пробел + 4000 букв» проходил бы как 4000.
|
||||
if utf8.RuneCountInString(body.Text) > 4000 ||
|
||||
(len(attachmentIDs) == 0 && strings.TrimSpace(body.Text) == "") {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid text")
|
||||
return
|
||||
}
|
||||
path := "/api/v1/chats/" + chatID.String() + "/messages"
|
||||
reqHash := idempotencyRequestHash(body.Text, canonicalIDs)
|
||||
result, err := s.Store.CreateMessageIdempotent(
|
||||
r.Context(), chatID, userFrom(r), body.Text, attachmentIDs,
|
||||
http.MethodPost, path, idemKey, reqHash,
|
||||
)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
if errors.Is(err, store.ErrIdempotencyConflict) {
|
||||
writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body")
|
||||
return
|
||||
}
|
||||
if errors.Is(err, store.ErrNotReady) {
|
||||
writeError(w, r, http.StatusConflict, "conflict", "attachment is not ready")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, 0, "", "")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, messageDTO(result.Message))
|
||||
}
|
||||
|
||||
func (s *Server) handleListMessages(w http.ResponseWriter, r *http.Request) {
|
||||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||||
return
|
||||
}
|
||||
scope := "chat:" + chatID.String()
|
||||
limit, after, err := parsePage(r, scope)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
|
||||
return
|
||||
}
|
||||
items, next, err := s.Store.ListMessages(r.Context(), chatID, userFrom(r), limit, after)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||||
return
|
||||
}
|
||||
out := make([]any, len(items))
|
||||
for i := range items {
|
||||
out[i] = messageDTO(&items[i])
|
||||
}
|
||||
var cursor *store.PageCursor
|
||||
if next != nil {
|
||||
cursor = &store.PageCursor{Scope: scope, CreatedAt: next.CreatedAt, ID: next.ID}
|
||||
}
|
||||
writeJSON(w, http.StatusOK, pageDTO(out, cursor))
|
||||
}
|
||||
|
||||
// requireUser принимает только Authorization: Bearer. X-User-Id не читается.
|
||||
// Basic на бизнес-методе — тот же 401, но с Bearer-challenge, не с Basic.
|
||||
func (s *Server) requireUser(next http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
header := r.Header.Get("Authorization")
|
||||
if strings.HasPrefix(strings.ToLower(header), "basic ") {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
token, ok := parseBearer(header)
|
||||
if !ok {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
uid, err := s.Sessions.Lookup(r.Context(), token)
|
||||
if errors.Is(err, session.ErrUnauthorized) {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
ctx := context.WithValue(r.Context(), userKey, uid)
|
||||
ctx = context.WithValue(ctx, tokenKey, token)
|
||||
next(w, r.WithContext(ctx))
|
||||
}
|
||||
}
|
||||
|
||||
func userFrom(r *http.Request) uuid.UUID {
|
||||
id, _ := r.Context().Value(userKey).(uuid.UUID)
|
||||
return id
|
||||
}
|
||||
|
||||
func (s *Server) withRequestID(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
rid := r.Header.Get("X-Request-Id")
|
||||
if rid == "" {
|
||||
rid = uuid.NewString()
|
||||
}
|
||||
w.Header().Set("X-Request-Id", rid)
|
||||
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), requestIDKey, rid)))
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) withInstanceID(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("X-Instance-Id", s.InstanceID)
|
||||
next.ServeHTTP(w, r)
|
||||
})
|
||||
}
|
||||
|
||||
// validIdempotencyKey — ASCII [A-Za-z0-9._:-]{1,128}.
|
||||
func validIdempotencyKey(key string) bool {
|
||||
if len(key) < 1 || len(key) > 128 {
|
||||
return false
|
||||
}
|
||||
for i := 0; i < len(key); i++ {
|
||||
c := key[i]
|
||||
switch {
|
||||
case c >= 'A' && c <= 'Z', c >= 'a' && c <= 'z', c >= '0' && c <= '9':
|
||||
case c == '.', c == '_', c == ':', c == '-':
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// idempotencyRequestHash канонизирует тело: порядок ключей JSON не важен,
|
||||
// отсутствующий attachment_ids равен []. Хэш — SHA-256 hex.
|
||||
func idempotencyRequestHash(text string, attachmentIDs []string) string {
|
||||
if attachmentIDs == nil {
|
||||
attachmentIDs = []string{}
|
||||
}
|
||||
payload, _ := json.Marshal(struct {
|
||||
Text string `json:"text"`
|
||||
AttachmentIDs []string `json:"attachment_ids"`
|
||||
}{Text: text, AttachmentIDs: attachmentIDs})
|
||||
sum := sha256.Sum256(payload)
|
||||
return hex.EncodeToString(sum[:])
|
||||
}
|
||||
|
||||
type statusRecorder struct {
|
||||
http.ResponseWriter
|
||||
status int
|
||||
}
|
||||
|
||||
func (s *statusRecorder) WriteHeader(code int) {
|
||||
s.status = code
|
||||
s.ResponseWriter.WriteHeader(code)
|
||||
}
|
||||
|
||||
func (s *Server) withAccessLog(next http.Handler) http.Handler {
|
||||
quiet := strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "0") || strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "false")
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
start := time.Now()
|
||||
rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
|
||||
next.ServeHTTP(rec, r)
|
||||
if quiet && rec.status < 400 {
|
||||
return
|
||||
}
|
||||
if strings.HasPrefix(r.URL.Path, "/health/") && rec.status == http.StatusOK {
|
||||
return
|
||||
}
|
||||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||||
// path без query: в cursor нет секрета, но и текста сообщения в логе быть не должно.
|
||||
log.Printf("method=%s path=%s status=%d request_id=%s duration_ms=%d",
|
||||
r.Method, r.URL.Path, rec.status, rid, time.Since(start).Milliseconds())
|
||||
})
|
||||
}
|
||||
|
||||
func parsePage(r *http.Request, expectedScope string) (int, *store.PageCursor, error) {
|
||||
limit := 50
|
||||
if raw := r.URL.Query().Get("limit"); raw != "" {
|
||||
n, err := strconv.Atoi(raw)
|
||||
if err != nil || n < 1 || n > 100 {
|
||||
return 0, nil, fmt.Errorf("invalid limit")
|
||||
}
|
||||
limit = n
|
||||
}
|
||||
rawCursor := r.URL.Query().Get("cursor")
|
||||
if rawCursor == "" {
|
||||
return limit, nil, nil
|
||||
}
|
||||
cur, err := decodeCursor(rawCursor)
|
||||
if err != nil || cur.Scope != expectedScope {
|
||||
return 0, nil, fmt.Errorf("invalid cursor")
|
||||
}
|
||||
return limit, cur, nil
|
||||
}
|
||||
|
||||
func encodeCursor(c *store.PageCursor) string {
|
||||
payload := fmt.Sprintf("%s|%s|%s", c.Scope, c.CreatedAt.UTC().Format(time.RFC3339Nano), c.ID.String())
|
||||
return base64.RawURLEncoding.EncodeToString([]byte(payload))
|
||||
}
|
||||
|
||||
func decodeCursor(raw string) (*store.PageCursor, error) {
|
||||
b, err := base64.RawURLEncoding.DecodeString(raw)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
parts := strings.SplitN(string(b), "|", 3)
|
||||
if len(parts) != 3 {
|
||||
return nil, fmt.Errorf("bad cursor")
|
||||
}
|
||||
ts, err := time.Parse(time.RFC3339Nano, parts[1])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
id, err := uuid.Parse(parts[2])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &store.PageCursor{Scope: parts[0], CreatedAt: ts.UTC(), ID: id}, nil
|
||||
}
|
||||
|
||||
func validUsername(s string) bool {
|
||||
if len(s) < 3 || len(s) > 32 {
|
||||
return false
|
||||
}
|
||||
for _, c := range s {
|
||||
if (c < 'a' || c > 'z') && (c < '0' || c > '9') && c != '_' {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func decodeStrict(r *http.Request, dst any) error {
|
||||
ct := r.Header.Get("Content-Type")
|
||||
if ct != "" && !strings.HasPrefix(strings.ToLower(strings.TrimSpace(ct)), "application/json") {
|
||||
return errUnsupported
|
||||
}
|
||||
// Читаем тело целиком: Decoder.More() не ловит хвост вида {"text":"x"}} —
|
||||
// после одного объекта More()=false, а лишняя скобка всё равно остаётся.
|
||||
raw, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
|
||||
if err != nil {
|
||||
return errMalformed
|
||||
}
|
||||
dec := json.NewDecoder(bytes.NewReader(raw))
|
||||
dec.DisallowUnknownFields()
|
||||
if err := dec.Decode(dst); err != nil {
|
||||
return errMalformed
|
||||
}
|
||||
rest := bytes.TrimSpace(raw[dec.InputOffset():])
|
||||
if len(rest) != 0 {
|
||||
return errMalformed
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var (
|
||||
errUnsupported = errors.New("unsupported media type")
|
||||
errMalformed = errors.New("malformed json")
|
||||
)
|
||||
|
||||
func writeDecodeErr(w http.ResponseWriter, r *http.Request, err error) {
|
||||
if errors.Is(err, errUnsupported) {
|
||||
writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "unsupported media type")
|
||||
return
|
||||
}
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed json")
|
||||
}
|
||||
|
||||
func parseBasic(header string) (string, string, bool) {
|
||||
const prefix = "basic "
|
||||
if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix {
|
||||
return "", "", false
|
||||
}
|
||||
raw, err := base64.StdEncoding.DecodeString(strings.TrimSpace(header[len(prefix):]))
|
||||
if err != nil || !utf8.Valid(raw) {
|
||||
return "", "", false
|
||||
}
|
||||
user, pass, ok := strings.Cut(string(raw), ":")
|
||||
if !ok || user == "" {
|
||||
return "", "", false
|
||||
}
|
||||
return user, pass, true
|
||||
}
|
||||
|
||||
func parseBearer(header string) (string, bool) {
|
||||
const prefix = "bearer "
|
||||
if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix {
|
||||
return "", false
|
||||
}
|
||||
token := strings.TrimSpace(header[len(prefix):])
|
||||
if token == "" || strings.Contains(token, " ") {
|
||||
return "", false
|
||||
}
|
||||
return token, true
|
||||
}
|
||||
|
||||
func userDTO(u *store.User) map[string]any {
|
||||
return map[string]any{
|
||||
"id": u.ID.String(),
|
||||
"username": u.Username,
|
||||
"display_name": u.DisplayName,
|
||||
"created_at": formatTime(u.CreatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func chatDTO(c *store.Chat) map[string]any {
|
||||
ids := make([]string, len(c.MemberIDs))
|
||||
for i, id := range c.MemberIDs {
|
||||
ids[i] = id.String()
|
||||
}
|
||||
return map[string]any{
|
||||
"id": c.ID.String(),
|
||||
"title": c.Title,
|
||||
"member_ids": ids,
|
||||
"created_at": formatTime(c.CreatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func messageDTO(m *store.Message) map[string]any {
|
||||
// Всегда массив, даже пустой: клиент lab3 без вложений видит [] (контракт 1.4.0).
|
||||
att := make([]string, len(m.AttachmentIDs))
|
||||
for i, id := range m.AttachmentIDs {
|
||||
att[i] = id.String()
|
||||
}
|
||||
return map[string]any{
|
||||
"id": m.ID.String(),
|
||||
"chat_id": m.ChatID.String(),
|
||||
"sender_id": m.SenderID.String(),
|
||||
"text": m.Text,
|
||||
"attachment_ids": att,
|
||||
"created_at": formatTime(m.CreatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func pageDTO(items []any, next *store.PageCursor) map[string]any {
|
||||
var cursor any
|
||||
if next != nil {
|
||||
cursor = encodeCursor(next)
|
||||
}
|
||||
if items == nil {
|
||||
items = []any{}
|
||||
}
|
||||
return map[string]any{"items": items, "next_cursor": cursor}
|
||||
}
|
||||
|
||||
func formatTime(t time.Time) string {
|
||||
return t.UTC().Truncate(time.Millisecond).Format("2006-01-02T15:04:05.000Z")
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
enc := json.NewEncoder(w)
|
||||
enc.SetEscapeHTML(false)
|
||||
_ = enc.Encode(v)
|
||||
}
|
||||
|
||||
func writeError(w http.ResponseWriter, r *http.Request, status int, code, message string) {
|
||||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||||
if rid == "" {
|
||||
rid = w.Header().Get("X-Request-Id")
|
||||
}
|
||||
writeJSON(w, status, map[string]any{
|
||||
"error": map[string]any{
|
||||
"code": code,
|
||||
"message": message,
|
||||
"request_id": rid,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
func writeAuthError(w http.ResponseWriter, r *http.Request, challenge string) {
|
||||
w.Header().Set("WWW-Authenticate", challenge)
|
||||
writeError(w, r, http.StatusUnauthorized, "unauthorized", "authentication required")
|
||||
}
|
||||
|
||||
// writeStoreErr прячет текст драйвера. fallbackStatus используется для ожидаемой доменной ошибки.
|
||||
func (s *Server) writeStoreErr(w http.ResponseWriter, r *http.Request, err error, fallbackStatus int, fallbackCode, fallbackMessage string) {
|
||||
switch {
|
||||
case errors.Is(err, store.ErrUnavailable):
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
case errors.Is(err, store.ErrIdempotencyConflict):
|
||||
writeError(w, r, http.StatusConflict, "conflict", "idempotency key reused with different body")
|
||||
case errors.Is(err, store.ErrConflict) && fallbackStatus != 0:
|
||||
writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage)
|
||||
case errors.Is(err, store.ErrNotFound) && fallbackStatus != 0:
|
||||
if fallbackCode == "unauthorized" {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage)
|
||||
case errors.Is(err, store.ErrInvalidCursor):
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||||
default:
|
||||
if errors.Is(err, store.ErrConflict) {
|
||||
writeError(w, r, http.StatusConflict, "conflict", "username already taken")
|
||||
return
|
||||
}
|
||||
// В лог — только тип, без SQL и без текста, который драйвер мог вложить в ошибку.
|
||||
log.Printf("request_id=%s store_error_type=%T", requestID(r), err)
|
||||
writeError(w, r, http.StatusInternalServerError, "internal_error", "internal error")
|
||||
}
|
||||
}
|
||||
|
||||
func requestID(r *http.Request) string {
|
||||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||||
return rid
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
// Package auth хранит пароли через Argon2id.
|
||||
//
|
||||
// bcrypt отвергнут: библиотека молча режет пароль на 72 байта, а контракт
|
||||
// разрешает до 128 Unicode code points, включая символы вне ASCII.
|
||||
// Argon2id принимает пароль целиком. Параметры — интерактивные, не «серверные»
|
||||
// на сотни миллисекунд: smoke создаёт несколько пользователей подряд.
|
||||
package auth
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/crypto/argon2"
|
||||
)
|
||||
|
||||
const (
|
||||
argonTime = 2
|
||||
argonMemory = 19 * 1024 // KiB, около 19 MiB
|
||||
argonThreads = 1
|
||||
argonKeyLen = 32
|
||||
argonSaltLen = 16
|
||||
)
|
||||
|
||||
// Hasher умеет хешировать и проверять. dummy — хеш случайного пароля,
|
||||
// чтобы отсутствующий username занимал примерно столько же CPU, сколько неверный пароль.
|
||||
type Hasher struct {
|
||||
dummy string
|
||||
}
|
||||
|
||||
// NewHasher готовит dummy-хеш один раз на процесс.
|
||||
func NewHasher() (*Hasher, error) {
|
||||
dummy, err := Hash(randomPassword())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &Hasher{dummy: dummy}, nil
|
||||
}
|
||||
|
||||
// Hash возвращает PHC-строку. Её пишем в users.password_hash.
|
||||
func Hash(password string) (string, error) {
|
||||
salt := make([]byte, argonSaltLen)
|
||||
if _, err := rand.Read(salt); err != nil {
|
||||
return "", err
|
||||
}
|
||||
sum := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
|
||||
return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s",
|
||||
argonMemory, argonTime, argonThreads,
|
||||
base64.RawStdEncoding.EncodeToString(salt),
|
||||
base64.RawStdEncoding.EncodeToString(sum),
|
||||
), nil
|
||||
}
|
||||
|
||||
// Verify сравнивает пароль с PHC-строкой. При битой строке возвращает false, не панику.
|
||||
func (h *Hasher) Verify(encoded, password string) bool {
|
||||
if encoded == "" {
|
||||
encoded = h.dummy
|
||||
}
|
||||
ok, err := verify(encoded, password)
|
||||
if err != nil {
|
||||
// Всё равно тратим время dummy-проверки, чтобы ветка ошибки не была мгновенной.
|
||||
_, _ = verify(h.dummy, password)
|
||||
return false
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
// Burn тратит время проверки, когда пользователя нет. Результат всегда false.
|
||||
func (h *Hasher) Burn(password string) {
|
||||
_, _ = verify(h.dummy, password)
|
||||
}
|
||||
|
||||
func verify(encoded, password string) (bool, error) {
|
||||
parts := strings.Split(encoded, "$")
|
||||
// ["", "argon2id", "v=19", "m=..,t=..,p=..", salt, hash]
|
||||
if len(parts) != 6 || parts[1] != "argon2id" || parts[2] != "v=19" {
|
||||
return false, fmt.Errorf("bad hash")
|
||||
}
|
||||
var memory uint32
|
||||
var timeCost uint32
|
||||
var threads uint8
|
||||
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil {
|
||||
return false, err
|
||||
}
|
||||
if memory != argonMemory || timeCost != argonTime || threads != argonThreads {
|
||||
return false, fmt.Errorf("unexpected argon2 parameters")
|
||||
}
|
||||
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
want, err := base64.RawStdEncoding.DecodeString(parts[5])
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
got := argon2.IDKey([]byte(password), salt, timeCost, memory, threads, uint32(len(want)))
|
||||
// ConstantTimeCompare не даёт выйти на первом несовпавшем байте.
|
||||
if subtle.ConstantTimeCompare(got, want) != 1 {
|
||||
return false, nil
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func randomPassword() string {
|
||||
buf := make([]byte, 24)
|
||||
_, _ = rand.Read(buf)
|
||||
return base64.RawStdEncoding.EncodeToString(buf)
|
||||
}
|
||||
@@ -0,0 +1,162 @@
|
||||
package blob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"io"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Memory — in-memory BlobStore для student-tests без живого MinIO.
|
||||
// Не для production: нет persistence между процессами.
|
||||
type Memory struct {
|
||||
mu sync.Mutex
|
||||
objects map[string]memObj
|
||||
down bool
|
||||
bucketOK bool
|
||||
now func() time.Time
|
||||
}
|
||||
|
||||
type memObj struct {
|
||||
data []byte
|
||||
modTime time.Time
|
||||
}
|
||||
|
||||
// NewMemory создаёт пустое хранилище с «живым» бакетом.
|
||||
func NewMemory() *Memory {
|
||||
return &Memory{
|
||||
objects: make(map[string]memObj),
|
||||
bucketOK: true,
|
||||
now: time.Now,
|
||||
}
|
||||
}
|
||||
|
||||
// SetUnavailable имитирует падение S3 (Ping/Put/Get → ErrUnavailable).
|
||||
func (m *Memory) SetUnavailable(v bool) { m.mu.Lock(); m.down = v; m.mu.Unlock() }
|
||||
|
||||
func (m *Memory) Bucket() string { return "memory" }
|
||||
|
||||
func (m *Memory) Ping(ctx context.Context) error {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
default:
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.down || !m.bucketOK {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) Put(ctx context.Context, key string, r io.Reader, size int64, _ string) error {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
default:
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.down {
|
||||
return ErrUnavailable
|
||||
}
|
||||
data, err := io.ReadAll(io.LimitReader(r, size+1))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if int64(len(data)) != size {
|
||||
return ErrUnavailable
|
||||
}
|
||||
m.objects[key] = memObj{data: append([]byte(nil), data...), modTime: m.now()}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
default:
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.down {
|
||||
return nil, ErrUnavailable
|
||||
}
|
||||
o, ok := m.objects[key]
|
||||
if !ok {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return io.NopCloser(bytes.NewReader(o.data)), nil
|
||||
}
|
||||
|
||||
func (m *Memory) Stat(ctx context.Context, key string) (ObjectInfo, error) {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return ObjectInfo{}, ctx.Err()
|
||||
default:
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.down {
|
||||
return ObjectInfo{}, ErrUnavailable
|
||||
}
|
||||
o, ok := m.objects[key]
|
||||
if !ok {
|
||||
return ObjectInfo{}, ErrNotFound
|
||||
}
|
||||
return ObjectInfo{Key: key, Size: int64(len(o.data)), LastModified: o.modTime}, nil
|
||||
}
|
||||
|
||||
func (m *Memory) Delete(ctx context.Context, key string) error {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
default:
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.down {
|
||||
return ErrUnavailable
|
||||
}
|
||||
delete(m.objects, key)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Memory) ListKeys(ctx context.Context, prefix string) ([]ObjectInfo, error) {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
default:
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.down {
|
||||
return nil, ErrUnavailable
|
||||
}
|
||||
var out []ObjectInfo
|
||||
for k, o := range m.objects {
|
||||
if len(prefix) == 0 || (len(k) >= len(prefix) && k[:len(prefix)] == prefix) {
|
||||
out = append(out, ObjectInfo{Key: k, Size: int64(len(o.data)), LastModified: o.modTime})
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Seed кладёт объект напрямую (для тестов reconciler).
|
||||
func (m *Memory) Seed(key string, data []byte, modTime time.Time) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if modTime.IsZero() {
|
||||
modTime = m.now()
|
||||
}
|
||||
m.objects[key] = memObj{data: append([]byte(nil), data...), modTime: modTime}
|
||||
}
|
||||
|
||||
var _ interface {
|
||||
Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error
|
||||
Get(ctx context.Context, key string) (io.ReadCloser, error)
|
||||
Delete(ctx context.Context, key string) error
|
||||
Ping(ctx context.Context) error
|
||||
} = (*Memory)(nil)
|
||||
@@ -0,0 +1,197 @@
|
||||
// Package blob — тонкая обёртка над MinIO (S3 API) для оригиналов вложений lab4.
|
||||
//
|
||||
// Байты файлов живут только здесь, а не в PostgreSQL и не на диске API-реплики.
|
||||
// Ключ объекта назначает сервер (originals/<uuid>); filename клиента в ключ не попадает.
|
||||
// Bucket приватный: прямого доступа без подписи нет, скачивание идёт через авторизованный API.
|
||||
//
|
||||
// Ошибки сведены к двум классам, чтобы HTTP-слой не знал про minio-go:
|
||||
// ErrNotFound — объекта нет (404/500 по контексту), ErrUnavailable — S3 недоступен (503).
|
||||
package blob
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/credentials"
|
||||
)
|
||||
|
||||
// KeyPrefix — префикс ключей оригиналов. Reconciler обходит только его.
|
||||
const KeyPrefix = "originals/"
|
||||
|
||||
var (
|
||||
// ErrNotFound — такого объекта в бакете нет.
|
||||
ErrNotFound = errors.New("blob: not found")
|
||||
// ErrUnavailable — S3 не отвечает, отказал в доступе или вернул неожиданную ошибку.
|
||||
ErrUnavailable = errors.New("blob: unavailable")
|
||||
)
|
||||
|
||||
// Config — параметры подключения. Секреты приходят из окружения/файла, в логи не попадают.
|
||||
type Config struct {
|
||||
Endpoint string // host:port без схемы, например minio:9000
|
||||
UseSSL bool
|
||||
Region string
|
||||
Bucket string
|
||||
AccessKey string
|
||||
SecretKey string
|
||||
}
|
||||
|
||||
// ObjectInfo — то, что reconciler и тесты знают об объекте.
|
||||
type ObjectInfo struct {
|
||||
Key string
|
||||
Size int64
|
||||
LastModified time.Time
|
||||
}
|
||||
|
||||
// Client — клиент одного бакета.
|
||||
type Client struct {
|
||||
mc *minio.Client
|
||||
bucket string
|
||||
}
|
||||
|
||||
// New создаёт клиента. Сеть не трогает: доступность проверяют Ping/EnsureBucket.
|
||||
//
|
||||
// Таймауты заданы явно. Без них connection refused ретраится minio-go десяток раз,
|
||||
// и «S3 лежит» вместо быстрого 503 превращается в зависший запрос.
|
||||
func New(cfg Config) (*Client, error) {
|
||||
if cfg.Endpoint == "" || cfg.Bucket == "" {
|
||||
return nil, fmt.Errorf("blob: endpoint and bucket are required")
|
||||
}
|
||||
tr := &http.Transport{
|
||||
Proxy: nil,
|
||||
DialContext: (&net.Dialer{
|
||||
Timeout: 2 * time.Second,
|
||||
KeepAlive: 30 * time.Second,
|
||||
}).DialContext,
|
||||
MaxIdleConns: 64,
|
||||
MaxIdleConnsPerHost: 32,
|
||||
IdleConnTimeout: 60 * time.Second,
|
||||
TLSHandshakeTimeout: 3 * time.Second,
|
||||
ResponseHeaderTimeout: 20 * time.Second,
|
||||
}
|
||||
mc, err := minio.New(cfg.Endpoint, &minio.Options{
|
||||
Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""),
|
||||
Secure: cfg.UseSSL,
|
||||
Region: cfg.Region,
|
||||
Transport: tr,
|
||||
MaxRetries: 2,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("blob: init client: %w", err)
|
||||
}
|
||||
return &Client{mc: mc, bucket: cfg.Bucket}, nil
|
||||
}
|
||||
|
||||
// Bucket возвращает имя бакета (для логов и отчётов).
|
||||
func (c *Client) Bucket() string { return c.bucket }
|
||||
|
||||
// EnsureBucket создаёт бакет, если его нет. Идемпотентно.
|
||||
// В Compose бакет создаёт minio-init с root-правами, а у app-пользователя прав на
|
||||
// создание нет — функция нужна локальным тестам и ручному запуску на «голом» MinIO.
|
||||
func (c *Client) EnsureBucket(ctx context.Context) error {
|
||||
ok, err := c.mc.BucketExists(ctx, c.bucket)
|
||||
if err != nil {
|
||||
return classify(err)
|
||||
}
|
||||
if ok {
|
||||
return nil
|
||||
}
|
||||
if err := c.mc.MakeBucket(ctx, c.bucket, minio.MakeBucketOptions{}); err != nil {
|
||||
// Гонка двух инициализаторов: бакет уже создан соседом.
|
||||
code := minio.ToErrorResponse(err).Code
|
||||
if code == "BucketAlreadyOwnedByYou" || code == "BucketAlreadyExists" {
|
||||
return nil
|
||||
}
|
||||
return classify(err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Ping — проверка для /health/ready. Короткий таймаут: readiness не должна висеть.
|
||||
func (c *Client) Ping(ctx context.Context) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
|
||||
defer cancel()
|
||||
ok, err := c.mc.BucketExists(ctx, c.bucket)
|
||||
if err != nil || !ok {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Put кладёт объект известного размера. r должен уметь Seek (файл или bytes.Reader):
|
||||
// тогда minio-go отправляет тело одним запросом без буферизации в памяти.
|
||||
func (c *Client) Put(ctx context.Context, key string, r io.Reader, size int64, contentType string) error {
|
||||
_, err := c.mc.PutObject(ctx, c.bucket, key, r, size, minio.PutObjectOptions{
|
||||
ContentType: contentType,
|
||||
// Один PUT для файлов до лимита lab4 (10 MiB): multipart не нужен.
|
||||
DisableMultipart: true,
|
||||
})
|
||||
return classify(err)
|
||||
}
|
||||
|
||||
// Get открывает объект на чтение. Существование проверяется сразу (Stat), чтобы HTTP-слой
|
||||
// успел вернуть 404/503 до отправки заголовков 200.
|
||||
func (c *Client) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
obj, err := c.mc.GetObject(ctx, c.bucket, key, minio.GetObjectOptions{})
|
||||
if err != nil {
|
||||
return nil, classify(err)
|
||||
}
|
||||
if _, err := obj.Stat(); err != nil {
|
||||
_ = obj.Close()
|
||||
return nil, classify(err)
|
||||
}
|
||||
return obj, nil
|
||||
}
|
||||
|
||||
// Stat возвращает метаданные объекта или ErrNotFound.
|
||||
func (c *Client) Stat(ctx context.Context, key string) (ObjectInfo, error) {
|
||||
st, err := c.mc.StatObject(ctx, c.bucket, key, minio.StatObjectOptions{})
|
||||
if err != nil {
|
||||
return ObjectInfo{}, classify(err)
|
||||
}
|
||||
return ObjectInfo{Key: st.Key, Size: st.Size, LastModified: st.LastModified}, nil
|
||||
}
|
||||
|
||||
// Delete удаляет объект. Отсутствие объекта — не ошибка (S3 DELETE идемпотентен).
|
||||
func (c *Client) Delete(ctx context.Context, key string) error {
|
||||
err := c.mc.RemoveObject(ctx, c.bucket, key, minio.RemoveObjectOptions{})
|
||||
if err != nil && errors.Is(classify(err), ErrNotFound) {
|
||||
return nil
|
||||
}
|
||||
return classify(err)
|
||||
}
|
||||
|
||||
// ListKeys возвращает все объекты с префиксом (рекурсивно). Для reconciler:
|
||||
// стоимость обхода — O(число объектов), память — по записи на объект.
|
||||
func (c *Client) ListKeys(ctx context.Context, prefix string) ([]ObjectInfo, error) {
|
||||
var out []ObjectInfo
|
||||
for o := range c.mc.ListObjects(ctx, c.bucket, minio.ListObjectsOptions{Prefix: prefix, Recursive: true}) {
|
||||
if o.Err != nil {
|
||||
return nil, classify(o.Err)
|
||||
}
|
||||
out = append(out, ObjectInfo{Key: o.Key, Size: o.Size, LastModified: o.LastModified})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// classify сводит ошибки minio-go к ErrNotFound/ErrUnavailable. Текст исходной ошибки
|
||||
// наружу не возвращаем: в нём могут быть endpoint и имя бакета.
|
||||
func classify(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
switch minio.ToErrorResponse(err).Code {
|
||||
case "NoSuchKey", "NotFound":
|
||||
return ErrNotFound
|
||||
}
|
||||
if minio.ToErrorResponse(err).StatusCode == http.StatusNotFound &&
|
||||
minio.ToErrorResponse(err).Code != "NoSuchBucket" {
|
||||
return ErrNotFound
|
||||
}
|
||||
return ErrUnavailable
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
// Package config читает настройки процесса из окружения.
|
||||
//
|
||||
// Для lab4 добавлены S3_* и лимиты вложений.
|
||||
//
|
||||
// Прямые URL (DATABASE_URL, REDIS_URL) удобны в Compose.
|
||||
// Вариант *_FILE из .env.example нужен, если секрет смонтирован файлом:
|
||||
// тогда в переменной лежит путь, а не сам секрет.
|
||||
package config
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Config — всё, что процесс обязан знать до открытия соединений.
|
||||
type Config struct {
|
||||
Host string
|
||||
Port int
|
||||
Env string
|
||||
DatabaseURL string
|
||||
RedisURL string
|
||||
SessionTTL time.Duration
|
||||
InstanceID string
|
||||
MaxConns int32
|
||||
RunMigrations bool
|
||||
IdempotencyTTL time.Duration
|
||||
|
||||
// Лимиты вложений (lab4). Контракт: 10 MiB и 40 млн пикселей.
|
||||
MaxUploadBytes int64
|
||||
MaxImagePixels int64
|
||||
// ReconcileGrace — минимальный возраст объекта/строки, прежде чем reconciler их тронет.
|
||||
ReconcileGrace time.Duration
|
||||
}
|
||||
|
||||
// S3 — параметры подключения к S3-совместимому хранилищу.
|
||||
type S3 struct {
|
||||
Endpoint string
|
||||
UseSSL bool
|
||||
Region string
|
||||
Bucket string
|
||||
AccessKey string
|
||||
SecretKey string
|
||||
}
|
||||
|
||||
// Load собирает Config. Пустой URL без файла — ошибка запуска, а не тихий дефолт на чужой хост.
|
||||
func Load() (Config, error) {
|
||||
cfg := Config{
|
||||
Host: getenv("APP_HOST", "0.0.0.0"),
|
||||
Env: getenv("APP_ENV", "lab"),
|
||||
}
|
||||
port, err := strconv.Atoi(getenv("APP_PORT", "8080"))
|
||||
if err != nil || port < 1 || port > 65535 {
|
||||
return cfg, fmt.Errorf("invalid APP_PORT")
|
||||
}
|
||||
cfg.Port = port
|
||||
|
||||
ttlSec, err := strconv.Atoi(getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
if err != nil || ttlSec < 1 || ttlSec > 7*24*3600 {
|
||||
return cfg, fmt.Errorf("invalid SESSION_TTL_SECONDS")
|
||||
}
|
||||
cfg.SessionTTL = time.Duration(ttlSec) * time.Second
|
||||
|
||||
idemTTL, err := strconv.Atoi(getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))
|
||||
if err != nil || idemTTL < 60 || idemTTL > 7*24*3600 {
|
||||
return cfg, fmt.Errorf("invalid IDEMPOTENCY_TTL_SECONDS")
|
||||
}
|
||||
cfg.IdempotencyTTL = time.Duration(idemTTL) * time.Second
|
||||
|
||||
maxConns, err := strconv.Atoi(getenv("DB_MAX_CONNS", "5"))
|
||||
if err != nil || maxConns < 1 || maxConns > 50 {
|
||||
return cfg, fmt.Errorf("invalid DB_MAX_CONNS")
|
||||
}
|
||||
cfg.MaxConns = int32(maxConns)
|
||||
|
||||
cfg.DatabaseURL, err = getenvOrFile("DATABASE_URL", "DATABASE_URL_FILE")
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
cfg.RedisURL, err = getenvOrFile("REDIS_URL", "CACHE_URL_FILE")
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
|
||||
cfg.InstanceID = strings.TrimSpace(os.Getenv("INSTANCE_ID"))
|
||||
if cfg.InstanceID == "" {
|
||||
host, herr := os.Hostname()
|
||||
if herr != nil || strings.TrimSpace(host) == "" {
|
||||
return cfg, fmt.Errorf("set INSTANCE_ID or ensure hostname is available")
|
||||
}
|
||||
cfg.InstanceID = host
|
||||
}
|
||||
|
||||
cfg.MaxUploadBytes, err = getenvInt64("MAX_UPLOAD_BYTES", 10485760, 1, 10485760)
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
cfg.MaxImagePixels, err = getenvInt64("MAX_IMAGE_PIXELS", 40000000, 1, 40000000)
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
graceSec, err := getenvInt64("S3_RECONCILE_GRACE_SECONDS", 60, 0, 7*24*3600)
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
cfg.ReconcileGrace = time.Duration(graceSec) * time.Second
|
||||
|
||||
cfg.RunMigrations = truthy(os.Getenv("RUN_MIGRATIONS"))
|
||||
return cfg, nil
|
||||
}
|
||||
|
||||
// LoadS3 читает настройки S3. Ключи — из S3_ACCESS_KEY_ID / S3_SECRET_ACCESS_KEY
|
||||
// либо из файлов *_FILE. Пустые ключи — ошибка запуска API (migrate без S3 обходится).
|
||||
func LoadS3() (S3, error) {
|
||||
var (
|
||||
c S3
|
||||
err error
|
||||
)
|
||||
c.Endpoint = getenv("S3_ENDPOINT", "minio:9000")
|
||||
// Endpoint может прийти со схемой http:// — minio-go ждёт host:port.
|
||||
c.Endpoint = strings.TrimPrefix(c.Endpoint, "https://")
|
||||
c.Endpoint = strings.TrimPrefix(c.Endpoint, "http://")
|
||||
c.Region = getenv("S3_REGION", "us-east-1")
|
||||
c.Bucket = getenv("S3_BUCKET", "messenger-attachments")
|
||||
c.UseSSL = truthy(os.Getenv("S3_USE_SSL"))
|
||||
c.AccessKey, err = getenvOrFile("S3_ACCESS_KEY_ID", "S3_ACCESS_KEY_ID_FILE")
|
||||
if err != nil {
|
||||
return c, err
|
||||
}
|
||||
c.SecretKey, err = getenvOrFile("S3_SECRET_ACCESS_KEY", "S3_SECRET_ACCESS_KEY_FILE")
|
||||
if err != nil {
|
||||
return c, err
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
// Addr — адрес Listen, обычно 0.0.0.0:8080 внутри контейнера.
|
||||
func (c Config) Addr() string {
|
||||
return fmt.Sprintf("%s:%d", c.Host, c.Port)
|
||||
}
|
||||
|
||||
func getenv(key, fallback string) string {
|
||||
if v := strings.TrimSpace(os.Getenv(key)); v != "" {
|
||||
return v
|
||||
}
|
||||
return fallback
|
||||
}
|
||||
|
||||
func getenvInt64(key string, fallback, lo, hi int64) (int64, error) {
|
||||
raw := strings.TrimSpace(os.Getenv(key))
|
||||
if raw == "" {
|
||||
return fallback, nil
|
||||
}
|
||||
n, err := strconv.ParseInt(raw, 10, 64)
|
||||
if err != nil || n < lo || n > hi {
|
||||
return 0, fmt.Errorf("invalid %s", key)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
func getenvOrFile(directKey, fileKey string) (string, error) {
|
||||
if v := strings.TrimSpace(os.Getenv(directKey)); v != "" {
|
||||
return v, nil
|
||||
}
|
||||
path := strings.TrimSpace(os.Getenv(fileKey))
|
||||
if path == "" {
|
||||
return "", fmt.Errorf("set %s or %s", directKey, fileKey)
|
||||
}
|
||||
b, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("read %s: %w", fileKey, err)
|
||||
}
|
||||
v := strings.TrimSpace(string(b))
|
||||
if v == "" {
|
||||
return "", fmt.Errorf("%s is empty", fileKey)
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
|
||||
func truthy(v string) bool {
|
||||
switch strings.ToLower(strings.TrimSpace(v)) {
|
||||
case "1", "true", "yes", "on":
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
// Package session хранит opaque Bearer-сессии в Redis.
|
||||
//
|
||||
// PostgreSQL остаётся источником истины для пользователей и сообщений.
|
||||
// Сессия — отдельная роль: случайный токен, срок жизни SESSION_TTL_SECONDS и отзыв.
|
||||
// В Redis лежит не сам токен, а его SHA-256: дамп AOF не содержит значение,
|
||||
// которое клиент предъявляет в Authorization.
|
||||
//
|
||||
// TTL ключа равен оставшемуся сроку сессии. Рестарт API его не продлевает.
|
||||
// Рестарт Redis сессию сохраняет только потому, что включён AOF на volume.
|
||||
package session
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrUnauthorized = errors.New("unauthorized")
|
||||
ErrUnavailable = errors.New("unavailable")
|
||||
)
|
||||
|
||||
// Store — клиент Redis с короткими таймаутами.
|
||||
type Store struct {
|
||||
client *redis.Client
|
||||
ttl time.Duration
|
||||
}
|
||||
|
||||
// Open разбирает redis:// URL. Пароль в лог не пишется.
|
||||
func Open(redisURL string, ttl time.Duration) (*Store, error) {
|
||||
opt, err := redis.ParseURL(redisURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse redis url: %w", err)
|
||||
}
|
||||
opt.DialTimeout = 500 * time.Millisecond
|
||||
opt.ReadTimeout = 500 * time.Millisecond
|
||||
opt.WriteTimeout = 500 * time.Millisecond
|
||||
opt.PoolSize = 20
|
||||
client := redis.NewClient(opt)
|
||||
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
||||
defer cancel()
|
||||
if err := client.Ping(ctx).Err(); err != nil {
|
||||
_ = client.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &Store{client: client, ttl: ttl}, nil
|
||||
}
|
||||
|
||||
// Close закрывает пул при остановке процесса.
|
||||
func (s *Store) Close() error {
|
||||
return s.client.Close()
|
||||
}
|
||||
|
||||
// Ping — готовность кэша сессий. Недоступный Redis не означает «анонимный доступ».
|
||||
func (s *Store) Ping(ctx context.Context) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 300*time.Millisecond)
|
||||
defer cancel()
|
||||
if err := s.client.Ping(ctx).Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Issue выпускает 256 бит случайности (32 байта) и кладёт сессию с TTL.
|
||||
// Наружу уходит hex (64 символа). В Redis — только хеш.
|
||||
func (s *Store) Issue(ctx context.Context, userID uuid.UUID) (token string, expiresAt time.Time, err error) {
|
||||
buf := make([]byte, 32)
|
||||
if _, err = rand.Read(buf); err != nil {
|
||||
return "", time.Time{}, err
|
||||
}
|
||||
token = hex.EncodeToString(buf)
|
||||
expiresAt = time.Now().UTC().Add(s.ttl).Truncate(time.Millisecond)
|
||||
value := userID.String() + "|" + expiresAt.Format(time.RFC3339Nano)
|
||||
ctx, cancel := context.WithTimeout(ctx, time.Second)
|
||||
defer cancel()
|
||||
if err = s.client.Set(ctx, key(token), value, time.Until(expiresAt)).Err(); err != nil {
|
||||
return "", time.Time{}, ErrUnavailable
|
||||
}
|
||||
return token, expiresAt, nil
|
||||
}
|
||||
|
||||
// Lookup возвращает владельца живой сессии.
|
||||
// Промах и истёкший срок — ErrUnauthorized. Сбой Redis — ErrUnavailable (HTTP 503).
|
||||
func (s *Store) Lookup(ctx context.Context, token string) (uuid.UUID, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, time.Second)
|
||||
defer cancel()
|
||||
raw, err := s.client.Get(ctx, key(token)).Result()
|
||||
if errors.Is(err, redis.Nil) {
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
if err != nil {
|
||||
return uuid.Nil, ErrUnavailable
|
||||
}
|
||||
userPart, expPart, ok := strings.Cut(raw, "|")
|
||||
if !ok {
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
exp, err := time.Parse(time.RFC3339Nano, expPart)
|
||||
if err != nil || !exp.After(time.Now()) {
|
||||
_ = s.client.Del(ctx, key(token)).Err()
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
id, err := uuid.Parse(userPart)
|
||||
if err != nil {
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// Revoke удаляет текущую сессию. Повторный отзыв — это уже отсутствие ключа.
|
||||
func (s *Store) Revoke(ctx context.Context, token string) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, time.Second)
|
||||
defer cancel()
|
||||
n, err := s.client.Del(ctx, key(token)).Result()
|
||||
if err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
if n == 0 {
|
||||
return ErrUnauthorized
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func key(token string) string {
|
||||
sum := sha256.Sum256([]byte(token))
|
||||
return "sess:" + hex.EncodeToString(sum[:])
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
// Вложения lab4: метаданные в PostgreSQL, байты в S3 (пакет blob).
|
||||
//
|
||||
// Согласованность двух хранилищ строится на порядке «сначала S3, потом БД»:
|
||||
// 1. PUT объекта в S3 по серверному ключу;
|
||||
// 2. INSERT строки attachments.
|
||||
//
|
||||
// Если PUT прошёл, а INSERT нет, остаётся объект без строки (orphan). API пытается удалить
|
||||
// его сразу, а если не вышло, его удалит reconciler после grace period. Обратный порядок
|
||||
// опаснее: строка без объекта отдавала бы клиенту 201 на файл, которого нет.
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
// ErrNotReady — вложение существует в этом чате, но ещё не ready (в lab4 недостижимо,
|
||||
// зарезервировано под асинхронную обработку lab5).
|
||||
var ErrNotReady = errors.New("attachment not ready")
|
||||
|
||||
// Attachment — метаданные оригинала. ObjectKey во внешний JSON не попадает.
|
||||
type Attachment struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
OwnerID uuid.UUID
|
||||
Filename string
|
||||
ContentType string
|
||||
SizeBytes int64
|
||||
SHA256 string
|
||||
ObjectKey string
|
||||
Status string
|
||||
ErrorCode *string
|
||||
CreatedAt time.Time
|
||||
UpdatedAt time.Time
|
||||
}
|
||||
|
||||
// CreateAttachment пишет метаданные после успешного PUT в S3. ID и ObjectKey задаёт вызывающий:
|
||||
// ключ нужен до записи в БД. Членство в чате проверяется в самом INSERT — если автора уже
|
||||
// нет в чате, строка не появится и вернётся ErrNotFound.
|
||||
func (s *Store) CreateAttachment(ctx context.Context, a *Attachment) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
now := nowUTC()
|
||||
a.Status = "ready"
|
||||
a.ErrorCode = nil
|
||||
a.CreatedAt, a.UpdatedAt = now, now
|
||||
tag, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO attachments (
|
||||
id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
|
||||
object_key, status, error_code, created_at, updated_at
|
||||
)
|
||||
SELECT $1, $2, $3, $4, $5, $6, $7, $8, $9, NULL, $10, $10
|
||||
WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3)`,
|
||||
a.ID, a.ChatID, a.OwnerID, a.Filename, a.ContentType, a.SizeBytes, a.SHA256,
|
||||
a.ObjectKey, a.Status, a.CreatedAt)
|
||||
if err != nil {
|
||||
return mapWriteErr(err)
|
||||
}
|
||||
if tag.RowsAffected() != 1 {
|
||||
return ErrNotFound
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetAttachment отдаёт вложение только участнику его чата. Чужому и несуществующему —
|
||||
// одинаковый ErrNotFound (HTTP 404): наличие чужого файла не раскрываем.
|
||||
func (s *Store) GetAttachment(ctx context.Context, id, userID uuid.UUID) (*Attachment, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var a Attachment
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256,
|
||||
a.object_key, a.status, a.error_code, a.created_at, a.updated_at
|
||||
FROM attachments a
|
||||
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
|
||||
WHERE a.id = $1`, id, userID).Scan(
|
||||
&a.ID, &a.ChatID, &a.OwnerID, &a.Filename, &a.ContentType, &a.SizeBytes, &a.SHA256,
|
||||
&a.ObjectKey, &a.Status, &a.ErrorCode, &a.CreatedAt, &a.UpdatedAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return &a, nil
|
||||
}
|
||||
|
||||
// EnsureChatMember — публичная проверка «пользователь состоит в чате» (ErrNotFound иначе).
|
||||
func (s *Store) EnsureChatMember(ctx context.Context, chatID, userID uuid.UUID) error {
|
||||
return s.ensureMember(ctx, chatID, userID)
|
||||
}
|
||||
|
||||
// ListAttachmentIDsForMessage возвращает ID вложений сообщения в порядке запроса.
|
||||
// Пустой результат — непустой срез нулевой длины, чтобы JSON дал [], а не null.
|
||||
func (s *Store) ListAttachmentIDsForMessage(ctx context.Context, messageID uuid.UUID) ([]uuid.UUID, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
byMsg, err := attachmentIDsByMessage(ctx, s.pool, []uuid.UUID{messageID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return byMsg[messageID], nil
|
||||
}
|
||||
|
||||
// querier — общая часть pgxpool.Pool и pgx.Tx.
|
||||
type querier interface {
|
||||
Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
|
||||
}
|
||||
|
||||
// attachmentIDsByMessage — один запрос на страницу сообщений (без N+1).
|
||||
// Все ключи результата заполнены: у сообщений без вложений значение — пустой срез.
|
||||
//
|
||||
// q — пул или транзакция: внутри транзакции запрос обязан идти по её соединению, иначе при
|
||||
// маленьком пуле транзакция занимает соединение и ждёт второе.
|
||||
func attachmentIDsByMessage(ctx context.Context, q querier, messageIDs []uuid.UUID) (map[uuid.UUID][]uuid.UUID, error) {
|
||||
out := make(map[uuid.UUID][]uuid.UUID, len(messageIDs))
|
||||
if len(messageIDs) == 0 {
|
||||
return out, nil
|
||||
}
|
||||
strs := make([]string, len(messageIDs))
|
||||
for i, id := range messageIDs {
|
||||
out[id] = []uuid.UUID{}
|
||||
strs[i] = id.String()
|
||||
}
|
||||
rows, err := q.Query(ctx, `
|
||||
SELECT message_id, attachment_id
|
||||
FROM message_attachments
|
||||
WHERE message_id = ANY($1::uuid[])
|
||||
ORDER BY message_id, position`, strs)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var mid, aid uuid.UUID
|
||||
if err := rows.Scan(&mid, &aid); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
out[mid] = append(out[mid], aid)
|
||||
}
|
||||
return out, mapWriteErr(rows.Err())
|
||||
}
|
||||
|
||||
// AttachmentRef — строка attachments для reconciler: только то, что нужно для сверки с S3.
|
||||
type AttachmentRef struct {
|
||||
ID uuid.UUID
|
||||
ObjectKey string
|
||||
SizeBytes int64
|
||||
CreatedAt time.Time
|
||||
Referenced bool // есть ли хотя бы одно сообщение со ссылкой на файл
|
||||
}
|
||||
|
||||
// ListAttachmentRefs — keyset-страница по id. Страницы небольшие: у соединения
|
||||
// statement_timeout 3 с, один огромный SELECT на большой таблице под него не уложится.
|
||||
func (s *Store) ListAttachmentRefs(ctx context.Context, after uuid.UUID, limit int) ([]AttachmentRef, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT a.id, a.object_key, a.size_bytes, a.created_at,
|
||||
EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id)
|
||||
FROM attachments a
|
||||
WHERE a.id > $1
|
||||
ORDER BY a.id
|
||||
LIMIT $2`, after, limit)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []AttachmentRef
|
||||
for rows.Next() {
|
||||
var r AttachmentRef
|
||||
if err := rows.Scan(&r.ID, &r.ObjectKey, &r.SizeBytes, &r.CreatedAt, &r.Referenced); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
out = append(out, r)
|
||||
}
|
||||
return out, mapWriteErr(rows.Err())
|
||||
}
|
||||
|
||||
// AttachmentKeyExists — повторная проверка перед удалением orphan: между листингом S3
|
||||
// и удалением объект мог получить строку (загрузка закончилась). Это страховка поверх grace.
|
||||
func (s *Store) AttachmentKeyExists(ctx context.Context, objectKey string) (bool, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var ok bool
|
||||
err := s.pool.QueryRow(ctx,
|
||||
`SELECT EXISTS (SELECT 1 FROM attachments WHERE object_key = $1)`, objectKey).Scan(&ok)
|
||||
return ok, mapWriteErr(err)
|
||||
}
|
||||
|
||||
// DeleteUnreferencedAttachment удаляет строку, только если на неё нет ссылок из сообщений.
|
||||
// Условие NOT EXISTS в самом DELETE закрывает гонку «сообщение прикрепили, пока мы решали».
|
||||
// Возвращает true, если строка была удалена.
|
||||
func (s *Store) DeleteUnreferencedAttachment(ctx context.Context, id uuid.UUID) (bool, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
tag, err := s.pool.Exec(ctx, `
|
||||
DELETE FROM attachments a
|
||||
WHERE a.id = $1
|
||||
AND NOT EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id)`, id)
|
||||
if err != nil {
|
||||
return false, mapWriteErr(err)
|
||||
}
|
||||
return tag.RowsAffected() == 1, nil
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"embed"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
//go:embed migrations/*.sql
|
||||
var migrationFS embed.FS
|
||||
|
||||
// Migrate применяет встроенные SQL-файлы по одному разу.
|
||||
// Повторный старт процесса не создаёт вторую копию строк: версия пишется в schema_migrations.
|
||||
func (s *Store) Migrate(ctx context.Context) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
defer cancel()
|
||||
if _, err := s.pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
)`); err != nil {
|
||||
return fmt.Errorf("schema_migrations: %w", err)
|
||||
}
|
||||
entries, err := migrationFS.ReadDir("migrations")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
names := make([]string, 0, len(entries))
|
||||
for _, e := range entries {
|
||||
if !e.IsDir() && strings.HasSuffix(e.Name(), ".sql") {
|
||||
names = append(names, e.Name())
|
||||
}
|
||||
}
|
||||
sort.Strings(names)
|
||||
for _, name := range names {
|
||||
var exists bool
|
||||
if err := s.pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM schema_migrations WHERE version = $1)`, name).Scan(&exists); err != nil {
|
||||
return err
|
||||
}
|
||||
if exists {
|
||||
continue
|
||||
}
|
||||
body, err := migrationFS.ReadFile("migrations/" + name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// pgx в extended protocol не выполняет несколько команд одним Exec.
|
||||
for _, stmt := range splitSQL(string(body)) {
|
||||
if _, err := tx.Exec(ctx, stmt); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return fmt.Errorf("migrate %s: %w", name, err)
|
||||
}
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version) VALUES ($1)`, name); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return err
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// splitSQL делит файл миграции по ';'. В этих файлах нет строк с точкой с запятой внутри литералов.
|
||||
func splitSQL(body string) []string {
|
||||
parts := strings.Split(body, ";")
|
||||
out := make([]string, 0, len(parts))
|
||||
for _, part := range parts {
|
||||
stmt := strings.TrimSpace(part)
|
||||
if stmt == "" {
|
||||
continue
|
||||
}
|
||||
out = append(out, stmt)
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
-- Схема lab2. PostgreSQL — источник истины для пользователей, чатов и сообщений.
|
||||
-- Сессии здесь намеренно нет: их держит Redis с AOF, TTL не продлевается рестартом API.
|
||||
-- Повторный запуск безопасен: все объекты создаются через IF NOT EXISTS.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
-- Argon2id PHC-строка. Не SHA-256 и не plaintext. Наружу не отдаётся.
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT users_username_unique UNIQUE (username)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
-- Составной первичный ключ не даёт вставить участника дважды.
|
||||
-- Внешние ключи не дают сослаться на несуществующего пользователя или чат.
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
-- Список чатов пользователя начинается с фильтра «где я участник».
|
||||
CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
-- Keyset истории: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id.
|
||||
-- Составной индекс покрывает и фильтр, и порядок. Слабый индекс только по chat_id
|
||||
-- заставил бы сортировать историю чата. Его нет в продовой схеме, он появляется
|
||||
-- лишь на время эксперимента трека 2.
|
||||
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,23 @@
|
||||
-- Идемпотентность POST сообщения (lab3).
|
||||
-- Область ключа: (user_id, method, path, key).
|
||||
-- Разные пользователи и чаты могут независимо использовать одну строку Idempotency-Key.
|
||||
-- request_hash — SHA-256 канонического тела.
|
||||
-- Другой body при том же ключе даёт HTTP 409.
|
||||
-- response_* фиксируются только для успешного 201 в той же транзакции, что и INSERT messages.
|
||||
-- Транзиентный 5xx не сохраняется как окончательный результат.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS idempotency_keys (
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
method text NOT NULL,
|
||||
path text NOT NULL,
|
||||
key text NOT NULL,
|
||||
request_hash text NOT NULL,
|
||||
response_status integer NOT NULL,
|
||||
response_body jsonb NOT NULL,
|
||||
message_id uuid NOT NULL REFERENCES messages (id),
|
||||
created_at timestamptz NOT NULL,
|
||||
PRIMARY KEY (user_id, method, path, key)
|
||||
);
|
||||
|
||||
-- Индекс по времени — для будущей очистки хвоста старше 24 часов.
|
||||
CREATE INDEX IF NOT EXISTS idempotency_keys_created_idx ON idempotency_keys (created_at);
|
||||
@@ -0,0 +1,33 @@
|
||||
-- Вложения lab4. Метаданные в PostgreSQL, байты в приватном S3-bucket (MinIO).
|
||||
-- Ключ объекта назначает сервер: originals/<attachment_id>.
|
||||
-- filename только для отображения, в ключ не попадает.
|
||||
--
|
||||
-- ВНИМАНИЕ: файл режется по символу точки с запятой (см. splitSQL в migrate.go),
|
||||
-- поэтому в комментариях и литералах здесь нет этого символа.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS attachments (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
owner_id uuid NOT NULL REFERENCES users (id),
|
||||
filename text NOT NULL,
|
||||
content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')),
|
||||
size_bytes bigint NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
|
||||
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
|
||||
object_key text COLLATE "C" NOT NULL,
|
||||
status text NOT NULL DEFAULT 'ready' CHECK (status IN ('ready')),
|
||||
error_code text,
|
||||
created_at timestamptz NOT NULL,
|
||||
updated_at timestamptz NOT NULL,
|
||||
CONSTRAINT attachments_object_key_unique UNIQUE (object_key)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS attachments_chat_idx ON attachments (chat_id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS message_attachments (
|
||||
message_id uuid NOT NULL REFERENCES messages (id),
|
||||
attachment_id uuid NOT NULL REFERENCES attachments (id),
|
||||
position smallint NOT NULL CHECK (position >= 0),
|
||||
PRIMARY KEY (message_id, attachment_id)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS message_attachments_attachment_idx ON message_attachments (attachment_id);
|
||||
@@ -0,0 +1,723 @@
|
||||
// Package store — пользователи, чаты, сообщения и ключи идемпотентности в PostgreSQL.
|
||||
//
|
||||
// Источник истины — только эти таблицы. Память процесса после рестарта пуста,
|
||||
// поэтому ни одного map с данными здесь нет. Каждый запрос параметризован ($1, $2):
|
||||
// текст сообщения не склеивается в SQL.
|
||||
//
|
||||
// Создание чата — одна транзакция: строка чата и все участники фиксируются вместе
|
||||
// либо не фиксируются вообще. Уникальность username обеспечивает UNIQUE, а не проверка
|
||||
// «сначала SELECT, потом INSERT» (та проверка проигрывает гонке).
|
||||
//
|
||||
// Вложения (lab4) — файл attachments.go: метаданные в PostgreSQL, байты в S3. Сообщение
|
||||
// ссылается на вложения через message_attachments; ссылки пишутся в той же транзакции,
|
||||
// что и само сообщение и ключ идемпотентности.
|
||||
//
|
||||
// Идемпотентность сообщения тоже живёт в PostgreSQL, а не в памяти реплики:
|
||||
// два параллельных POST с одним ключом через разные API-контейнеры видят один PK.
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/binary"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"mtusi2026lab4/internal/auth"
|
||||
)
|
||||
|
||||
const queryTimeout = 3 * time.Second
|
||||
|
||||
// Ошибки домена. HTTP-слой переводит их в коды контракта и не показывает SQL.
|
||||
var (
|
||||
ErrConflict = errors.New("conflict")
|
||||
ErrNotFound = errors.New("not found")
|
||||
ErrInvalidCursor = errors.New("invalid cursor")
|
||||
ErrUnavailable = errors.New("unavailable")
|
||||
// ErrIdempotencyConflict — тот же ключ, но другое тело запроса.
|
||||
ErrIdempotencyConflict = errors.New("idempotency conflict")
|
||||
// ErrAttachmentNotReady — вложение существует, но ещё не ready (409 по контракту).
|
||||
// В lab4 все вложения создаются сразу ready; проверка нужна для lab5+ и защищает
|
||||
// от прикрепления недообработанного файла.
|
||||
ErrAttachmentNotReady = errors.New("attachment not ready")
|
||||
)
|
||||
|
||||
// User — публичные поля пользователя. Hash пароля в эту структуру не попадает.
|
||||
type User struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// Chat — чат и явный состав участников.
|
||||
type Chat struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
MemberIDs []uuid.UUID
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// Message — одно подтверждённое сообщение. sender_id назначает сервер.
|
||||
// AttachmentIDs всегда непустой срез нулевой длины, если вложений нет (JSON даёт []).
|
||||
type Message struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
AttachmentIDs []uuid.UUID
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// PageCursor — позиция keyset. Клиент видит только opaque-строку в пакете api.
|
||||
type PageCursor struct {
|
||||
CreatedAt time.Time
|
||||
ID uuid.UUID
|
||||
Scope string
|
||||
}
|
||||
|
||||
// Store — пул соединений. Пул ограничен, у каждого запроса свой таймаут.
|
||||
type Store struct {
|
||||
pool *pgxpool.Pool
|
||||
hasher *auth.Hasher
|
||||
}
|
||||
|
||||
// Open поднимает пул. ConnectTimeout короткий, чтобы недоступная БД быстро стала 503,
|
||||
// а не висела до клиентского таймаута теста.
|
||||
// maxConns — на одну реплику; при N репликах суммарный пул ≈ N*maxConns.
|
||||
func Open(ctx context.Context, databaseURL string, hasher *auth.Hasher, maxConns int32) (*Store, error) {
|
||||
if maxConns < 1 {
|
||||
maxConns = 5
|
||||
}
|
||||
cfg, err := pgxpool.ParseConfig(databaseURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse database url: %w", err)
|
||||
}
|
||||
cfg.MaxConns = maxConns
|
||||
cfg.MinConns = 1
|
||||
cfg.MaxConnLifetime = 30 * time.Minute
|
||||
cfg.MaxConnIdleTime = 5 * time.Minute
|
||||
cfg.HealthCheckPeriod = 30 * time.Second
|
||||
cfg.ConnConfig.ConnectTimeout = 2 * time.Second
|
||||
cfg.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error {
|
||||
// UTC, чтобы timestamptz читался так же, как мы его записали.
|
||||
// statement_timeout обрывает запрос, который внезапно решил сканировать всё.
|
||||
_, err := conn.Exec(ctx, `SET TIME ZONE 'UTC'; SET statement_timeout = '3s'`)
|
||||
return err
|
||||
}
|
||||
pool, err := pgxpool.NewWithConfig(ctx, cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pingCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
||||
defer cancel()
|
||||
if err := pool.Ping(pingCtx); err != nil {
|
||||
pool.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &Store{pool: pool, hasher: hasher}, nil
|
||||
}
|
||||
|
||||
// Close освобождает соединения при остановке процесса.
|
||||
func (s *Store) Close() {
|
||||
s.pool.Close()
|
||||
}
|
||||
|
||||
// Ping — проверка для /health/ready. Ошибка здесь значит «не готов», не «жив».
|
||||
func (s *Store) Ping(ctx context.Context) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 300*time.Millisecond)
|
||||
defer cancel()
|
||||
if err := s.pool.Ping(ctx); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CreateUser пишет пользователя. Повтор username → ErrConflict благодаря UNIQUE.
|
||||
func (s *Store) CreateUser(ctx context.Context, username, displayName, password string) (*User, error) {
|
||||
hash, err := auth.Hash(password)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
u := &User{
|
||||
ID: uuid.New(),
|
||||
Username: username,
|
||||
DisplayName: displayName,
|
||||
CreatedAt: nowUTC(),
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
_, err = s.pool.Exec(ctx, `
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)`,
|
||||
u.ID, u.Username, u.DisplayName, hash, u.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// Authenticate проверяет Basic-логин. Нет пользователя и неверный пароль
|
||||
// выглядят одинаково: оба дают false без отдельной ошибки «такого логина нет».
|
||||
func (s *Store) Authenticate(ctx context.Context, username, password string) (*User, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var u User
|
||||
var hash string
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT id, username, display_name, created_at, password_hash
|
||||
FROM users WHERE username = $1`, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
s.hasher.Burn(password)
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if !s.hasher.Verify(hash, password) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return &u, nil
|
||||
}
|
||||
|
||||
// GetUser нужен, чтобы ответ /users/me совпал с объектом из регистрации.
|
||||
func (s *Store) GetUser(ctx context.Context, id uuid.UUID) (*User, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var u User
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT id, username, display_name, created_at FROM users WHERE id = $1`, id).
|
||||
Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return &u, nil
|
||||
}
|
||||
|
||||
// CreateChat атомарно создаёт чат и состав. Неизвестный участник откатывает всё:
|
||||
// в таблице chats не остаётся «пустой» строки без полного состава.
|
||||
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []uuid.UUID) (*Chat, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
|
||||
chat := &Chat{
|
||||
ID: uuid.New(),
|
||||
Title: title,
|
||||
MemberIDs: append([]uuid.UUID(nil), memberIDs...),
|
||||
CreatedAt: nowUTC(),
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`,
|
||||
chat.ID, chat.Title, chat.CreatedAt); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
for _, uid := range memberIDs {
|
||||
// INSERT ... SELECT вставит 0 строк, если пользователя нет, и не нарушит FK.
|
||||
tag, err := tx.Exec(ctx, `
|
||||
INSERT INTO chat_members (chat_id, user_id)
|
||||
SELECT $1, id FROM users WHERE id = $2`, chat.ID, uid)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if tag.RowsAffected() != 1 {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return chat, nil
|
||||
}
|
||||
|
||||
// GetChat возвращает чат только участнику. Чужому — ErrNotFound (HTTP 404, не 403).
|
||||
func (s *Store) GetChat(ctx context.Context, chatID, userID uuid.UUID) (*Chat, error) {
|
||||
if err := s.ensureMember(ctx, chatID, userID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return s.loadChat(ctx, chatID)
|
||||
}
|
||||
|
||||
// ListChats — keyset по (created_at, id) только среди чатов этого пользователя.
|
||||
func (s *Store) ListChats(ctx context.Context, userID uuid.UUID, limit int, after *PageCursor) ([]Chat, *PageCursor, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var (
|
||||
rows pgx.Rows
|
||||
err error
|
||||
)
|
||||
if after == nil {
|
||||
rows, err = s.pool.Query(ctx, `
|
||||
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
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $2`, userID, limit+1)
|
||||
} else {
|
||||
rows, err = s.pool.Query(ctx, `
|
||||
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
|
||||
AND (c.created_at, c.id) > ($2, $3)
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $4`, userID, after.CreatedAt, after.ID, limit+1)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var items []Chat
|
||||
for rows.Next() {
|
||||
var c Chat
|
||||
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
items = append(items, c)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
next, items := trimPage(items, limit, func(c Chat) (time.Time, uuid.UUID) {
|
||||
return c.CreatedAt, c.ID
|
||||
})
|
||||
for i := range items {
|
||||
members, err := s.memberIDs(ctx, items[i].ID)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
items[i].MemberIDs = members
|
||||
}
|
||||
var cursor *PageCursor
|
||||
if next {
|
||||
last := items[len(items)-1]
|
||||
cursor = &PageCursor{CreatedAt: last.CreatedAt, ID: last.ID}
|
||||
}
|
||||
return items, cursor, nil
|
||||
}
|
||||
|
||||
// CreateMessage пишет сообщение только если отправитель состоит в чате.
|
||||
// Подтверждение — это COMMIT строки. Следующее чтение видит её без кэша истории.
|
||||
// Без идемпотентности — только для внутренних/тестовых случаев; HTTP использует CreateMessageIdempotent.
|
||||
func (s *Store) CreateMessage(ctx context.Context, chatID, senderID uuid.UUID, text string) (*Message, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
msg := &Message{
|
||||
ID: uuid.New(),
|
||||
ChatID: chatID,
|
||||
SenderID: senderID,
|
||||
Text: text,
|
||||
CreatedAt: nowUTC(),
|
||||
AttachmentIDs: []uuid.UUID{},
|
||||
}
|
||||
tag, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT $1, $2, $3, $4, $5
|
||||
WHERE EXISTS (
|
||||
SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3
|
||||
)`, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if tag.RowsAffected() != 1 {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return msg, nil
|
||||
}
|
||||
|
||||
// IdempotentMessage — либо только что созданное, либо ранее сохранённое по ключу сообщение.
|
||||
type IdempotentMessage struct {
|
||||
Message *Message
|
||||
Replayed bool
|
||||
}
|
||||
|
||||
// CreateMessageIdempotent атомарно создаёт сообщение со вложениями и запоминает ответ по ключу.
|
||||
//
|
||||
// Алгоритм (общая БД, любые реплики):
|
||||
// 1. BEGIN;
|
||||
// 2. pg_advisory_xact_lock по хешу (user, method, path, key) — сериализует конкурентов
|
||||
// ещё до INSERT messages, иначе два победителя гонки успели бы создать два сообщения;
|
||||
// 3. SELECT сохранённого ключа — если есть, сравнить hash и вернуть Message (с его вложениями);
|
||||
// 4. иначе проверить членство в чате и вложения: каждое должно существовать, лежать
|
||||
// в ЭТОМ чате и быть ready (чужое/неизвестное — ErrNotFound, не ready — ErrNotReady);
|
||||
// 5. INSERT message + message_attachments + idempotency_keys в той же транзакции;
|
||||
// 6. COMMIT (advisory lock снимается вместе с транзакцией).
|
||||
//
|
||||
// attachmentIDs уже без дубликатов (проверяет HTTP-слой), порядок сохраняется.
|
||||
// Пустой текст допустим только вместе с вложениями — это тоже проверяет HTTP-слой.
|
||||
// Другой request_hash → ErrIdempotencyConflict. Транзиентный 5xx сюда не попадает:
|
||||
// запись ключа только после успешной подготовки 201.
|
||||
func (s *Store) CreateMessageIdempotent(
|
||||
ctx context.Context,
|
||||
chatID, senderID uuid.UUID,
|
||||
text string,
|
||||
attachmentIDs []uuid.UUID,
|
||||
method, path, idemKey, requestHash string,
|
||||
) (*IdempotentMessage, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
if attachmentIDs == nil {
|
||||
attachmentIDs = []uuid.UUID{}
|
||||
}
|
||||
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
|
||||
lockKey := idempotencyLockKey(senderID, method, path, idemKey)
|
||||
if _, err := tx.Exec(ctx, `SELECT pg_advisory_xact_lock($1)`, lockKey); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
|
||||
var (
|
||||
storedHash string
|
||||
msgID uuid.UUID
|
||||
msgChat uuid.UUID
|
||||
msgSender uuid.UUID
|
||||
msgText string
|
||||
msgCreated time.Time
|
||||
)
|
||||
err = tx.QueryRow(ctx, `
|
||||
SELECT i.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at
|
||||
FROM idempotency_keys i
|
||||
JOIN messages m ON m.id = i.message_id
|
||||
WHERE i.user_id = $1 AND i.method = $2 AND i.path = $3 AND i.key = $4`,
|
||||
senderID, method, path, idemKey,
|
||||
).Scan(&storedHash, &msgID, &msgChat, &msgSender, &msgText, &msgCreated)
|
||||
if err == nil {
|
||||
if storedHash != requestHash {
|
||||
return nil, ErrIdempotencyConflict
|
||||
}
|
||||
byMsg, err := attachmentIDsByMessage(ctx, tx, []uuid.UUID{msgID})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return &IdempotentMessage{
|
||||
Message: &Message{
|
||||
ID: msgID,
|
||||
ChatID: msgChat,
|
||||
SenderID: msgSender,
|
||||
Text: msgText,
|
||||
AttachmentIDs: byMsg[msgID],
|
||||
CreatedAt: msgCreated,
|
||||
},
|
||||
Replayed: true,
|
||||
}, nil
|
||||
}
|
||||
if !errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
|
||||
var member int
|
||||
if err := tx.QueryRow(ctx, `
|
||||
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, senderID).Scan(&member); err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
|
||||
attStrs := make([]string, len(attachmentIDs))
|
||||
for i, id := range attachmentIDs {
|
||||
attStrs[i] = id.String()
|
||||
}
|
||||
if len(attStrs) > 0 {
|
||||
// chat_id = $2 — вложение другого чата неотличимо от несуществующего (404, не 403).
|
||||
rows, err := tx.Query(ctx, `
|
||||
SELECT status FROM attachments WHERE id = ANY($1::uuid[]) AND chat_id = $2`, attStrs, chatID)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
found, notReady := 0, false
|
||||
for rows.Next() {
|
||||
var status string
|
||||
if err := rows.Scan(&status); err != nil {
|
||||
rows.Close()
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
found++
|
||||
if status != "ready" {
|
||||
notReady = true
|
||||
}
|
||||
}
|
||||
rows.Close()
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if found != len(attStrs) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if notReady {
|
||||
return nil, ErrNotReady
|
||||
}
|
||||
}
|
||||
|
||||
msg := &Message{
|
||||
ID: uuid.New(),
|
||||
ChatID: chatID,
|
||||
SenderID: senderID,
|
||||
Text: text,
|
||||
AttachmentIDs: append([]uuid.UUID{}, attachmentIDs...),
|
||||
CreatedAt: nowUTC(),
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)`,
|
||||
msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if len(attStrs) > 0 {
|
||||
// WITH ORDINALITY сохраняет порядок attachment_ids из запроса.
|
||||
if _, err := tx.Exec(ctx, `
|
||||
INSERT INTO message_attachments (message_id, attachment_id, position)
|
||||
SELECT $1, u.id, (u.ord - 1)::smallint
|
||||
FROM unnest($2::uuid[]) WITH ORDINALITY AS u(id, ord)`, msg.ID, attStrs); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
}
|
||||
|
||||
// response_body заполняем каноническим Message JSON уже здесь, чтобы replay
|
||||
// не зависел от повторной сериализации в HTTP-слое с другим порядком полей.
|
||||
bodyJSON, err := json.Marshal(map[string]any{
|
||||
"id": msg.ID.String(),
|
||||
"chat_id": msg.ChatID.String(),
|
||||
"sender_id": msg.SenderID.String(),
|
||||
"text": msg.Text,
|
||||
"attachment_ids": attStrs,
|
||||
"created_at": msg.CreatedAt.UTC().Truncate(time.Millisecond).Format("2006-01-02T15:04:05.000Z"),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err = tx.Exec(ctx, `
|
||||
INSERT INTO idempotency_keys (
|
||||
user_id, method, path, key, request_hash,
|
||||
response_status, response_body, message_id, created_at
|
||||
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)`,
|
||||
senderID, method, path, idemKey, requestHash,
|
||||
201, bodyJSON, msg.ID, msg.CreatedAt); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return &IdempotentMessage{Message: msg, Replayed: false}, nil
|
||||
}
|
||||
|
||||
// idempotencyLockKey — стабильный int64 для pg_advisory_xact_lock из области ключа.
|
||||
func idempotencyLockKey(userID uuid.UUID, method, path, key string) int64 {
|
||||
sum := sha256.Sum256([]byte(userID.String() + "|" + method + "|" + path + "|" + key))
|
||||
return int64(binary.BigEndian.Uint64(sum[:8]))
|
||||
}
|
||||
|
||||
// ListMessages — keyset по индексу messages_history_idx. Берём limit+1 строку,
|
||||
// чтобы next_cursor был null, когда следующей записи уже нет.
|
||||
func (s *Store) ListMessages(ctx context.Context, chatID, userID uuid.UUID, limit int, after *PageCursor) ([]Message, *PageCursor, error) {
|
||||
if err := s.ensureMember(ctx, chatID, userID); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var (
|
||||
rows pgx.Rows
|
||||
err error
|
||||
)
|
||||
if after == nil {
|
||||
rows, err = s.pool.Query(ctx, `
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2`, chatID, limit+1)
|
||||
} else {
|
||||
rows, err = s.pool.Query(ctx, `
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4`, chatID, after.CreatedAt, after.ID, limit+1)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var items []Message
|
||||
for rows.Next() {
|
||||
var m Message
|
||||
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
items = append(items, m)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
hasNext, items := trimPage(items, limit, func(m Message) (time.Time, uuid.UUID) {
|
||||
return m.CreatedAt, m.ID
|
||||
})
|
||||
// Вложения страницы — одним запросом, а не по запросу на сообщение.
|
||||
ids := make([]uuid.UUID, len(items))
|
||||
for i := range items {
|
||||
ids[i] = items[i].ID
|
||||
}
|
||||
byMsg, err := attachmentIDsByMessage(ctx, s.pool, ids)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
for i := range items {
|
||||
items[i].AttachmentIDs = byMsg[items[i].ID]
|
||||
}
|
||||
var cursor *PageCursor
|
||||
if hasNext {
|
||||
last := items[len(items)-1]
|
||||
cursor = &PageCursor{CreatedAt: last.CreatedAt, ID: last.ID}
|
||||
}
|
||||
return items, cursor, nil
|
||||
}
|
||||
|
||||
// ChatExistsForTitle помогает тесту отката: после ошибки создания чата строки нет.
|
||||
func (s *Store) CountChatsByTitle(ctx context.Context, title string) (int, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var n int
|
||||
err := s.pool.QueryRow(ctx, `SELECT count(*) FROM chats WHERE title = $1`, title).Scan(&n)
|
||||
if err != nil {
|
||||
return 0, mapWriteErr(err)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
func (s *Store) ensureMember(ctx context.Context, chatID, userID uuid.UUID) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var one int
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, userID).Scan(&one)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return mapWriteErr(err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Store) loadChat(ctx context.Context, chatID uuid.UUID) (*Chat, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var c Chat
|
||||
err := s.pool.QueryRow(ctx, `SELECT id, title, created_at FROM chats WHERE id = $1`, chatID).
|
||||
Scan(&c.ID, &c.Title, &c.CreatedAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
c.MemberIDs, err = s.memberIDs(ctx, chatID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &c, nil
|
||||
}
|
||||
|
||||
func (s *Store) memberIDs(ctx context.Context, chatID uuid.UUID) ([]uuid.UUID, error) {
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT user_id FROM chat_members WHERE chat_id = $1 ORDER BY user_id`, chatID)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var ids []uuid.UUID
|
||||
for rows.Next() {
|
||||
var id uuid.UUID
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
return ids, mapWriteErr(rows.Err())
|
||||
}
|
||||
|
||||
func trimPage[T any](items []T, limit int, _ func(T) (time.Time, uuid.UUID)) (bool, []T) {
|
||||
if len(items) > limit {
|
||||
return true, items[:limit]
|
||||
}
|
||||
return false, items
|
||||
}
|
||||
|
||||
func nowUTC() time.Time {
|
||||
// Миллисекунда — точность, которую мы же и печатаем в JSON.
|
||||
return time.Now().UTC().Truncate(time.Millisecond)
|
||||
}
|
||||
|
||||
func mapWriteErr(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
var pgErr *pgconn.PgError
|
||||
if errors.As(err, &pgErr) && pgErr.Code == "23505" {
|
||||
return ErrConflict
|
||||
}
|
||||
if errors.Is(err, context.DeadlineExceeded) || isConn(err) {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func isConn(err error) bool {
|
||||
msg := err.Error()
|
||||
// Не логируем и не возвращаем клиенту эту строку. Здесь только классификация.
|
||||
switch {
|
||||
case errors.Is(err, pgx.ErrNoRows):
|
||||
return false
|
||||
default:
|
||||
if stringsContains(msg, "connection refused") ||
|
||||
stringsContains(msg, "failed to connect") ||
|
||||
stringsContains(msg, "conn closed") ||
|
||||
stringsContains(msg, "closed pool") ||
|
||||
stringsContains(msg, "broken pipe") ||
|
||||
stringsContains(msg, "connection reset") ||
|
||||
stringsContains(msg, "SQLSTATE 57P01") ||
|
||||
stringsContains(msg, "SQLSTATE 08006") ||
|
||||
stringsContains(msg, "SQLSTATE 08001") {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func stringsContains(s, sub string) bool {
|
||||
return len(s) >= len(sub) && (s == sub || len(sub) == 0 ||
|
||||
(func() bool { return contains(s, sub) })())
|
||||
}
|
||||
|
||||
func contains(s, sub string) bool {
|
||||
for i := 0; i+len(sub) <= len(s); i++ {
|
||||
if s[i:i+len(sub)] == sub {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
Executable
+31
@@ -0,0 +1,31 @@
|
||||
#!/bin/sh
|
||||
# Уровень 4: прямое неаутентифицированное чтение объекта из bucket должно отказать.
|
||||
# Ожидание: HTTP 403 (или отказ соединения / 400 Signature) — не 200 с телом файла.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
|
||||
BUCKET=${S3_BUCKET:-messenger-attachments}
|
||||
ENDPOINT=${S3_PUBLIC_ENDPOINT:-http://127.0.0.1:9000}
|
||||
# Любой ключ: даже несуществующий при private bucket не должен отдаваться анониму как 200+тело.
|
||||
URL="${ENDPOINT}/${BUCKET}/originals/does-not-exist"
|
||||
|
||||
code=$(curl -sS -o /tmp/private-bucket-body.$$ -w '%{http_code}' "$URL" || echo "000")
|
||||
body_len=$(wc -c < /tmp/private-bucket-body.$$ | tr -d ' ')
|
||||
rm -f /tmp/private-bucket-body.$$
|
||||
|
||||
echo "GET $URL → HTTP $code body_bytes=$body_len"
|
||||
case "$code" in
|
||||
200)
|
||||
echo "FAIL: anonymous GET returned 200" >&2
|
||||
exit 1
|
||||
;;
|
||||
000)
|
||||
echo "FAIL: could not reach MinIO at $ENDPOINT" >&2
|
||||
exit 1
|
||||
;;
|
||||
*)
|
||||
echo "PASS: anonymous access denied (HTTP $code)"
|
||||
exit 0
|
||||
;;
|
||||
esac
|
||||
Executable
+130
@@ -0,0 +1,130 @@
|
||||
#!/bin/sh
|
||||
# Уровень 4: ≥10 одновременных загрузок + пик RSS API-реплик.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
export BASE_URL=${BASE_URL:-http://127.0.0.1:8080}
|
||||
export N=${N:-12}
|
||||
export OUT=${OUT:-evidence/concurrent-uploads.txt}
|
||||
mkdir -p evidence
|
||||
|
||||
python3 - <<'PY'
|
||||
import base64, binascii, json, os, struct, subprocess, sys, threading, time, urllib.request, uuid, zlib
|
||||
|
||||
base = os.environ["BASE_URL"]
|
||||
n = int(os.environ["N"])
|
||||
out = os.environ["OUT"]
|
||||
|
||||
def req(method, path, data=None, headers=None, timeout=60):
|
||||
h = dict(headers or {})
|
||||
body = data
|
||||
if isinstance(data, (dict, list)):
|
||||
body = json.dumps(data).encode()
|
||||
h.setdefault("Content-Type", "application/json")
|
||||
r = urllib.request.Request(base + path, data=body, headers=h, method=method)
|
||||
with urllib.request.urlopen(r, timeout=timeout) as resp:
|
||||
return resp.status, resp.read()
|
||||
|
||||
def chunk(tag, data):
|
||||
return struct.pack(">I", len(data)) + tag + data + struct.pack(">I", binascii.crc32(tag + data) & 0xffffffff)
|
||||
|
||||
# 1024×1024 RGB, zlib level 0 → ~3 MiB: заметнее для RSS, всё ещё ≪ 10 MiB лимита.
|
||||
w = h = 1024
|
||||
ihdr = struct.pack(">IIBBBBB", w, h, 8, 2, 0, 0, 0)
|
||||
raw = b"".join(b"\x00" + bytes(w * 3) for _ in range(h))
|
||||
big = b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(raw, 0)) + chunk(b"IEND", b"")
|
||||
print(f"upload_size_bytes={len(big)}", flush=True)
|
||||
|
||||
uname = "cu_" + uuid.uuid4().hex[:10]
|
||||
password = "correct-horse-1"
|
||||
st, body = req("POST", "/api/v1/users", {"username": uname, "display_name": "CU", "password": password})
|
||||
assert st == 201, body
|
||||
uid = json.loads(body)["id"]
|
||||
basic = base64.b64encode(f"{uname}:{password}".encode()).decode()
|
||||
st, body = req("POST", "/api/v1/auth/sessions", headers={"Authorization": f"Basic {basic}"})
|
||||
assert st == 201, body
|
||||
token = json.loads(body)["token"]
|
||||
st, body = req("POST", "/api/v1/chats", {"title": "concurrent", "member_ids": [uid]},
|
||||
headers={"Authorization": f"Bearer {token}"})
|
||||
assert st == 201, body
|
||||
chat = json.loads(body)["id"]
|
||||
|
||||
def api_rss_kb():
|
||||
try:
|
||||
ids = subprocess.check_output(
|
||||
["docker", "compose", "--env-file", ".env", "ps", "-q", "api"], text=True
|
||||
).split()
|
||||
total = 0
|
||||
for i in ids:
|
||||
line = subprocess.check_output(
|
||||
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", i], text=True
|
||||
).strip()
|
||||
part = line.split("/")[0].strip()
|
||||
num = float("".join(ch for ch in part if ch.isdigit() or ch == "."))
|
||||
if "GiB" in part:
|
||||
total += int(num * 1024 * 1024)
|
||||
elif "MiB" in part:
|
||||
total += int(num * 1024)
|
||||
else:
|
||||
total += int(num)
|
||||
return total
|
||||
except Exception as e:
|
||||
print("rss_err", e, flush=True)
|
||||
return -1
|
||||
|
||||
rss_before = api_rss_kb()
|
||||
peak = {"v": rss_before}
|
||||
stop = threading.Event()
|
||||
|
||||
def monitor():
|
||||
while not stop.is_set():
|
||||
v = api_rss_kb()
|
||||
if v > peak["v"]:
|
||||
peak["v"] = v
|
||||
time.sleep(0.2)
|
||||
|
||||
mon = threading.Thread(target=monitor, daemon=True)
|
||||
mon.start()
|
||||
results = [None] * n
|
||||
barrier = threading.Barrier(n)
|
||||
|
||||
def worker(i):
|
||||
barrier.wait(60)
|
||||
try:
|
||||
r = urllib.request.Request(
|
||||
f"{base}/api/v1/chats/{chat}/attachments?filename=c{i}.png",
|
||||
data=big,
|
||||
headers={"Authorization": f"Bearer {token}", "Content-Type": "image/png"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(r, timeout=120) as resp:
|
||||
results[i] = resp.status
|
||||
except Exception as e:
|
||||
results[i] = str(e)
|
||||
|
||||
threads = [threading.Thread(target=worker, args=(i,)) for i in range(n)]
|
||||
t0 = time.time()
|
||||
for th in threads:
|
||||
th.start()
|
||||
for th in threads:
|
||||
th.join()
|
||||
elapsed = time.time() - t0
|
||||
stop.set()
|
||||
mon.join(timeout=1)
|
||||
rss_after = api_rss_kb()
|
||||
ok = sum(1 for r in results if r == 201)
|
||||
text = "\n".join([
|
||||
f"concurrent={n}",
|
||||
f"upload_bytes={len(big)}",
|
||||
f"ok_201={ok}",
|
||||
f"results={results}",
|
||||
f"elapsed_s={elapsed:.3f}",
|
||||
f"api_rss_kb_before={rss_before}",
|
||||
f"api_rss_kb_peak={peak['v']}",
|
||||
f"api_rss_kb_after={rss_after}",
|
||||
]) + "\n"
|
||||
print(text, end="")
|
||||
open(out, "w").write(text)
|
||||
sys.exit(0 if ok == n else 1)
|
||||
PY
|
||||
echo "wrote $OUT"
|
||||
Executable
+146
@@ -0,0 +1,146 @@
|
||||
#!/bin/sh
|
||||
# Трек 5: внедрить orphan + missing, показать dry-run и apply, доказать защиту fresh.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
OUT=${OUT:-evidence/reconcile.txt}
|
||||
mkdir -p evidence
|
||||
: >"$OUT"
|
||||
|
||||
log() { echo "$@" | tee -a "$OUT"; }
|
||||
|
||||
BUCKET=$(grep -E '^S3_BUCKET=' .env | cut -d= -f2-)
|
||||
BUCKET=${BUCKET:-messenger-attachments}
|
||||
ROOT_USER=$(grep -E '^MINIO_ROOT_USER=' .env | cut -d= -f2-)
|
||||
ROOT_PASS=$(grep -E '^MINIO_ROOT_PASSWORD=' .env | cut -d= -f2-)
|
||||
ROOT_USER=${ROOT_USER:-minioadmin}
|
||||
ROOT_PASS=${ROOT_PASS:-minioadmin-secret}
|
||||
ORPHAN_KEY="originals/00000000-0000-4000-8000-0000000000aa"
|
||||
|
||||
log "=== seed orphan object via root PutObject (python/minio not required: curl+aws style via go) ==="
|
||||
# Используем временный контейнер с нашим s3bootstrap-окружением нельзя для PUT.
|
||||
# Кладём объект через API MinIO SDK в одноразовом python boto? Проще — docker run с
|
||||
# нашим образом и маленьким go-one-liner... Пишем через awscli-совместимый путь:
|
||||
# minio client отсутствует → используем python3 + urllib подписанный запрос слишком сложен.
|
||||
# Простой путь: временный Go в scripts/seed_orphan — нет. Используем docker compose run
|
||||
# с entrypoint /s3bootstrap нельзя. Добавим флаг...
|
||||
# Практика: python boto3 если есть, иначе raw Put через minio-go в compose run server?
|
||||
# Самое простое — python3 и hashlib hmac для SigV4.
|
||||
|
||||
python3 - <<PY | tee -a "$OUT"
|
||||
import hashlib, hmac, datetime, urllib.request
|
||||
access="${ROOT_USER}"
|
||||
secret="${ROOT_PASS}"
|
||||
bucket="${BUCKET}"
|
||||
key="${ORPHAN_KEY}"
|
||||
host="127.0.0.1:9000"
|
||||
body=b"orphan-bytes"
|
||||
t=datetime.datetime.utcnow()
|
||||
amz=t.strftime("%Y%m%dT%H%M%SZ")
|
||||
datestamp=t.strftime("%Y%m%d")
|
||||
payload_hash=hashlib.sha256(body).hexdigest()
|
||||
canonical_headers=f"host:{host}\nx-amz-content-sha256:{payload_hash}\nx-amz-date:{amz}\n"
|
||||
signed_headers="host;x-amz-content-sha256;x-amz-date"
|
||||
canonical_request="\n".join([
|
||||
"PUT", f"/{bucket}/{key}", "", canonical_headers, signed_headers, payload_hash
|
||||
])
|
||||
credential_scope=f"{datestamp}/us-east-1/s3/aws4_request"
|
||||
string_to_sign="\n".join([
|
||||
"AWS4-HMAC-SHA256", amz, credential_scope, hashlib.sha256(canonical_request.encode()).hexdigest()
|
||||
])
|
||||
def sign(key, msg):
|
||||
return hmac.new(key, msg.encode(), hashlib.sha256).digest()
|
||||
kDate=sign(("AWS4"+secret).encode(), datestamp)
|
||||
kRegion=sign(kDate, "us-east-1")
|
||||
kService=sign(kRegion, "s3")
|
||||
kSigning=sign(kService, "aws4_request")
|
||||
signature=hmac.new(kSigning, string_to_sign.encode(), hashlib.sha256).hexdigest()
|
||||
auth=f"AWS4-HMAC-SHA256 Credential={access}/{credential_scope}, SignedHeaders={signed_headers}, Signature={signature}"
|
||||
req=urllib.request.Request(
|
||||
f"http://{host}/{bucket}/{key}", data=body, method="PUT",
|
||||
headers={
|
||||
"Host": host,
|
||||
"x-amz-content-sha256": payload_hash,
|
||||
"x-amz-date": amz,
|
||||
"Authorization": auth,
|
||||
"Content-Length": str(len(body)),
|
||||
},
|
||||
)
|
||||
try:
|
||||
with urllib.request.urlopen(req) as resp:
|
||||
print("orphan_put", resp.status)
|
||||
except Exception as e:
|
||||
print("orphan_put_err", e)
|
||||
raise
|
||||
PY
|
||||
|
||||
log "=== seed missing metadata (DB row, no S3 object) ==="
|
||||
docker compose --env-file .env exec -T postgres \
|
||||
psql -U messenger -d messenger -v ON_ERROR_STOP=1 <<'SQL' | tee -a "$OUT"
|
||||
DO $$
|
||||
DECLARE
|
||||
uid uuid;
|
||||
cid uuid;
|
||||
aid uuid := '11111111-1111-4111-8111-111111111111';
|
||||
BEGIN
|
||||
SELECT id INTO uid FROM users LIMIT 1;
|
||||
IF uid IS NULL THEN
|
||||
RAISE NOTICE 'no users yet — skip missing seed';
|
||||
RETURN;
|
||||
END IF;
|
||||
SELECT c.id INTO cid
|
||||
FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = uid
|
||||
LIMIT 1;
|
||||
IF cid IS NULL THEN
|
||||
RAISE NOTICE 'no chat — skip missing seed';
|
||||
RETURN;
|
||||
END IF;
|
||||
INSERT INTO attachments (
|
||||
id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
|
||||
object_key, status, error_code, created_at, updated_at
|
||||
) VALUES (
|
||||
aid, cid, uid, 'missing.png', 'image/png', 12,
|
||||
'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
|
||||
'originals/11111111-1111-4111-8111-111111111111',
|
||||
'ready', NULL,
|
||||
now() - interval '2 hours', now() - interval '2 hours'
|
||||
) ON CONFLICT (id) DO UPDATE SET created_at = EXCLUDED.created_at, updated_at = EXCLUDED.updated_at;
|
||||
END $$;
|
||||
SQL
|
||||
|
||||
log "=== dry-run grace=0 ==="
|
||||
docker compose --env-file .env run --rm --no-deps reconcile -grace-seconds=0 2>&1 | tee -a "$OUT"
|
||||
|
||||
log "=== apply grace=0 ==="
|
||||
docker compose --env-file .env run --rm --no-deps reconcile -apply -grace-seconds=0 2>&1 | tee -a "$OUT"
|
||||
|
||||
log "=== second apply (idempotent) ==="
|
||||
docker compose --env-file .env run --rm --no-deps reconcile -apply -grace-seconds=0 2>&1 | tee -a "$OUT"
|
||||
|
||||
log "=== fresh orphan skipped with default grace ==="
|
||||
python3 - <<PY | tee -a "$OUT"
|
||||
import hashlib, hmac, datetime, urllib.request
|
||||
access="${ROOT_USER}"; secret="${ROOT_PASS}"; bucket="${BUCKET}"
|
||||
key="originals/00000000-0000-4000-8000-0000000000bb"
|
||||
host="127.0.0.1:9000"; body=b"fresh"
|
||||
t=datetime.datetime.utcnow(); amz=t.strftime("%Y%m%dT%H%M%SZ"); datestamp=t.strftime("%Y%m%d")
|
||||
payload_hash=hashlib.sha256(body).hexdigest()
|
||||
canonical_headers=f"host:{host}\nx-amz-content-sha256:{payload_hash}\nx-amz-date:{amz}\n"
|
||||
signed_headers="host;x-amz-content-sha256;x-amz-date"
|
||||
canonical_request="\n".join(["PUT", f"/{bucket}/{key}", "", canonical_headers, signed_headers, payload_hash])
|
||||
credential_scope=f"{datestamp}/us-east-1/s3/aws4_request"
|
||||
string_to_sign="\n".join(["AWS4-HMAC-SHA256", amz, credential_scope, hashlib.sha256(canonical_request.encode()).hexdigest()])
|
||||
def sign(key, msg): return hmac.new(key, msg.encode(), hashlib.sha256).digest()
|
||||
kSigning=sign(sign(sign(sign(("AWS4"+secret).encode(), datestamp), "us-east-1"), "s3"), "aws4_request")
|
||||
signature=hmac.new(kSigning, string_to_sign.encode(), hashlib.sha256).hexdigest()
|
||||
auth=f"AWS4-HMAC-SHA256 Credential={access}/{credential_scope}, SignedHeaders={signed_headers}, Signature={signature}"
|
||||
req=urllib.request.Request(f"http://{host}/{bucket}/{key}", data=body, method="PUT", headers={
|
||||
"Host": host, "x-amz-content-sha256": payload_hash, "x-amz-date": amz, "Authorization": auth,
|
||||
"Content-Length": str(len(body)),
|
||||
})
|
||||
with urllib.request.urlopen(req) as resp:
|
||||
print("fresh_put", resp.status)
|
||||
PY
|
||||
docker compose --env-file .env run --rm --no-deps reconcile 2>&1 | tee -a "$OUT"
|
||||
|
||||
log "wrote $OUT"
|
||||
Executable
+7
@@ -0,0 +1,7 @@
|
||||
#!/bin/sh
|
||||
# Перезапуск API (всех реплик), LB и всех хранилищ без удаления volumes.
|
||||
# Важно: именно restart, а не up -d — иначе PID/StartedAt у живых контейнеров не меняются.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
docker compose --env-file .env restart postgres redis minio api lb
|
||||
Executable
+42
@@ -0,0 +1,42 @@
|
||||
#!/bin/sh
|
||||
# Поднимает недостающие / остановленные API-реплики до API_REPLICAS после stop-one.
|
||||
# Не трогает volumes и не делает down -v. Миграции уже применены — не пересоздаём migrate.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
API_REPLICAS=$(grep -E '^API_REPLICAS=' .env 2>/dev/null | cut -d= -f2- || true)
|
||||
API_REPLICAS=${API_REPLICAS:-2}
|
||||
|
||||
# Стартуем остановленные контейнеры сервиса api и добираем scale при нехватке.
|
||||
docker compose --env-file .env start api 2>/dev/null || true
|
||||
docker compose --env-file .env up -d --no-deps --scale "api=${API_REPLICAS}" api
|
||||
|
||||
deadline=$(( $(date +%s) + 90 ))
|
||||
while :; do
|
||||
if curl -fsS "http://127.0.0.1:8080/health/ready" >/dev/null 2>&1; then
|
||||
# Ждём, пока LB реально видит ≥2 instance id (не только один backend).
|
||||
ids=$(
|
||||
python3 - <<'PY'
|
||||
import urllib.request
|
||||
ids=set()
|
||||
for _ in range(24):
|
||||
try:
|
||||
with urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=1) as r:
|
||||
i=r.headers.get('X-Instance-Id')
|
||||
if i: ids.add(i)
|
||||
except Exception:
|
||||
pass
|
||||
print(len(ids))
|
||||
PY
|
||||
)
|
||||
if [ "$ids" -ge 2 ] || [ "$API_REPLICAS" -lt 2 ]; then
|
||||
exit 0
|
||||
fi
|
||||
fi
|
||||
if [ "$(date +%s)" -ge "$deadline" ]; then
|
||||
echo "restore timeout (replicas visible via LB: ${ids:-0})" >&2
|
||||
docker compose --env-file .env ps >&2 || true
|
||||
exit 1
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
Executable
+44
@@ -0,0 +1,44 @@
|
||||
#!/bin/sh
|
||||
# Останавливает РОВНО одну API-реплику, чей X-Instance-Id = TARGET_INSTANCE_ID.
|
||||
# Реплика остаётся остановленной; восстановление — scripts/restore-one.sh или compose up.
|
||||
# Не трогает postgres/redis/lb/volumes. Должен завершиться за <10 с.
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
|
||||
ids=$(docker compose --env-file .env ps -q api)
|
||||
if [ -z "$ids" ]; then
|
||||
echo "no api containers" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
found=0
|
||||
for id in $ids; do
|
||||
# Совпадает с config.InstanceID: hostname контейнера, если INSTANCE_ID не задан.
|
||||
hostname=$(docker inspect -f '{{.Config.Hostname}}' "$id")
|
||||
env_id=$(docker inspect -f '{{range .Config.Env}}{{println .}}{{end}}' "$id" | sed -n 's/^INSTANCE_ID=//p' | head -n1)
|
||||
match=$hostname
|
||||
if [ -n "$env_id" ]; then
|
||||
match=$env_id
|
||||
fi
|
||||
if [ "$match" = "$TARGET_INSTANCE_ID" ]; then
|
||||
# Явный stop контейнера; restart: "no" у api гарантирует, что он не вернётся сам.
|
||||
docker stop -t 8 "$id" >/dev/null
|
||||
# Подтверждаем, что контейнер действительно не running — иначе failover-тест врёт.
|
||||
state=$(docker inspect -f '{{.State.Running}}' "$id")
|
||||
if [ "$state" = "true" ]; then
|
||||
echo "container still running after stop" >&2
|
||||
exit 1
|
||||
fi
|
||||
found=1
|
||||
break
|
||||
fi
|
||||
done
|
||||
|
||||
if [ "$found" -ne 1 ]; then
|
||||
echo "TARGET_INSTANCE_ID not found among api replicas" >&2
|
||||
exit 1
|
||||
fi
|
||||
exit 0
|
||||
Executable
+38
@@ -0,0 +1,38 @@
|
||||
#!/bin/sh
|
||||
# Единая последовательность запуска стенда lab4.
|
||||
# 1) postgres+redis+minio 2) bootstrap bucket 3) миграции 4) API×N 5) HAProxy
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
|
||||
if [ ! -f .env ]; then
|
||||
cp .env.example .env
|
||||
echo "created .env from .env.example" >&2
|
||||
fi
|
||||
|
||||
API_REPLICAS=$(grep -E '^API_REPLICAS=' .env | cut -d= -f2- || true)
|
||||
API_REPLICAS=${API_REPLICAS:-2}
|
||||
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build postgres redis minio
|
||||
docker compose --env-file .env run --rm minio-init
|
||||
docker compose --env-file .env run --rm --build migrate
|
||||
docker compose --env-file .env up -d --build --scale "api=${API_REPLICAS}" --no-deps api
|
||||
docker compose --env-file .env up -d --no-deps lb
|
||||
|
||||
echo "waiting for http://127.0.0.1:8080/health/ready via LB..."
|
||||
deadline=$(( $(date +%s) + 180 ))
|
||||
while :; do
|
||||
if curl -fsS "http://127.0.0.1:8080/health/ready" >/dev/null 2>&1; then
|
||||
echo "ready"
|
||||
docker compose --env-file .env ps
|
||||
exit 0
|
||||
fi
|
||||
if [ "$(date +%s)" -ge "$deadline" ]; then
|
||||
echo "timeout waiting for readiness" >&2
|
||||
docker compose --env-file .env ps >&2 || true
|
||||
docker compose --env-file .env logs --tail=80 api lb minio minio-init >&2 || true
|
||||
exit 1
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
@@ -0,0 +1,664 @@
|
||||
// Собственные проверки lab3 (плюс регрессия lab2). Им нужен уже поднятый
|
||||
// PostgreSQL и Redis (docker compose up / scripts/up.sh): контракт требует
|
||||
// настоящую БД, а не sqlmock. HTTP бьём в httptest.Server поверх того же Store,
|
||||
// что и реплики — идемпотентность и гонки видны без обхода LB.
|
||||
//
|
||||
// Каждый тест пишет в лог, что именно проверяет и какой статус получил.
|
||||
package studenttests
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026lab4/internal/api"
|
||||
"mtusi2026lab4/internal/auth"
|
||||
"mtusi2026lab4/internal/blob"
|
||||
"mtusi2026lab4/internal/session"
|
||||
"mtusi2026lab4/internal/store"
|
||||
)
|
||||
|
||||
var (
|
||||
sharedStore *store.Store
|
||||
sharedSessions *session.Store
|
||||
sharedRedisURL string
|
||||
)
|
||||
|
||||
func TestMain(m *testing.M) {
|
||||
ctx := context.Background()
|
||||
dsn := getenv("DATABASE_URL", "postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable")
|
||||
sharedRedisURL = getenv("REDIS_URL", "redis://127.0.0.1:6379/0")
|
||||
hasher, err := auth.NewHasher()
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "hasher:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
sharedStore, err = store.Open(ctx, dsn, hasher, 5)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "postgres:", err)
|
||||
fmt.Fprintln(os.Stderr, "подсказка: docker compose --env-file .env up -d --build")
|
||||
os.Exit(1)
|
||||
}
|
||||
defer sharedStore.Close()
|
||||
if err := sharedStore.Migrate(ctx); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "migrate:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
// Повтор миграции не должен падать и не должен дублировать данные.
|
||||
if err := sharedStore.Migrate(ctx); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "migrate second:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
sharedSessions, err = session.Open(sharedRedisURL, time.Hour)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "redis:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
defer sharedSessions.Close()
|
||||
os.Exit(m.Run())
|
||||
}
|
||||
|
||||
func TestMalformedJSONAndValidation(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "битый JSON, хвост после объекта, лишнее поле, пустой текст, чужой чат")
|
||||
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/users", nil, "{")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest || !strings.Contains(body, "invalid_request") {
|
||||
t.Fatalf("malformed json: status=%d body=%s", status, body)
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/users", nil,
|
||||
`{"username":"abc","display_name":"Имя","password":"correct-horse-1","extra":1}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("extra field: status=%d", status)
|
||||
}
|
||||
|
||||
user := register(t, srv, "ok_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, token, user.id, "Чат проверки")
|
||||
auth := map[string]string{"Authorization": "Bearer " + token}
|
||||
|
||||
// Decoder.More() это не ловит: один объект декодируется, лишняя скобка остаётся.
|
||||
for _, raw := range []string{`{"text":"valid"}}`, `{"text":"valid"}]`} {
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, raw)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("trailing garbage %q: status=%d body=%s", raw, status, body)
|
||||
}
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, `{"text":" "}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("blank message: status=%d", status)
|
||||
}
|
||||
|
||||
outsider := register(t, srv, "outsider")
|
||||
outTok := login(t, srv, outsider.username, outsider.password)
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{"Authorization": "Bearer " + outTok}, `{"text":"чужое"}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("foreign chat: status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "валидация JSON, хвоста, пустого текста и чужого чата")
|
||||
}
|
||||
|
||||
func TestMessageTextPreservedAndLengthOnOriginal(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "пробелы по краям сохраняются; длина считается по исходному тексту")
|
||||
user := register(t, srv, "text_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, token, user.id, "Текст")
|
||||
auth := map[string]string{"Authorization": "Bearer " + token}
|
||||
|
||||
original := " строка\nс пробелами "
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth,
|
||||
fmt.Sprintf(`{"text":%q}`, original))
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("preserve spaces: status=%d", status)
|
||||
}
|
||||
got := decode(t, body)
|
||||
if got["text"] != original {
|
||||
t.Fatalf("text mutated: got %q want %q", got["text"], original)
|
||||
}
|
||||
|
||||
tooLong := " " + strings.Repeat("a", 4000) // 4001 code points
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth,
|
||||
fmt.Sprintf(`{"text":%q}`, tooLong))
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("length after trim bypass: status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "текст сохранён целиком, обход лимита через TrimSpace закрыт")
|
||||
}
|
||||
|
||||
func TestSessionRejectsJSONBody(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "POST /auth/sessions с телом должен быть 400 даже при верном Basic")
|
||||
user := register(t, srv, "body_user")
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{
|
||||
"Authorization": "Basic " + basic(user.username, user.password),
|
||||
}, `{"extra":1}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("session with body: status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "вход без JSON body")
|
||||
}
|
||||
|
||||
func TestWrongPasswordLogoutAndIgnoredUserHeader(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "неверный пароль, Basic на бизнес-методе, X-User-Id, logout")
|
||||
user := register(t, srv, "auth_user")
|
||||
other := register(t, srv, "auth_other")
|
||||
|
||||
status, body, hdr := doRaw(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{
|
||||
"Authorization": "Basic " + basic(user.username, "wrong-password-1"),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnauthorized || !strings.HasPrefix(hdr.Get("WWW-Authenticate"), "Basic") {
|
||||
t.Fatalf("wrong password: status=%d www=%q", status, hdr.Get("WWW-Authenticate"))
|
||||
}
|
||||
|
||||
token := login(t, srv, user.username, user.password)
|
||||
status, body, hdr = doRaw(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{
|
||||
"Authorization": "Basic " + basic(user.username, user.password),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnauthorized || !strings.HasPrefix(hdr.Get("WWW-Authenticate"), "Bearer") {
|
||||
t.Fatalf("basic on business endpoint: status=%d www=%q", status, hdr.Get("WWW-Authenticate"))
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"X-User-Id": user.id}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("X-User-Id alone: status=%d", status)
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{
|
||||
"Authorization": "Bearer " + token,
|
||||
"X-User-Id": other.id,
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusOK || !strings.Contains(body, user.id) || strings.Contains(body, other.id) {
|
||||
t.Fatalf("X-User-Id overrode bearer: status=%d body=%s", status, body)
|
||||
}
|
||||
|
||||
status, _ = do(t, srv, http.MethodDelete, "/api/v1/auth/sessions/current", map[string]string{"Authorization": "Bearer " + token}, "")
|
||||
t.Logf("logout status=%d", status)
|
||||
if status != http.StatusNoContent {
|
||||
t.Fatalf("logout status=%d", status)
|
||||
}
|
||||
status, _ = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"Authorization": "Bearer " + token}, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("token still valid after logout: %d", status)
|
||||
}
|
||||
status, _ = do(t, srv, http.MethodDelete, "/api/v1/auth/sessions/current", map[string]string{"Authorization": "Bearer " + token}, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("second logout status=%d", status)
|
||||
}
|
||||
logOK(t, "пароль, заголовки и отзыв сессии")
|
||||
}
|
||||
|
||||
func TestSessionExpiry(t *testing.T) {
|
||||
srv := newAPI(t, 2*time.Second)
|
||||
defer srv.Close()
|
||||
logStep(t, "SESSION_TTL=2s: тот же токен после паузы должен стать 401, TTL рестартом API не продлевается")
|
||||
user := register(t, srv, "ttl_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
time.Sleep(2500 * time.Millisecond)
|
||||
status, body := do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"Authorization": "Bearer " + token}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("expired token status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "истёкшая сессия отклонена")
|
||||
}
|
||||
|
||||
func TestDuplicateUsernameRace(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
name := "race_" + uuid.NewString()[:8]
|
||||
logStep(t, "8 параллельных регистраций username="+name)
|
||||
const n = 8
|
||||
codes := make([]int, n)
|
||||
var wg sync.WaitGroup
|
||||
body := fmt.Sprintf(`{"username":%q,"display_name":"Гонка","password":"correct-horse-1"}`, name)
|
||||
for i := 0; i < n; i++ {
|
||||
wg.Add(1)
|
||||
go func(i int) {
|
||||
defer wg.Done()
|
||||
status, _ := do(t, srv, http.MethodPost, "/api/v1/users", nil, body)
|
||||
codes[i] = status
|
||||
}(i)
|
||||
}
|
||||
wg.Wait()
|
||||
ok, conflict := 0, 0
|
||||
for _, c := range codes {
|
||||
switch c {
|
||||
case http.StatusCreated:
|
||||
ok++
|
||||
case http.StatusConflict:
|
||||
conflict++
|
||||
default:
|
||||
t.Errorf("unexpected status %d", c)
|
||||
}
|
||||
}
|
||||
t.Logf("created=%d conflict=%d", ok, conflict)
|
||||
if ok != 1 || conflict != n-1 {
|
||||
t.Fatalf("race result created=%d conflict=%d", ok, conflict)
|
||||
}
|
||||
logOK(t, "UNIQUE username выдержал гонку")
|
||||
}
|
||||
|
||||
func TestChatCreateRollsBack(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
user := register(t, srv, "roll_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
title := "rollback-" + uuid.NewString()
|
||||
missing := uuid.NewString()
|
||||
logStep(t, "создание чата с несуществующим участником должно откатиться, title="+title)
|
||||
raw := fmt.Sprintf(`{"title":%q,"member_ids":[%q,%q]}`, title, user.id, missing)
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats", map[string]string{"Authorization": "Bearer " + token}, raw)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("status=%d", status)
|
||||
}
|
||||
n, err := sharedStore.CountChatsByTitle(context.Background(), title)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Logf("строк chats с этим title после ошибки: %d", n)
|
||||
if n != 0 {
|
||||
t.Fatalf("chat row survived rollback: %d", n)
|
||||
}
|
||||
logOK(t, "транзакция создания чата откатилась")
|
||||
}
|
||||
|
||||
func TestPaginationPages(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "три сообщения, две страницы limit=2, затем последняя")
|
||||
user := register(t, srv, "page_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, token, user.id, "Страницы")
|
||||
auth := map[string]string{"Authorization": "Bearer " + token}
|
||||
for _, text := range []string{"раз", "два", "три"} {
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, fmt.Sprintf(`{"text":%q}`, text))
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("post message %s: %d %s", text, status, body)
|
||||
}
|
||||
}
|
||||
status, body := do(t, srv, http.MethodGet, "/api/v1/chats/"+chat+"/messages?limit=2", auth, "")
|
||||
logResult(t, status, body)
|
||||
page := decode(t, body)
|
||||
items, _ := page["items"].([]any)
|
||||
if status != http.StatusOK || len(items) != 2 || page["next_cursor"] == nil {
|
||||
t.Fatalf("page1: %+v", page)
|
||||
}
|
||||
cursor, _ := page["next_cursor"].(string)
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/chats/"+chat+"/messages?limit=2&cursor="+cursor, auth, "")
|
||||
logResult(t, status, body)
|
||||
page = decode(t, body)
|
||||
items, _ = page["items"].([]any)
|
||||
if len(items) != 1 || page["next_cursor"] != nil {
|
||||
t.Fatalf("page2: %+v", page)
|
||||
}
|
||||
logOK(t, "keyset обошёл историю без зависания cursor")
|
||||
}
|
||||
|
||||
func TestRedisDownIsNotAnonymous(t *testing.T) {
|
||||
logStep(t, "закрытый клиент Redis: вход и Bearer дают 503, а не 200 от анонима")
|
||||
closed, err := session.Open(sharedRedisURL, time.Hour)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := closed.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
srv := httptest.NewServer(api.New(sharedStore, closed, blob.NewMemory(), "test-closed-redis").Handler())
|
||||
defer srv.Close()
|
||||
regSrv := newAPI(t, time.Hour)
|
||||
defer regSrv.Close()
|
||||
user := register(t, regSrv, "redis_down")
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{
|
||||
"Authorization": "Basic " + basic(user.username, user.password),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable {
|
||||
t.Fatalf("login with dead redis: status=%d body=%s", status, body)
|
||||
}
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{
|
||||
"Authorization": "Bearer " + strings.Repeat("ab", 32),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable {
|
||||
t.Fatalf("bearer with dead redis: status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "сбой Redis не стал анонимным доступом")
|
||||
}
|
||||
|
||||
func TestPostgresDownIsNotAnonymous(t *testing.T) {
|
||||
logStep(t, "закрытый пул PostgreSQL: ready/me/login дают 503, без тела пользователя")
|
||||
regSrv := newAPI(t, time.Hour)
|
||||
defer regSrv.Close()
|
||||
user := register(t, regSrv, "pg_down")
|
||||
token := login(t, regSrv, user.username, user.password)
|
||||
|
||||
hasher, err := auth.NewHasher()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
dsn := getenv("DATABASE_URL", "postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable")
|
||||
broken, err := store.Open(context.Background(), dsn, hasher, 5)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
broken.Close()
|
||||
sessions, err := session.Open(sharedRedisURL, time.Hour)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = sessions.Close() })
|
||||
srv := httptest.NewServer(api.New(broken, sessions, blob.NewMemory(), "test-broken-pg").Handler())
|
||||
defer srv.Close()
|
||||
|
||||
status, body := do(t, srv, http.MethodGet, "/health/ready", nil, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable {
|
||||
t.Fatalf("ready with dead postgres: %d", status)
|
||||
}
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{
|
||||
"Authorization": "Bearer " + token,
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable || strings.Contains(body, `"username"`) {
|
||||
t.Fatalf("me with dead postgres: status=%d body=%s", status, body)
|
||||
}
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{
|
||||
"Authorization": "Basic " + basic(user.username, user.password),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable {
|
||||
t.Fatalf("login with dead postgres: status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "сбой PostgreSQL не стал анонимным доступом")
|
||||
}
|
||||
|
||||
|
||||
func TestIdempotencyReplayAndConflict(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "повтор того же Idempotency-Key возвращает то же сообщение; другой body — 409")
|
||||
user := register(t, srv, "idem_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, token, user.id, "Идемпотентность")
|
||||
key := "key-" + uuid.NewString()
|
||||
auth := map[string]string{
|
||||
"Authorization": "Bearer " + token,
|
||||
"Idempotency-Key": key,
|
||||
}
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, `{"text":"один раз"}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("first: %d %s", status, body)
|
||||
}
|
||||
first := decode(t, body)
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, `{"text":"один раз"}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("replay: %d %s", status, body)
|
||||
}
|
||||
second := decode(t, body)
|
||||
if first["id"] != second["id"] || first["text"] != second["text"] {
|
||||
t.Fatalf("replay differs: first=%v second=%v", first, second)
|
||||
}
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, `{"text":"другой body"}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusConflict {
|
||||
t.Fatalf("conflict: %d %s", status, body)
|
||||
}
|
||||
logOK(t, "replay и conflict по Idempotency-Key")
|
||||
}
|
||||
|
||||
func TestIdempotencyKeyRequiredAndConcurrent(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "нет ключа → 400; 8 параллельных POST с одним ключом → ровно одно сообщение")
|
||||
user := register(t, srv, "idem_race")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, token, user.id, "Гонка ключа")
|
||||
|
||||
// Явно без ключа: хелпер doRaw подставляет ключ только если заголовок пуст —
|
||||
// поэтому бьём в doRaw с пустым Idempotency-Key, переопределив после...
|
||||
// Проще: отдельный raw-запрос.
|
||||
req, err := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/chats/"+chat+"/messages", strings.NewReader(`{"text":"без ключа"}`))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
b, _ := io.ReadAll(resp.Body)
|
||||
resp.Body.Close()
|
||||
logResult(t, resp.StatusCode, string(b))
|
||||
if resp.StatusCode != http.StatusBadRequest {
|
||||
t.Fatalf("missing key: %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
key := "race-" + uuid.NewString()
|
||||
const n = 8
|
||||
ids := make([]string, n)
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < n; i++ {
|
||||
wg.Add(1)
|
||||
go func(i int) {
|
||||
defer wg.Done()
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{
|
||||
"Authorization": "Bearer " + token,
|
||||
"Idempotency-Key": key,
|
||||
}, `{"text":"параллельно"}`)
|
||||
if status != http.StatusCreated {
|
||||
t.Errorf("worker %d status=%d body=%s", i, status, body)
|
||||
return
|
||||
}
|
||||
ids[i] = decode(t, body)["id"].(string)
|
||||
}(i)
|
||||
}
|
||||
wg.Wait()
|
||||
uniq := map[string]struct{}{}
|
||||
for _, id := range ids {
|
||||
if id == "" {
|
||||
t.Fatalf("empty id in race")
|
||||
}
|
||||
uniq[id] = struct{}{}
|
||||
}
|
||||
t.Logf("unique message ids=%d", len(uniq))
|
||||
if len(uniq) != 1 {
|
||||
t.Fatalf("expected 1 message, got %d ids=%v", len(uniq), ids)
|
||||
}
|
||||
logOK(t, "ключ обязателен; конкурентный повтор не плодит дубли")
|
||||
}
|
||||
|
||||
func TestInstanceIDHeaderPresent(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "каждый ответ содержит непустой X-Instance-Id")
|
||||
status, body, hdr := doRaw(t, srv, http.MethodGet, "/health/live", nil, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusOK || hdr.Get("X-Instance-Id") == "" {
|
||||
t.Fatalf("live instance header missing: %q status=%d", hdr.Get("X-Instance-Id"), status)
|
||||
}
|
||||
logOK(t, "X-Instance-Id="+hdr.Get("X-Instance-Id"))
|
||||
}
|
||||
|
||||
type account struct {
|
||||
id string
|
||||
username string
|
||||
password string
|
||||
}
|
||||
|
||||
func newAPI(t *testing.T, ttl time.Duration) *httptest.Server {
|
||||
t.Helper()
|
||||
sessions, err := session.Open(sharedRedisURL, ttl)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = sessions.Close() })
|
||||
return httptest.NewServer(api.New(sharedStore, sessions, blob.NewMemory(), "test-instance").Handler())
|
||||
}
|
||||
|
||||
func newAPIBlob(t *testing.T, ttl time.Duration, bl api.BlobStore) *httptest.Server {
|
||||
t.Helper()
|
||||
sessions, err := session.Open(sharedRedisURL, ttl)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = sessions.Close() })
|
||||
return httptest.NewServer(api.New(sharedStore, sessions, bl, "test-instance").Handler())
|
||||
}
|
||||
|
||||
func register(t *testing.T, srv *httptest.Server, prefix string) account {
|
||||
t.Helper()
|
||||
username := prefix + "_" + uuid.NewString()[:8]
|
||||
password := "correct-horse-1"
|
||||
raw := fmt.Sprintf(`{"username":%q,"display_name":"Студент","password":%q}`, username, password)
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/users", nil, raw)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("register %s: %d %s", username, status, body)
|
||||
}
|
||||
var u struct {
|
||||
ID string `json:"id"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(body), &u); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Logf("создан %s id=%s", username, u.ID)
|
||||
return account{id: u.ID, username: username, password: password}
|
||||
}
|
||||
|
||||
func login(t *testing.T, srv *httptest.Server, username, password string) string {
|
||||
t.Helper()
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{
|
||||
"Authorization": "Basic " + basic(username, password),
|
||||
}, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("login %s: %d %s", username, status, body)
|
||||
}
|
||||
var s struct {
|
||||
Token string `json:"token"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(body), &s); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(s.Token) < 32 {
|
||||
t.Fatalf("token too short: %d", len(s.Token))
|
||||
}
|
||||
t.Logf("сессия выпущена, длина токена=%d (значение не печатаем)", len(s.Token))
|
||||
return s.Token
|
||||
}
|
||||
|
||||
func createChat(t *testing.T, srv *httptest.Server, token, userID, title string) string {
|
||||
t.Helper()
|
||||
raw := fmt.Sprintf(`{"title":%q,"member_ids":[%q]}`, title, userID)
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats", map[string]string{"Authorization": "Bearer " + token}, raw)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("chat: %d %s", status, body)
|
||||
}
|
||||
var c struct {
|
||||
ID string `json:"id"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(body), &c); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return c.ID
|
||||
}
|
||||
|
||||
func do(t *testing.T, srv *httptest.Server, method, path string, headers map[string]string, raw string) (int, string) {
|
||||
t.Helper()
|
||||
status, body, _ := doRaw(t, srv, method, path, headers, raw)
|
||||
return status, body
|
||||
}
|
||||
|
||||
func doRaw(t *testing.T, srv *httptest.Server, method, path string, headers map[string]string, raw string) (int, string, http.Header) {
|
||||
t.Helper()
|
||||
var rdr io.Reader
|
||||
if raw != "" {
|
||||
rdr = bytes.NewBufferString(raw)
|
||||
}
|
||||
req, err := http.NewRequest(method, srv.URL+path, rdr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if raw != "" && method != http.MethodGet {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
for k, v := range headers {
|
||||
req.Header.Set(k, v)
|
||||
}
|
||||
// Lab3: POST сообщений без ключа — 400. В хелперах подставляем уникальный ключ,
|
||||
// если тест сам его не задал (негативные проверки ключа делают это явно).
|
||||
if method == http.MethodPost && strings.Contains(path, "/messages") && req.Header.Get("Idempotency-Key") == "" {
|
||||
req.Header.Set("Idempotency-Key", uuid.NewString())
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
b, _ := io.ReadAll(resp.Body)
|
||||
return resp.StatusCode, string(b), resp.Header
|
||||
}
|
||||
|
||||
func decode(t *testing.T, body string) map[string]any {
|
||||
t.Helper()
|
||||
var m map[string]any
|
||||
if err := json.Unmarshal([]byte(body), &m); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func basic(user, pass string) string {
|
||||
return base64.StdEncoding.EncodeToString([]byte(user + ":" + pass))
|
||||
}
|
||||
|
||||
func logStep(t *testing.T, msg string) { t.Helper(); t.Logf("→ %s", msg) }
|
||||
func logOK(t *testing.T, msg string) { t.Helper(); t.Logf("✓ %s", msg) }
|
||||
func logResult(t *testing.T, status int, body string) {
|
||||
t.Helper()
|
||||
if len(body) > 400 {
|
||||
body = body[:400] + "..."
|
||||
}
|
||||
t.Logf("status=%d body=%s", status, body)
|
||||
}
|
||||
|
||||
func getenv(k, def string) string {
|
||||
if v := os.Getenv(k); v != "" {
|
||||
return v
|
||||
}
|
||||
return def
|
||||
}
|
||||
@@ -0,0 +1,244 @@
|
||||
package studenttests
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"mtusi2026lab4/internal/api"
|
||||
"mtusi2026lab4/internal/blob"
|
||||
"mtusi2026lab4/internal/session"
|
||||
)
|
||||
|
||||
// 1×1 PNG (valid IHDR + IDAT + IEND, CRC проверены).
|
||||
var tinyPNG = []byte{
|
||||
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
|
||||
0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
|
||||
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
|
||||
0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
|
||||
0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41,
|
||||
0x54, 0x78, 0xda, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
|
||||
0x00, 0x03, 0x01, 0x01, 0x00, 0xf7, 0x03, 0x41,
|
||||
0x43, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
|
||||
0x44, 0xae, 0x42, 0x60, 0x82,
|
||||
}
|
||||
|
||||
func TestAttachmentUploadDownloadAndACL(t *testing.T) {
|
||||
mem := blob.NewMemory()
|
||||
srv := newAPIBlob(t, time.Hour, mem)
|
||||
defer srv.Close()
|
||||
logStep(t, "upload PNG → 201 ready → download checksum; посторонний — 404")
|
||||
|
||||
owner := register(t, srv, "att_owner")
|
||||
ownerTok := login(t, srv, owner.username, owner.password)
|
||||
stranger := register(t, srv, "att_stranger")
|
||||
strangerTok := login(t, srv, stranger.username, stranger.password)
|
||||
chat := createChat(t, srv, ownerTok, owner.id, "Вложения")
|
||||
|
||||
attID, sha := uploadPNG(t, srv, ownerTok, chat, "pic.png", tinyPNG)
|
||||
status, body := do(t, srv, http.MethodGet, "/api/v1/attachments/"+attID, map[string]string{
|
||||
"Authorization": "Bearer " + ownerTok,
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusOK {
|
||||
t.Fatalf("meta: %d %s", status, body)
|
||||
}
|
||||
meta := decode(t, body)
|
||||
if meta["status"] != "ready" || meta["sha256"] != sha {
|
||||
t.Fatalf("meta unexpected: %+v", meta)
|
||||
}
|
||||
|
||||
statusCode, raw, hdr := downloadBytes(t, srv, ownerTok, attID)
|
||||
if statusCode != http.StatusOK {
|
||||
t.Fatalf("download: %d", statusCode)
|
||||
}
|
||||
if hdr.Get("Content-Type") != "image/png" {
|
||||
t.Fatalf("content-type: %q", hdr.Get("Content-Type"))
|
||||
}
|
||||
sum := sha256.Sum256(raw)
|
||||
if hex.EncodeToString(sum[:]) != sha {
|
||||
t.Fatalf("checksum mismatch")
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/attachments/"+attID, map[string]string{
|
||||
"Authorization": "Bearer " + strangerTok,
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("stranger meta: %d", status)
|
||||
}
|
||||
statusCode, _, _ = downloadBytes(t, srv, strangerTok, attID)
|
||||
if statusCode != http.StatusNotFound {
|
||||
t.Fatalf("stranger download: %d", statusCode)
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{
|
||||
"Authorization": "Bearer " + ownerTok,
|
||||
}, fmt.Sprintf(`{"text":"с файлом","attachment_ids":[%q]}`, attID))
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("message with att: %d %s", status, body)
|
||||
}
|
||||
msg := decode(t, body)
|
||||
ids, _ := msg["attachment_ids"].([]any)
|
||||
if len(ids) != 1 || ids[0] != attID {
|
||||
t.Fatalf("attachment_ids: %+v", msg["attachment_ids"])
|
||||
}
|
||||
logOK(t, "upload/download/ACL и message.attachment_ids")
|
||||
}
|
||||
|
||||
func TestAttachmentRejectsBadInput(t *testing.T) {
|
||||
mem := blob.NewMemory()
|
||||
srv := newAPIBlob(t, time.Hour, mem)
|
||||
defer srv.Close()
|
||||
logStep(t, "битый PNG, подмена MIME, опасный filename, чужой чат → 4xx не 500")
|
||||
|
||||
user := register(t, srv, "att_bad")
|
||||
tok := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, tok, user.id, "Отказы")
|
||||
|
||||
status, body := uploadRaw(t, srv, tok, chat, "../x.png", "image/png", tinyPNG)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("bad filename: %d", status)
|
||||
}
|
||||
|
||||
status, body = uploadRaw(t, srv, tok, chat, "x.jpg", "image/jpeg", tinyPNG)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnsupportedMediaType {
|
||||
t.Fatalf("mime mismatch: %d", status)
|
||||
}
|
||||
|
||||
status, body = uploadRaw(t, srv, tok, chat, "bad.png", "image/png", tinyPNG[:20])
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnsupportedMediaType {
|
||||
t.Fatalf("truncated: %d", status)
|
||||
}
|
||||
|
||||
// Отдельный сервер с маленьким лимитом: реально шлём 2 KiB, ожидаем 413.
|
||||
small := blob.NewMemory()
|
||||
sessions, err := session.Open(sharedRedisURL, time.Hour)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = sessions.Close() })
|
||||
apiSrv := api.New(sharedStore, sessions, small, "test-small-limit")
|
||||
apiSrv.MaxUploadBytes = 1024
|
||||
limSrv := httptest.NewServer(apiSrv.Handler())
|
||||
defer limSrv.Close()
|
||||
status, body = uploadRaw(t, limSrv, tok, chat, "huge.png", "image/png", make([]byte, 2048))
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusRequestEntityTooLarge {
|
||||
t.Fatalf("too large body: %d", status)
|
||||
}
|
||||
|
||||
other := register(t, srv, "att_other")
|
||||
otherTok := login(t, srv, other.username, other.password)
|
||||
otherChat := createChat(t, srv, otherTok, other.id, "Чужой")
|
||||
status, body = uploadRaw(t, srv, tok, otherChat, "x.png", "image/png", tinyPNG)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("foreign chat upload: %d", status)
|
||||
}
|
||||
|
||||
attID, _ := uploadPNG(t, srv, otherTok, otherChat, "o.png", tinyPNG)
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{
|
||||
"Authorization": "Bearer " + tok,
|
||||
}, fmt.Sprintf(`{"text":"steal","attachment_ids":[%q]}`, attID))
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("foreign attachment_id: %d %s", status, body)
|
||||
}
|
||||
logOK(t, "негативные сценарии вложений → клиентские 4xx")
|
||||
}
|
||||
|
||||
func TestAttachmentS3DownIs503(t *testing.T) {
|
||||
mem := blob.NewMemory()
|
||||
mem.SetUnavailable(true)
|
||||
srv := newAPIBlob(t, time.Hour, mem)
|
||||
defer srv.Close()
|
||||
logStep(t, "S3 недоступен: ready и upload → 503")
|
||||
|
||||
status, body := do(t, srv, http.MethodGet, "/health/ready", nil, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable {
|
||||
t.Fatalf("ready: %d", status)
|
||||
}
|
||||
|
||||
user := register(t, srv, "s3_down")
|
||||
tok := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, tok, user.id, "S3 down")
|
||||
status, body = uploadRaw(t, srv, tok, chat, "x.png", "image/png", tinyPNG)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable {
|
||||
t.Fatalf("upload with s3 down: %d %s", status, body)
|
||||
}
|
||||
logOK(t, "падение S3 → 503")
|
||||
}
|
||||
|
||||
func uploadPNG(t *testing.T, srv *httptest.Server, token, chatID, filename string, data []byte) (id, sha string) {
|
||||
t.Helper()
|
||||
status, body := uploadRaw(t, srv, token, chatID, filename, "image/png", data)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("upload: %d %s", status, body)
|
||||
}
|
||||
var att struct {
|
||||
ID string `json:"id"`
|
||||
SHA256 string `json:"sha256"`
|
||||
Status string `json:"status"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(body), &att); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if att.Status != "ready" || att.ID == "" {
|
||||
t.Fatalf("upload body: %s", body)
|
||||
}
|
||||
sum := sha256.Sum256(data)
|
||||
want := hex.EncodeToString(sum[:])
|
||||
if att.SHA256 != want {
|
||||
t.Fatalf("sha got=%s want=%s", att.SHA256, want)
|
||||
}
|
||||
return att.ID, att.SHA256
|
||||
}
|
||||
|
||||
func uploadRaw(t *testing.T, srv *httptest.Server, token, chatID, filename, ctype string, data []byte) (int, string) {
|
||||
t.Helper()
|
||||
u := srv.URL + "/api/v1/chats/" + chatID + "/attachments?filename=" + url.QueryEscape(filename)
|
||||
req, err := http.NewRequest(http.MethodPost, u, bytes.NewReader(data))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
req.Header.Set("Content-Type", ctype)
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
b, _ := io.ReadAll(resp.Body)
|
||||
return resp.StatusCode, string(b)
|
||||
}
|
||||
|
||||
func downloadBytes(t *testing.T, srv *httptest.Server, token, attID string) (int, []byte, http.Header) {
|
||||
t.Helper()
|
||||
req, err := http.NewRequest(http.MethodGet, srv.URL+"/api/v1/attachments/"+attID+"/content", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
b, _ := io.ReadAll(resp.Body)
|
||||
return resp.StatusCode, b, resp.Header.Clone()
|
||||
}
|
||||
Reference in New Issue
Block a user