Реализовать 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:
Mlvn
2026-11-12 18:08:47 +03:00
parent ec540a1a72
commit 7cbb75c897
43 changed files with 6075 additions and 36 deletions
+32 -12
View File
@@ -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
View File
@@ -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"]
+22 -2
View File
@@ -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
+60 -16
View File
@@ -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`.
+221
View File
@@ -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
}
+123
View File
@@ -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
}
+214
View File
@@ -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
View File
@@ -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:
+8
View File
@@ -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
+4
View File
@@ -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.
+3
View File
@@ -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.
+2
View File
@@ -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)
+129
View File
@@ -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
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
+250
View File
@@ -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
+54
View File
@@ -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
)
+128
View File
@@ -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
View File
@@ -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`) **не публикуется**.
+52
View File
@@ -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
+17
View File
@@ -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/*"]
}
]
}
+32
View File
@@ -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"
+448
View File
@@ -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
}
+780
View File
@@ -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
}
+110
View File
@@ -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)
}
+162
View File
@@ -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)
+197
View File
@@ -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
}
+189
View File
@@ -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
}
}
+135
View File
@@ -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[:])
}
+209
View File
@@ -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
}
+84
View File
@@ -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
}
+49
View File
@@ -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);
+723
View File
@@ -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
}
+31
View File
@@ -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
+130
View File
@@ -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"
+146
View File
@@ -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"
+7
View File
@@ -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
+42
View File
@@ -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
+44
View File
@@ -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
View File
@@ -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
+664
View File
@@ -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
}
+244
View File
@@ -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()
}