ЛР 4 — БВТ2302 — Заморский — на 5 #161

Open
0pavel1 wants to merge 1 commits from 0pavel1/mtusi2026lab4:solution/bvt2302-zamorskiy into main
33 changed files with 8458 additions and 21 deletions
+2
View File
@@ -0,0 +1,2 @@
*.sh text eol=lf
*.sql text eol=lf
+38
View File
@@ -0,0 +1,38 @@
# syntax=docker/dockerfile:1
# Stage 1: Build static Go binary
FROM golang:1.24-alpine AS builder
WORKDIR /src
ENV GOPROXY=https://goproxy.io,direct
ENV GOSUMDB=off
# Cache dependencies first
COPY go.mod go.sum ./
RUN go mod download
# Copy application source and migrations
COPY cmd/ ./cmd/
COPY internal/ ./internal/
COPY migrations/ ./migrations/
# Build stripped static binary
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger ./cmd/server
# Stage 2: Minimal non-root runtime image
FROM alpine:3.21
RUN addgroup -g 10001 -S appgroup && \
adduser -u 10001 -S appuser -G appgroup
WORKDIR /app
COPY --from=builder /out/messenger /app/messenger
COPY --from=builder /src/migrations /app/migrations
RUN chown -R appuser:appgroup /app
USER 10001:10001
EXPOSE 8080
HEALTHCHECK --interval=2s --timeout=2s --start-period=2s --retries=10 \
CMD wget -q -O /dev/null http://127.0.0.1:8080/health/ready || exit 1
ENTRYPOINT ["/app/messenger"]
+11 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test load test-persistence test-failover test-grade4 test-track2 seed
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -28,3 +28,13 @@ 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)
test-grade4:
$(PYTHON) student-tests/test_grade4.py "$(BASE_URL)"
test-track2:
$(PYTHON) student-tests/test_track2_reconciler.py "$(BASE_URL)"
seed:
$(PYTHON) scripts/seed.py "$(BASE_URL)"
+120 -20
View File
@@ -1,37 +1,137 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- **Автор, группа:** Заморский Павел, БВТ2302
- **Целевая оценка; трек 5:** **5** (выполнены уровни 3, 4 и **Трек 2 «Согласованность двух хранилищ»**)
- **Commit/PR:** ветка `solution/bvt2302-zamorskiy`
- **Использованные источники, библиотеки и помощь ИИ:** Go 1.24 (`jackc/pgx/v5`, `redis/go-redis/v9`, `minio/minio-go/v7`, `golang.org/x/crypto/argon2`, `golang.org/x/sync/singleflight`, `google/uuid`), PostgreSQL 18 (`postgres:18-alpine`), Redis 7.4 (`redis:7.4-alpine`), MinIO (`minio/minio@sha256:14cea493...` `RELEASE.2025-09-07T16-13-09Z` + `minio/mc@sha256:a7fe349e...`), HAProxy 3.0 (`haproxy:3.0-alpine`), документация MinIO S3 API & IAM Policies. Помощь ИИ (Google Antigravity) при генерации тестовых/экспериментальных скриптов и оформлении отчёта.
## Запуск из чистого clone
---
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
## 1. Запуск из чистого clone
## Архитектура и решения
### 1.1. Версии runtime и контейнерных образов
- **Go runtime / builder:** `golang:1.24-alpine`, runtime-образ: `alpine:3.21` (non-root UID/GID `10001`).
- **PostgreSQL:** `postgres:18-alpine` (volume `mtusi_lab4_pgdata`, `PGDATA=/var/lib/postgresql/data/pgdata`).
- **Redis:** `redis:7.4-alpine` (AOF `appendonly yes`, volume `mtusi_lab4_redisdata`).
- **S3-хранилище (MinIO):** `minio/minio@sha256:14cea493d9a34af32f524e538b8346cf79f3321eff8e708c1e2960462bd8936e` (`RELEASE.2025-09-07T16-13-09Z`, volume `mtusi_lab4_s3data`, `MINIO_BROWSER="off"`, порты `9000/9001` наружу не публикуются).
- **MinIO Bootstrap Client (`s3-init`):** `minio/mc@sha256:a7fe349ef4bd8521fb8497f55c6042871b2ae640607cf99d9bede5e9bdf11727`.
- **Load Balancer:** `haproxy:3.0-alpine` (единственная публичная точка входа `8080->80`).
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
### 1.2. Команды запуска, проверки и сброса
## Доказательства критериев
```sh
# 1. Скопировать локальный .env (секреты не коммитятся в Git)
cp .env.example .env
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
# 2. Проверить Compose и контракт
docker compose --env-file .env config --quiet
make check
# 3. Собрать и поднять стенд (Postgres + Redis + MinIO -> migrate + s3-init -> API x2 -> HAProxy LB)
docker compose --env-file .env up -d --build
docker compose --env-file .env ps
# 4. Дождаться готовности и наполнить демо-данные с изображением (опционально для /docs)
curl -fsS http://localhost:8080/health/ready
make seed
# 5. Обязательные проверки (уровень 3)
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
# Восстановить остановленную реплику после failover-теста:
docker compose --env-file .env up -d --no-deps api
# 6. Проверки уровня 4 и эксперимент уровня 5 (Трек 2)
make test-grade4
make test-track2
```
- **Безопасная остановка (с сохранением volumes):** `docker compose --env-file .env down`
- **Намеренное удаление данных и томов:** `docker compose --env-file .env down -v`
---
## 2. Архитектура и решения
### 2.1. Перенос из ЛР3 и изменения ЛР4
Из ЛР3 перенесены: HAProxy 3.0 с активным `/health/ready`, 2 stateless API-реплики с `X-Instance-Id`, `Idempotency-Key`, общие PostgreSQL 18 + Redis 7.4, однократный init-сервис миграций `migrate`.
**Новые компоненты ЛР4:**
1. **Приватный MinIO S3 и принцип наименьших привилегий ([`compose.yaml`](compose.yaml), [`infra/s3-bootstrap.sh`](infra/s3-bootstrap.sh), [`infra/minio-api-policy.json`](infra/minio-api-policy.json)):**
- Init-сервис `s3-init` идемпотентно создаёт bucket `messenger-attachments` (`mc mb --ignore-existing`), отключает анонимный доступ (`mc anonymous set none`), создаёт отдельного пользователя `messenger_api_key` с IAM-политикой строго на один bucket (`GetBucketLocation`, `ListBucket`, `GetObject`, `PutObject`, `DeleteObject` только на `arn:aws:s3:::messenger-attachments/*`).
- Админская консоль MinIO выключена (`MINIO_BROWSER="off"`), а порты S3/консоли наружу не публикуются; API не получает root-учёток MinIO.
- Серверные S3 object keys имеют формат `attachments/<chat_id>/<attachment_id>`, клиентский `filename` хранится исключительно как метаданные в PostgreSQL и проверяется на отсутствие `/`, `\`, `NUL` и управляющих символов.
2. **Потоковая валидация изображений без OOM (`internal/media/validate.go`):**
- Проверка `Bearer`, валидности `chat_id` и прав участника (`404`) происходит **до** чтения тела и обращения к S3.
- Запрос ограничивается `http.MaxBytesReader` и `io.LimitReader(..., MAX_UPLOAD_BYTES+1)` во временный буфер `os.CreateTemp`, удаляемый в `defer` (0 локальных файлов после завершения запроса).
- На лету вычисляется `SHA-256`; по первым 512 байтам проверяются magic bytes против `Content-Type` (подмена MIME / несовпадение -> `415`).
- Перед полной распаковкой вызывается `image.DecodeConfig` (~4 КБ RAM) и проверяется `width * height <= MAX_IMAGE_PIXELS` (`40 000 000`) -> decompression bomb отклоняется кодом `413` без выделения памяти под пиксели.
- Дополнительно проверяется структурная целостность контейнера (CRC32 всех PNG-чанков до `IEND` или структура JPEG-маркеров до `EOI`) -> повреждённые файлы отклоняются с `415`.
3. **Загрузка, привязка и скачивание (`internal/store/postgres.go`, `internal/handler/handler.go`, `migrations/003_attachments.sql`):**
- `201 Attachment` возвращается **только после** успешного `PutObject` в MinIO и `COMMIT` в PostgreSQL. При ошибке БД выполняется немедленная синхронная компенсация `RemoveObject` в S3.
- `CreateMessage` поддерживает `attachment_ids` (`0..10` уникальных UUID этого чата, пустой `text=""` разрешён при наличии вложения; чужие/неизвестные вложения -> `404`). Отсутствующий `attachment_ids` и `[]` нормализуются в `[]` для канонического хеша `Idempotency-Key`.
- `GET /api/v1/attachments/{id}/content` стримит байты из приватного S3 через API без редиректа только участникам чата; при недоступности S3 или PostgreSQL `/health/ready` и эндпоинты вложений быстро (`MaxRetries: 1`, dial `800ms`) возвращают `503 unavailable`.
4. **Согласованность двух хранилищ и Reconciler (Уровень 4 + Трек 2):**
- Реализован `Store.Reconcile` (запускается фоновым тикером под advisory-блокировкой PostgreSQL `pg_try_advisory_lock(20260401)`, а также через CLI `-reconcile-once [-dry-run] [-grace-seconds]`).
- В пределах безопасного `grace_period` (`RECONCILE_GRACE_SECONDS=300` в проде) свежие объекты не трогаются. Объекты S3 без строки БД старше grace удаляются как осиротевшие; отсутствующие в S3 строки `pending` удаляются, а повреждённые `ready` (используемые сообщениями) переводятся в `status='failed', error_code='missing_s3_object'` (`GET /content -> 409`).
### 2.2. Соответствие `.env.example`
| Переменная `.env.example` | Использование | Значение по умолчанию |
| --- | --- | --- |
| `S3_ENDPOINT`, `S3_REGION`, `S3_BUCKET` | Внутренний адрес MinIO и приватный бакет | `http://s3:9000`, `us-east-1`, `messenger-attachments` |
| `S3_ACCESS_KEY_ID_FILE`, `S3_SECRET_ACCESS_KEY_FILE` | Секретные ключи ограниченного сервисного пользователя API (c fallback на прямые env) | `/run/secrets/...` |
| `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` | Лимиты размера (`10 MiB`) и числа пикселей (`40 MP`) до полной распаковки | `10485760`, `40000000` |
| Остальные (`APP_*`, `SESSION_*`, `DATABASE_*`, `API_REPLICAS`, `IDEMPOTENCY_*`) | Унаследованы без изменений из ЛР3 | как в ЛР3 |
---
## 3. Доказательства критериев
| Критерий README | Команда / сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Статический контракт и синтаксис | `make check` | `PASS: offline skeleton structure, local refs and Python syntax` | `scripts/check_contract.py` |
| Публичный smoke (уровень 3: upload, message с `attachment_ids`, SHA-256 download, `404` для `eve`) | `make test` | `PASS: lab4 public API scenario` | `tests/smoke.py` |
| Полный рестарт сохранность (включая MinIO S3 volume) | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | Перезапущены `postgres`, `redis`, `s3`, `api`, `lb`; прежний токен и бинарник вложения сохранены побайтно | `scripts/restart.sh` |
| Отказ одной API-реплики под записью | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | `observed_instances_before=2`, `successful_writes=142`, `failed_attempts=0`, `first_recovery_seconds=2.906` | `scripts/stop-one.sh` |
| Оценка 4: негативные сценарии (`413`, `415`, `400`, `404`), никогда не `500` | `make test-grade4` (`negative_validation`) | `>10MiB -> 413`, pixel bomb `7000x7000 -> 413`, обрезанный PNG & JPEG `-> 415`, подмена MIME `-> 415`, опасные filename `-> 400`, чужой чат / посторонний `-> 404` | [`evidence/grade4_checks.json`](evidence/grade4_checks.json) |
| Оценка 4: загрузка на реплику A -> остановка A -> скачивание с реплики B + отсутствие локальных файлов | `make test-grade4` (`cross_replica_failover_download`) | Загрузка на `4f15587f6c21`, остановка, скачивание с `0238360ce86c` с совпадением `SHA-256`; `0` временных файлов на API | [`evidence/grade4_checks.json`](evidence/grade4_checks.json) |
| Оценка 4: приватный bucket вне API, IAM минимальных прав, закрытая консоль, идемпотентный `s3-init` | `make test-grade4` (`private_bucket_and_iam`) | Прямой `GET http://s3:9000/messenger-attachments/...` из сети без авторизации даёт `403 Forbidden`; порты S3/консоли наружу закрыты (`0`); API использует `messenger_api_key`; повтор `s3-init` -> код `0` | [`evidence/grade4_checks.json`](evidence/grade4_checks.json) |
| Оценка 4: отказ S3 без `500` | `make test-grade4` (`s3_outage_handling`) | При остановке `s3`: `/health/ready -> 503`, `POST upload -> 503`, `GET content -> 503` | [`evidence/grade4_checks.json`](evidence/grade4_checks.json) |
| Оценка 4: `>=10` одновременных загрузок и ограниченность RAM | `make test-grade4` (`concurrent_streaming_memory`) | 12 одновременных загрузок PNG по `4.41 MiB` (`52.89 MiB` суммарно за `3.251s`): память реплик осталась `43.64 -> 56.23 MiB` и `51.44 -> 52.38 MiB` из лимита `256 MiB` | [`evidence/grade4_checks.json`](evidence/grade4_checks.json) |
| Базовая нагрузка `tests/load.py` | `python3 tests/load.py --duration 15 --concurrency 4 --output evidence/load.json` | `10001` успешных POST за 15s, `666.386 RPS`, `0` ошибок, `p50=4.893ms`, `p95=10.807ms`, `p99=20.305ms` | [`evidence/load.json`](evidence/load.json) |
| Оценка 5 Трек 2: сверщик PostgreSQL <-> S3 | `make test-track2` | `dry-run` (79 S3 / 78 DB за `18.4ms`) -> `apply` удалил 3 просроченных orphan в S3 и stale `pending`, пометил 1 missing `ready` как `failed`, не тронул свежий объект в grace и сохранил все 25 здоровых; повторный прогон дал 0 изменений (`19.7ms`) | [`evidence/track2_reconciler.json`](evidence/track2_reconciler.json) |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
---
## Эксперименты и отказы
## 4. Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### 4.1. Матрица отказов
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка загрузившей API-реплики (`docker stop`) | HAProxy выводит её из пула, другая реплика отдаёт файл побайтно из MinIO | `0238360ce86c` отдал точный оригинал (SHA-256 совпал); `make test-failover`: `142` записи, `failed_attempts=0`, `2.906s` | `0` потерь данных, `0` ошибок клиентов |
| Остановка контейнера `s3` | API быстро переходит в `503 unavailable` без `500` и зависаний | `/health/ready`, upload и download сразу отдавали `503` (благодаря `MaxRetries: 1` и dial `800ms`) | Восстановление за <3s после старта `s3` |
| Полный рестарт `postgres + redis + s3 + api + lb` (`scripts/restart.sh`) | Сессия, метаданные и объекты MinIO сохраняются в volumes | Прежний Bearer-токен скачал исходный PNG с прежним SHA-256 | `0` потерь метаданных и файлов |
## Ограничения и следующие шаги
### 4.2. Трек 2 — Согласованность двух хранилищ (Reconciler)
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Гипотеза:** В двуххранилищной архитектуре (S3 + PostgreSQL без 2PC) возможны сбои между `PutObject` и `COMMIT` (либо внешняя потеря объекта S3). Повторяемый сверщик с безопасным `grace_period`, `dry-run` и PostgreSQL advisory-блокировкой устраняет оба класса рассинхронизации за `1` `ListObjects` + `O(N)` строк БД без удаления активных или ещё загружаемых вложений.
- **Методика (`student-tests/test_track2_reconciler.py`):**
1. Загружено `25` здоровых вложений (10 из них привязаны к сообщениям).
2. Внедрены аномалии с обеих сторон: **3** осиротевших S3-объекта (возраст > `grace=5s`), **1** `ready`-вложение с удалённым в MinIO объектом (используемое в сообщении), **1** устаревшая `pending`-строка в БД без объекта, а также **1** «свежий» S3-объект внутри окна `grace_period=5s` (имитация активной загрузки).
- **Наблюдаемые результаты ([`evidence/track2_reconciler.json`](evidence/track2_reconciler.json)):**
- **`--dry-run`:** просканировал `79` S3-объектов (`1` вызов `ListObjects`) и `78` строк БД (`2` SQL-запроса) за **`18.395 ms`**. Обнаружил все `3` просроченных orphan в S3 и обе missing-строки БД, пропустил свежий объект в окне `grace`, сохранил все `75` здоровых, мутаций `0`.
- **`--apply`:** выполнил за **`27.038 ms`** (`1` `ListObjects`, `3` `RemoveObject`, `4` SQL-запроса): удалил строго `3` старых S3 orphan и `1` `pending`-строку, перевёл missing `ready`-вложение в `status='failed'` (`error_code='missing_s3_object'`, после чего `GET /content -> 409`), свежий объект в окне `grace` и все здоровые вложения остались нетронутыми.
- **Повторный запуск (идемпотентность):** `76` S3 / `77` DB за **`19.697 ms`** — `0` удалений, `0` обновлений, все `25` контрольных вложений скачаны с исходным `SHA-256`.
---
## 5. Ограничения и следующие шаги
- **Ограничения:**
- Загрузка идёт синхронным proxy-потоком через API (`201 ready` без асинхронной очереди миниатюр); пик локального spooling в `/tmp` ограничен размером `MAX_UPLOAD_BYTES` (`10 MiB`) и удаляется в `defer` — при большом числе параллельных загрузок требуется достаточный объём ephemeral `/tmp` и лимит на конкурентность на уровне LB/API.
- На одном хосте MinIO S3 развёрнут одним процессом без erasure coding/репликации (учебное хранилище на одном volume).
- **Следующий шаг (ЛР5):** перейти к асинхронному ответу `202 Attachment` (`queued -> processing -> ready`), брокеру сообщений, staging и фоновому worker генерации `thumbnail` (и `crop`/`optimized`).
+283
View File
@@ -0,0 +1,283 @@
package main
import (
"context"
"encoding/json"
"errors"
"flag"
"fmt"
"log"
"net/http"
"os"
"os/signal"
"path/filepath"
"sort"
"strconv"
"strings"
"syscall"
"time"
"github.com/google/uuid"
"messenger/internal/handler"
"messenger/internal/s3store"
"messenger/internal/store"
)
func getEnv(key, defaultVal string) string {
if val := strings.TrimSpace(os.Getenv(key)); val != "" {
return val
}
return defaultVal
}
func getEnvInt(key string, defaultVal int) int {
if val := strings.TrimSpace(os.Getenv(key)); val != "" {
if n, err := strconv.Atoi(val); err == nil {
return n
}
}
return defaultVal
}
func getEnvInt64(key string, defaultVal int64) int64 {
if val := strings.TrimSpace(os.Getenv(key)); val != "" {
if n, err := strconv.ParseInt(val, 10, 64); err == nil {
return n
}
}
return defaultVal
}
func getEnvBool(key string, defaultVal bool) bool {
if val := strings.TrimSpace(os.Getenv(key)); val != "" {
if b, err := strconv.ParseBool(val); err == nil {
return b
}
}
return defaultVal
}
func resolveSecretOrEnv(fileEnvKey, directEnvKey, defaultVal string) string {
if filePath := strings.TrimSpace(os.Getenv(fileEnvKey)); filePath != "" {
if data, err := os.ReadFile(filePath); err == nil {
if trimmed := strings.TrimSpace(string(data)); trimmed != "" {
return trimmed
}
}
}
if direct := strings.TrimSpace(os.Getenv(directEnvKey)); direct != "" {
return direct
}
return defaultVal
}
func resolveInstanceID() string {
if id := strings.TrimSpace(os.Getenv("INSTANCE_ID")); id != "" {
return id
}
if host, err := os.Hostname(); err == nil && strings.TrimSpace(host) != "" {
return strings.TrimSpace(host)
}
return "api-" + uuid.New().String()[:12]
}
func loadMigrations(dir string) ([]store.MigrationFile, error) {
entries, err := os.ReadDir(dir)
if err != nil {
return nil, fmt.Errorf("read migrations dir %s: %w", dir, err)
}
var names []string
for _, entry := range entries {
if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".sql") {
names = append(names, entry.Name())
}
}
sort.Strings(names)
if len(names) == 0 {
return nil, fmt.Errorf("no .sql migration files found in %s", dir)
}
migrations := make([]store.MigrationFile, 0, len(names))
for _, name := range names {
raw, err := os.ReadFile(filepath.Join(dir, name))
if err != nil {
return nil, fmt.Errorf("read migration %s: %w", name, err)
}
migrations = append(migrations, store.MigrationFile{
Version: name,
SQL: string(raw),
})
}
return migrations, nil
}
func main() {
migrateOnly := flag.Bool("migrate-only", false, "Run database migrations and exit")
reconcileOnce := flag.Bool("reconcile-once", false, "Run two-store (DB <-> S3) reconciliation once and exit")
reconcileDryRun := flag.Bool("dry-run", false, "Dry-run mode for -reconcile-once")
reconcileGraceSec := flag.Int("grace-seconds", -1, "Override grace period in seconds for -reconcile-once")
flag.Parse()
host := getEnv("APP_HOST", "0.0.0.0")
port := getEnv("APP_PORT", "8080")
appEnv := getEnv("APP_ENV", "lab")
sessionTTL := getEnvInt("SESSION_TTL_SECONDS", 3600)
idempotencyTTL := getEnvInt("IDEMPOTENCY_TTL_SECONDS", 86400)
maxConns := int32(getEnvInt("DB_MAX_CONNS", 12))
minConns := int32(getEnvInt("DB_MIN_CONNS", 2))
queryTimeoutMs := getEnvInt("DB_QUERY_TIMEOUT_MS", 5000)
drainDelayMs := getEnvInt("SHUTDOWN_DRAIN_DELAY_MS", 1500)
cacheMode := getEnv("CACHE_MODE", "write_through_versioned")
writeMode := getEnv("WRITE_MODE", "pipeline")
migrationsDir := getEnv("MIGRATIONS_DIR", "migrations")
runMigrations := *migrateOnly || getEnvBool("RUN_MIGRATIONS", true)
maxUploadBytes := getEnvInt64("MAX_UPLOAD_BYTES", 10485760)
maxImagePixels := getEnvInt64("MAX_IMAGE_PIXELS", 40000000)
reconcileIntervalSec := getEnvInt("RECONCILE_INTERVAL_SECONDS", 60)
reconcileGraceEnv := getEnvInt("RECONCILE_GRACE_SECONDS", 300)
if *reconcileGraceSec >= 0 {
reconcileGraceEnv = *reconcileGraceSec
}
instanceID := resolveInstanceID()
dbURL := resolveSecretOrEnv("DATABASE_URL_FILE", "DATABASE_URL", "postgres://messenger:messenger_lab4_pass@localhost:5432/messenger?sslmode=disable")
cacheURL := resolveSecretOrEnv("CACHE_URL_FILE", "CACHE_URL", "redis://localhost:6379/0")
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
st, err := store.NewPostgresStore(ctx, store.Config{
DatabaseURL: dbURL,
CacheURL: cacheURL,
MaxConns: maxConns,
MinConns: minConns,
QueryTimeout: time.Duration(queryTimeoutMs) * time.Millisecond,
CacheMode: cacheMode,
WriteMode: writeMode,
})
if err != nil {
log.Fatalf("Failed to initialize store: %v", err)
}
defer st.Close()
if runMigrations && !*reconcileOnce {
migrations, err := loadMigrations(migrationsDir)
if err != nil {
log.Fatalf("Failed to load migrations: %v", err)
}
var migErr error
for attempt := 1; attempt <= 30; attempt++ {
migErr = st.RunMigrations(ctx, migrations)
if migErr == nil {
break
}
log.Printf("Waiting for PostgreSQL to apply migrations (attempt %d/30): %v", attempt, migErr)
select {
case <-ctx.Done():
log.Fatalf("Interrupted while waiting for database migrations")
case <-time.After(1 * time.Second):
}
}
if migErr != nil {
log.Fatalf("Could not apply database migrations after 30 attempts: %v", migErr)
}
}
if *migrateOnly {
log.Println("Migrate-only flag set; exiting 0.")
return
}
s3Endpoint := getEnv("S3_ENDPOINT", "http://s3:9000")
s3Region := getEnv("S3_REGION", "us-east-1")
s3Bucket := getEnv("S3_BUCKET", "messenger-attachments")
s3AccessKey := resolveSecretOrEnv("S3_ACCESS_KEY_ID_FILE", "S3_ACCESS_KEY_ID", "messenger_api_key")
s3SecretKey := resolveSecretOrEnv("S3_SECRET_ACCESS_KEY_FILE", "S3_SECRET_ACCESS_KEY", "messenger_api_secret_key_lab4")
s3Client, err := s3store.NewClient(s3store.Config{
Endpoint: s3Endpoint,
Region: s3Region,
Bucket: s3Bucket,
AccessKey: s3AccessKey,
SecretKey: s3SecretKey,
})
if err != nil {
log.Fatalf("Failed to initialize S3 client: %v", err)
}
if *reconcileOnce {
grace := time.Duration(reconcileGraceEnv) * time.Second
report, rErr := st.Reconcile(ctx, s3Client, grace, *reconcileDryRun)
if rErr != nil {
log.Fatalf("Reconcile failed: %v", rErr)
}
out, _ := json.MarshalIndent(report, "", " ")
fmt.Println(string(out))
return
}
// Background two-store reconciliation loop (only 1 replica acquires advisory lock per interval).
if reconcileIntervalSec > 0 {
go func() {
ticker := time.NewTicker(time.Duration(reconcileIntervalSec) * time.Second)
defer ticker.Stop()
grace := time.Duration(reconcileGraceEnv) * time.Second
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
rCtx, rCancel := context.WithTimeout(ctx, 25*time.Second)
rep, rErr := st.Reconcile(rCtx, s3Client, grace, false)
rCancel()
if rErr != nil {
log.Printf("WARN: background reconcile error: %v", rErr)
} else if rep.LockAcquired && (len(rep.OrphanS3Deleted) > 0 || len(rep.MissingS3MarkedFailed) > 0 || len(rep.MissingS3Deleted) > 0) {
b, _ := json.Marshal(rep)
log.Printf("Background reconcile summary: %s", string(b))
}
}
}
}()
}
h, apiHandler := handler.RegisterRoutes(st, s3Client, sessionTTL, idempotencyTTL, maxUploadBytes, maxImagePixels, instanceID)
addr := fmt.Sprintf("%s:%s", host, port)
srv := &http.Server{
Addr: addr,
Handler: h,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 35 * time.Second,
WriteTimeout: 35 * time.Second,
IdleTimeout: 60 * time.Second,
}
go func() {
log.Printf("Starting messenger server (Lab 4, instance=%s) on %s (env=%s, s3=%s/%s, maxUpload=%dB, maxPixels=%d)",
instanceID, addr, appEnv, s3Endpoint, s3Bucket, maxUploadBytes, maxImagePixels)
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("ListenAndServe error: %v", err)
}
}()
<-ctx.Done()
log.Printf("Instance %s received termination signal: marking /health/ready=503 and draining...", instanceID)
apiHandler.SetDraining(true)
if drainDelayMs > 0 {
time.Sleep(time.Duration(drainDelayMs) * time.Millisecond)
}
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Printf("Server shutdown error: %v", err)
} else {
log.Printf("Instance %s stopped gracefully", instanceID)
}
}
+212
View File
@@ -0,0 +1,212 @@
x-lab-number: 4
x-required-roles:
- api
- postgres
- redis
- s3
- load_balancer
services:
postgres:
image: postgres:18-alpine
restart: unless-stopped
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-messenger_lab4_pass}
POSTGRES_DB: ${POSTGRES_DB:-messenger}
PGDATA: /var/lib/postgresql/data/pgdata
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER:-messenger} -d $${POSTGRES_DB:-messenger}"]
interval: 2s
timeout: 2s
retries: 15
start_period: 2s
deploy:
resources:
limits:
cpus: "${DB_CPU_LIMIT:-1.0}"
memory: "${DB_MEM_LIMIT:-512M}"
networks:
- backend
redis:
image: redis:7.4-alpine
restart: unless-stopped
command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
volumes:
- redisdata:/data
- ./infra/redis.conf:/usr/local/etc/redis/redis.conf:ro
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 2s
timeout: 2s
retries: 15
start_period: 2s
deploy:
resources:
limits:
cpus: "${REDIS_CPU_LIMIT:-0.5}"
memory: "${REDIS_MEM_LIMIT:-256M}"
networks:
- backend
s3:
image: minio/minio@sha256:14cea493d9a34af32f524e538b8346cf79f3321eff8e708c1e2960462bd8936e
restart: unless-stopped
command: ["server", "/data", "--address", ":9000", "--console-address", ":9001"]
environment:
MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minio_admin_local}
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minio_admin_secret_lab4}
MINIO_BROWSER: "off"
volumes:
- s3data:/data
healthcheck:
test: ["CMD", "curl", "-fsS", "http://127.0.0.1:9000/minio/health/live"]
interval: 2s
timeout: 2s
retries: 15
start_period: 2s
deploy:
resources:
limits:
cpus: "${S3_CPU_LIMIT:-1.0}"
memory: "${S3_MEM_LIMIT:-512M}"
networks:
- backend
s3-init:
image: minio/mc@sha256:a7fe349ef4bd8521fb8497f55c6042871b2ae640607cf99d9bede5e9bdf11727
restart: "no"
entrypoint: ["/bin/sh", "/infra/s3-bootstrap.sh"]
environment:
MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minio_admin_local}
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minio_admin_secret_lab4}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-messenger_api_key}
S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-messenger_api_secret_key_lab4}
volumes:
- ./infra/s3-bootstrap.sh:/infra/s3-bootstrap.sh:ro
- ./infra/minio-api-policy.json:/infra/minio-api-policy.json:ro
depends_on:
s3:
condition: service_healthy
networks:
- backend
migrate:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger:lab4
entrypoint: ["/app/messenger", "-migrate-only"]
restart: "no"
environment:
DATABASE_URL_FILE: ${DATABASE_URL_FILE:-/run/secrets/database_url}
DATABASE_URL: ${DATABASE_URL:-postgres://messenger:messenger_lab4_pass@postgres:5432/messenger?sslmode=disable}
CACHE_URL_FILE: ${CACHE_URL_FILE:-/run/secrets/cache_url}
CACHE_URL: ${CACHE_URL:-redis://redis:6379/0}
MIGRATIONS_DIR: /app/migrations
depends_on:
postgres:
condition: service_healthy
deploy:
resources:
limits:
cpus: "0.5"
memory: "128M"
networks:
- backend
api:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger:lab4
restart: unless-stopped
stop_grace_period: 10s
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
SESSION_STORE: ${SESSION_STORE:-redis}
RUN_MIGRATIONS: "false"
MIGRATIONS_DIR: /app/migrations
SHUTDOWN_DRAIN_DELAY_MS: ${SHUTDOWN_DRAIN_DELAY_MS:-1500}
DATABASE_URL_FILE: ${DATABASE_URL_FILE:-/run/secrets/database_url}
DATABASE_URL: ${DATABASE_URL:-postgres://messenger:messenger_lab4_pass@postgres:5432/messenger?sslmode=disable}
CACHE_URL_FILE: ${CACHE_URL_FILE:-/run/secrets/cache_url}
CACHE_URL: ${CACHE_URL:-redis://redis:6379/0}
S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID_FILE: ${S3_ACCESS_KEY_ID_FILE:-/run/secrets/s3_access_key_id}
S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-messenger_api_key}
S3_SECRET_ACCESS_KEY_FILE: ${S3_SECRET_ACCESS_KEY_FILE:-/run/secrets/s3_secret_access_key}
S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-messenger_api_secret_key_lab4}
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
RECONCILE_INTERVAL_SECONDS: ${RECONCILE_INTERVAL_SECONDS:-60}
RECONCILE_GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-300}
DB_MAX_CONNS: ${DB_MAX_CONNS:-12}
DB_MIN_CONNS: ${DB_MIN_CONNS:-2}
DB_QUERY_TIMEOUT_MS: ${DB_QUERY_TIMEOUT_MS:-5000}
CACHE_MODE: ${CACHE_MODE:-write_through_versioned}
WRITE_MODE: ${WRITE_MODE:-pipeline}
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
migrate:
condition: service_completed_successfully
s3-init:
condition: service_completed_successfully
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits:
cpus: "${API_CPU_LIMIT:-1.0}"
memory: "${API_MEM_LIMIT:-256M}"
networks:
- backend
lb:
image: haproxy:3.0-alpine
restart: unless-stopped
ports:
- "${APP_PORT:-8080}:80"
volumes:
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
healthcheck:
test: ["CMD-SHELL", "haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg && kill -0 1"]
interval: 2s
timeout: 2s
retries: 10
start_period: 1s
depends_on:
api:
condition: service_healthy
deploy:
resources:
limits:
cpus: "${LB_CPU_LIMIT:-0.5}"
memory: "${LB_MEM_LIMIT:-128M}"
networks:
- backend
volumes:
pgdata:
name: mtusi_lab4_pgdata
redisdata:
name: mtusi_lab4_redisdata
s3data:
name: mtusi_lab4_s3data
networks:
backend:
name: mtusi_lab4_backend
driver: bridge
+77
View File
@@ -0,0 +1,77 @@
{
"timestamp_utc": "2026-11-16T23:52:48Z",
"base_url": "http://localhost:8080",
"checks": {
"negative_validation": {
"status": "PASS",
"oversized_10mib_status": 413,
"pixel_bomb_49mp_status": 413,
"corrupted_png_status": 415,
"corrupted_jpg_status": 415,
"mime_spoof_status": 415,
"bad_filename_status": 400,
"outsider_and_cross_chat_status": 404
},
"cross_replica_failover_download": {
"status": "PASS",
"uploaded_by": "4f15587f6c21",
"downloaded_from_after_stop": "0238360ce86c",
"sha256_verified": true,
"api_temp_files_remaining": 0,
"object_key_internal": "attachments/d5a638fc-2400-4fab-9492-f1d36911298c/2ed2b132-7f96-4db7-80e8-9b68e0e2fdf7"
},
"private_bucket_and_iam": {
"status": "PASS",
"s3_exposed_host_ports": 0,
"minio_console_disabled": true,
"api_uses_scoped_credentials": "messenger_api_key",
"direct_unauth_s3_get": "403 Forbidden",
"s3_init_idempotent_rerun": 0
},
"s3_outage_handling": {
"status": "PASS",
"ready_during_s3_outage": 503,
"upload_during_s3_outage": 503,
"download_during_s3_outage": 503
},
"concurrent_streaming_memory": {
"status": "PASS",
"concurrent_uploads": 12,
"file_size_bytes": 4621523,
"file_size_mib": 4.41,
"total_payload_mib": 52.89,
"elapsed_seconds": 3.251,
"api_memory_baseline": {
"lab4-api-1": "43.64MiB / 256MiB",
"lab4-api-2": "51.44MiB / 256MiB"
},
"stats_during_concurrent_upload": {
"lab4-api-1": {
"mem": "56.23MiB / 256MiB",
"cpu": "0.79%"
},
"lab4-api-2": {
"mem": "52.38MiB / 256MiB",
"cpu": "0.82%"
},
"lab4-lb-1": {
"mem": "14.69MiB / 128MiB",
"cpu": "0.23%"
},
"lab4-redis-1": {
"mem": "3.734MiB / 256MiB",
"cpu": "0.35%"
},
"lab4-s3-1": {
"mem": "95.27MiB / 512MiB",
"cpu": "0.41%"
},
"lab4-postgres-1": {
"mem": "51.04MiB / 512MiB",
"cpu": "0.11%"
}
},
"api_temp_files_after": 0
}
}
}
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 4,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 15.0,
"elapsed_seconds": 15.008,
"concurrency": 4,
"successful_requests": 10001,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 666.386,
"successful_latency_ms": {
"p50": 4.893,
"p95": 10.807,
"p99": 20.305
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+96
View File
@@ -0,0 +1,96 @@
{
"timestamp_utc": "2026-11-16T23:53:59Z",
"healthy_attachments_verified": 25,
"injected_faults": {
"aged_orphan_s3_objects": 3,
"fresh_orphan_s3_inside_grace": 1,
"missing_s3_ready_referenced": 1,
"missing_s3_pending_stale": 1
},
"dry_run_report": {
"dry_run": true,
"grace_period_seconds": 5,
"lock_acquired": true,
"s3_objects_scanned": 79,
"db_rows_scanned": 78,
"orphan_s3_found": [
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_4fd8f77f-64b1-470c-b973-1c1255a86352",
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_de20049e-1906-4519-a652-ee54e9e13101",
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_fe71cc09-110e-406f-96a0-b3ca52491453"
],
"orphan_s3_deleted": [],
"orphan_s3_skipped_grace": [
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/fresh_af92437e-8430-4d64-b5b3-b90a6e92eb39"
],
"missing_s3_found": [
"a4d2ad97-ab03-4c84-b657-392221d850d6",
"f8aa5170-f723-448d-9fac-880bc06e4da0"
],
"missing_s3_marked_failed": [],
"missing_s3_deleted": [],
"missing_s3_skipped_grace": [],
"healthy_preserved": 75,
"s3_list_calls": 1,
"s3_remove_calls": 0,
"db_queries": 2,
"duration_ms": 18.395
},
"apply_report": {
"dry_run": false,
"grace_period_seconds": 5,
"lock_acquired": true,
"s3_objects_scanned": 79,
"db_rows_scanned": 78,
"orphan_s3_found": [
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_4fd8f77f-64b1-470c-b973-1c1255a86352",
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_de20049e-1906-4519-a652-ee54e9e13101",
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_fe71cc09-110e-406f-96a0-b3ca52491453"
],
"orphan_s3_deleted": [
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_4fd8f77f-64b1-470c-b973-1c1255a86352",
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_de20049e-1906-4519-a652-ee54e9e13101",
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/orphan_fe71cc09-110e-406f-96a0-b3ca52491453"
],
"orphan_s3_skipped_grace": [
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/fresh_af92437e-8430-4d64-b5b3-b90a6e92eb39"
],
"missing_s3_found": [
"a4d2ad97-ab03-4c84-b657-392221d850d6",
"f8aa5170-f723-448d-9fac-880bc06e4da0"
],
"missing_s3_marked_failed": [
"a4d2ad97-ab03-4c84-b657-392221d850d6"
],
"missing_s3_deleted": [
"f8aa5170-f723-448d-9fac-880bc06e4da0"
],
"missing_s3_skipped_grace": [],
"healthy_preserved": 75,
"s3_list_calls": 1,
"s3_remove_calls": 3,
"db_queries": 4,
"duration_ms": 27.038
},
"idempotent_rerun_report": {
"dry_run": false,
"grace_period_seconds": 5,
"lock_acquired": true,
"s3_objects_scanned": 76,
"db_rows_scanned": 77,
"orphan_s3_found": [],
"orphan_s3_deleted": [],
"orphan_s3_skipped_grace": [
"attachments/c0ab7718-6287-4ab8-81b9-0d89b3ab0b06/fresh_af92437e-8430-4d64-b5b3-b90a6e92eb39"
],
"missing_s3_found": [],
"missing_s3_marked_failed": [],
"missing_s3_deleted": [],
"missing_s3_skipped_grace": [],
"healthy_preserved": 75,
"s3_list_calls": 1,
"s3_remove_calls": 0,
"db_queries": 2,
"duration_ms": 19.697
},
"status": "PASS"
}
+31
View File
@@ -0,0 +1,31 @@
module messenger
go 1.24
require (
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.7.2
github.com/redis/go-redis/v9 v9.17.2
golang.org/x/crypto v0.33.0
golang.org/x/sync v0.11.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/goccy/go-json v0.10.5 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/klauspost/compress v1.17.11 // indirect
github.com/klauspost/cpuid/v2 v2.2.9 // indirect
github.com/minio/crc64nvme v1.0.1 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/minio/minio-go/v7 v7.0.88 // indirect
github.com/rs/xid v1.6.0 // indirect
golang.org/x/net v0.35.0 // indirect
golang.org/x/sys v0.30.0 // indirect
golang.org/x/text v0.22.0 // indirect
)
+64
View File
@@ -0,0 +1,64 @@
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI=
github.com/jackc/pgx/v5 v5.7.2/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.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=
github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
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/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.88 h1:v8MoIJjwYxOkehp+eiLIuvXk87P2raUtoU5klrAAshs=
github.com/minio/minio-go/v7 v7.0.88/go.mod h1:33+O8h0tO7pCeCWwBVa07RhVVfB/3vS4kEX7rwYKmIg=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.17.2 h1:P2EGsA4qVIM3Pp+aPocCJ7DguDHhqrXNhVcEp4ViluI=
github.com/redis/go-redis/v9 v9.17.2/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370=
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
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=
+40
View File
@@ -0,0 +1,40 @@
global
log stdout format raw local0
maxconn 4096
defaults
mode http
log global
option httplog
option dontlognull
option redispatch
retries 2
timeout connect 2s
timeout client 30s
timeout server 30s
timeout check 1500ms
resolvers docker_dns
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold other 2s
hold refused 2s
hold nx 2s
hold timeout 2s
hold valid 2s
hold obsolete 2s
frontend http_front
bind *:80
default_backend api_back
backend api_back
balance roundrobin
http-reuse safe
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host localhost
http-check expect status 200
default-server inter 1s fastinter 500ms downinter 1s fall 2 rise 1 resolvers docker_dns resolve-prefer ipv4 init-addr none maxconn 256
server-template api 1-8 api:8080 check
+26
View File
@@ -0,0 +1,26 @@
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::messenger-attachments"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::messenger-attachments/*"
]
}
]
}
+14
View File
@@ -0,0 +1,14 @@
# Redis 7.4 configuration for MTUCI Lab 3 (Shared Sessions + History Cache)
bind 0.0.0.0
port 6379
protected-mode no
# Durable persistence (AOF + RDB snapshot) so cached sessions survive container restarts
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec
save 60 1
# Memory limits
maxmemory 128mb
maxmemory-policy volatile-lru
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
set -eu
mc alias set local http://s3:9000 "${MINIO_ROOT_USER}" "${MINIO_ROOT_PASSWORD}"
mc mb --ignore-existing "local/${S3_BUCKET}"
mc anonymous set none "local/${S3_BUCKET}"
mc admin user add local "${S3_ACCESS_KEY_ID}" "${S3_SECRET_ACCESS_KEY}"
mc admin policy create local messenger-api-policy /infra/minio-api-policy.json
mc admin policy attach local messenger-api-policy --user "${S3_ACCESS_KEY_ID}"
+108
View File
@@ -0,0 +1,108 @@
package auth
import (
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"errors"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
const (
argonTime uint32 = 1
argonMemory uint32 = 19 * 1024 // 19 MiB (OWASP interactive recommendation)
argonThreads uint8 = 2
argonKeyLen uint32 = 32
argonSaltLen int = 16
)
var dummyHash string
func init() {
h, err := HashPassword("dummy-password-for-constant-time-check")
if err == nil {
dummyHash = h
}
}
// HashPassword hashes a UTF-8 password using Argon2id and returns a PHC-formatted string.
func HashPassword(password string) (string, error) {
salt := make([]byte, argonSaltLen)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("failed to generate salt: %w", err)
}
hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
b64Salt := base64.RawStdEncoding.EncodeToString(salt)
b64Hash := base64.RawStdEncoding.EncodeToString(hash)
encoded := fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version, argonMemory, argonTime, argonThreads, b64Salt, b64Hash)
return encoded, nil
}
// VerifyPassword compares a UTF-8 password against an Argon2id PHC string in constant time.
func VerifyPassword(password, encodedHash string) (bool, error) {
parts := strings.Split(encodedHash, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return false, errors.New("invalid argon2id hash format")
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil {
return false, err
}
var memory, 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
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return false, err
}
expectedHash, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return false, err
}
computedHash := argon2.IDKey([]byte(password), salt, timeCost, memory, threads, uint32(len(expectedHash)))
if subtle.ConstantTimeCompare(computedHash, expectedHash) == 1 {
return true, nil
}
return false, nil
}
// VerifyDummy runs an Argon2id verification against a dummy hash to prevent timing attacks on unknown usernames.
func VerifyDummy(password string) {
if dummyHash != "" {
_, _ = VerifyPassword(password, dummyHash)
}
}
// GenerateSessionToken generates an opaque 256-bit (32-byte) random token encoded as 64 hex chars,
// along with its SHA-256 hex digest for storage.
func GenerateSessionToken() (rawToken string, tokenHash string, err error) {
buf := make([]byte, 32) // 256 bits of entropy
if _, err := rand.Read(buf); err != nil {
return "", "", fmt.Errorf("failed to generate random token: %w", err)
}
rawToken = hex.EncodeToString(buf)
tokenHash = HashToken(rawToken)
return rawToken, tokenHash, nil
}
// HashToken returns the lowercase SHA-256 hex digest of an opaque session token.
func HashToken(rawToken string) string {
sum := sha256.Sum256([]byte(rawToken))
return hex.EncodeToString(sum[:])
}
+43
View File
@@ -0,0 +1,43 @@
package auth
import (
"strings"
"testing"
)
func TestHashAndVerifyPassword(t *testing.T) {
pw := "Сложный:Пароль:С:Двоеточиями:2026!🚀"
hash, err := HashPassword(pw)
if err != nil {
t.Fatalf("HashPassword failed: %v", err)
}
if !strings.HasPrefix(hash, "$argon2id$v=19$") {
t.Fatalf("expected Argon2id PHC prefix, got: %s", hash)
}
ok, err := VerifyPassword(pw, hash)
if err != nil || !ok {
t.Fatalf("expected password verification to succeed, err=%v, ok=%v", err, ok)
}
okWrong, err := VerifyPassword("WrongPassword-12345!", hash)
if err != nil || okWrong {
t.Fatalf("expected wrong password to fail verification")
}
}
func TestGenerateSessionToken(t *testing.T) {
raw, hash, err := GenerateSessionToken()
if err != nil {
t.Fatalf("GenerateSessionToken failed: %v", err)
}
if len(raw) != 64 {
t.Fatalf("expected 64-char hex raw token (256-bit), got len=%d", len(raw))
}
if len(hash) != 64 {
t.Fatalf("expected 64-char SHA-256 hex digest, got len=%d", len(hash))
}
if HashToken(raw) != hash {
t.Fatalf("HashToken mismatch")
}
}
+662
View File
@@ -0,0 +1,662 @@
package handler
import (
"context"
_ "embed"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"sync/atomic"
"time"
"unicode"
"unicode/utf8"
"github.com/google/uuid"
"messenger/internal/media"
"messenger/internal/model"
"messenger/internal/s3store"
"messenger/internal/store"
)
//go:embed openapi.json
var openAPISpec []byte
const swaggerUIHTML = `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>MTUCI Messenger API (Lab 4) - Swagger UI</title>
<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css" />
<style>
body { margin: 0; background: #fafafa; }
.swagger-ui .topbar { display: none; }
</style>
</head>
<body>
<div id="swagger-ui"></div>
<script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
<script>
window.onload = function() {
SwaggerUIBundle({
url: "/openapi.json",
dom_id: '#swagger-ui',
deepLinking: true,
presets: [
SwaggerUIBundle.presets.apis,
SwaggerUIBundle.SwaggerUIStandalonePreset
],
layout: "BaseLayout"
});
};
</script>
</body>
</html>`
type APIHandler struct {
store store.Store
s3 *s3store.Client
sessionTTL int
idempotencyTTL int
maxUploadBytes int64
maxImagePixels int64
instanceID string
draining atomic.Bool
}
func NewAPIHandler(st store.Store, s3 *s3store.Client, sessionTTL, idempotencyTTL int, maxUploadBytes, maxImagePixels int64, instanceID string) *APIHandler {
if sessionTTL <= 0 {
sessionTTL = 3600
}
if idempotencyTTL <= 0 {
idempotencyTTL = 86400
}
if maxUploadBytes <= 0 {
maxUploadBytes = 10 * 1024 * 1024
}
if maxImagePixels <= 0 {
maxImagePixels = 40_000_000
}
return &APIHandler{
store: st,
s3: s3,
sessionTTL: sessionTTL,
idempotencyTTL: idempotencyTTL,
maxUploadBytes: maxUploadBytes,
maxImagePixels: maxImagePixels,
instanceID: instanceID,
}
}
func (h *APIHandler) SetDraining(v bool) {
h.draining.Store(v)
}
func (h *APIHandler) IsDraining() bool {
return h.draining.Load()
}
func decodeJSON(r *http.Request, dst interface{}) error {
if r.Body == nil {
return errors.New("request body is missing")
}
defer r.Body.Close()
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
if errors.Is(err, io.EOF) {
return errors.New("request body is empty")
}
var unmarshalTypeError *json.UnmarshalTypeError
if errors.As(err, &unmarshalTypeError) {
return fmt.Errorf("field '%s' has incorrect type (expected %s)", unmarshalTypeError.Field, unmarshalTypeError.Type)
}
return fmt.Errorf("malformed JSON or unexpected field: %v", err)
}
if dec.More() {
return errors.New("request body contains multiple JSON values")
}
return nil
}
func writeStoreError(w http.ResponseWriter, r *http.Request, err error) {
switch {
case errors.Is(err, store.ErrConflict):
WriteError(w, r, http.StatusConflict, "conflict", "resource conflict")
case errors.Is(err, store.ErrNotFound):
WriteError(w, r, http.StatusNotFound, "not_found", "resource not found or access denied")
case errors.Is(err, store.ErrUnauthorized):
WriteBearerUnauthorized(w, r, "unauthorized")
case errors.Is(err, store.ErrUnavailable):
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "storage dependency is temporarily unavailable")
case errors.Is(err, store.ErrBadRequest):
WriteError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
default:
WriteError(w, r, http.StatusInternalServerError, "internal_error", "internal server error")
}
}
func (h *APIHandler) HandleLiveness(w http.ResponseWriter, r *http.Request) {
WriteJSON(w, r, http.StatusOK, model.HealthResponse{Status: "ok"})
}
func (h *APIHandler) HandleReadiness(w http.ResponseWriter, r *http.Request) {
if h.IsDraining() {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "instance is draining")
return
}
if err := h.store.Ready(r.Context()); err != nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "database dependency is not ready")
return
}
if h.s3 == nil || h.s3.Ready(r.Context()) != nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage dependency is not ready")
return
}
WriteJSON(w, r, http.StatusOK, model.HealthResponse{Status: "ok"})
}
func (h *APIHandler) HandleRegisterUser(w http.ResponseWriter, r *http.Request) {
var req model.CreateUserRequest
if err := decodeJSON(r, &req); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
return
}
user, err := h.store.CreateUser(r.Context(), req)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusCreated, user)
}
func (h *APIHandler) HandleCreateSession(w http.ResponseWriter, r *http.Request) {
// Contract: POST /auth/sessions accepts ONLY Authorization: Basic <base64(username:password)>, without JSON body.
if r.Body != nil {
defer r.Body.Close()
var buf [1]byte
n, _ := r.Body.Read(buf[:])
if n > 0 {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "POST /api/v1/auth/sessions must not include a request body")
return
}
}
authHeader := strings.TrimSpace(r.Header.Get("Authorization"))
if authHeader == "" {
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
parts := strings.SplitN(authHeader, " ", 2)
if len(parts) != 2 || !strings.EqualFold(parts[0], "Basic") {
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
b64Payload := strings.TrimSpace(parts[1])
decoded, err := base64.StdEncoding.DecodeString(b64Payload)
if err != nil || !utf8.Valid(decoded) {
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
credParts := strings.SplitN(string(decoded), ":", 2)
if len(credParts) != 2 {
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
username := credParts[0]
password := credParts[1]
sess, err := h.store.AuthenticateAndCreateSession(r.Context(), username, password, h.sessionTTL)
if err != nil {
if errors.Is(err, store.ErrUnavailable) {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "storage dependency is temporarily unavailable")
return
}
WriteBasicUnauthorized(w, r, "invalid credentials")
return
}
WriteJSON(w, r, http.StatusCreated, sess)
}
func (h *APIHandler) HandleRevokeSession(w http.ResponseWriter, r *http.Request) {
rawToken := GetAuthToken(r.Context())
if rawToken == "" {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
if err := h.store.RevokeSession(r.Context(), rawToken); err != nil {
if errors.Is(err, store.ErrUnavailable) {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "storage dependency is temporarily unavailable")
return
}
WriteBearerUnauthorized(w, r, "session already revoked or expired")
return
}
reqID := GetRequestID(r.Context())
w.Header().Set("X-Request-Id", reqID)
w.WriteHeader(http.StatusNoContent)
}
func (h *APIHandler) HandleCurrentUser(w http.ResponseWriter, r *http.Request) {
user := GetAuthUser(r.Context())
if user == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
WriteJSON(w, r, http.StatusOK, user)
}
func (h *APIHandler) HandleCreateChat(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
var req model.CreateChatRequest
if err := decodeJSON(r, &req); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
return
}
chat, err := h.store.CreateChat(r.Context(), caller.ID, req)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusCreated, chat)
}
func (h *APIHandler) HandleListChats(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
limit := 50
limitStr := r.URL.Query().Get("limit")
if limitStr != "" {
l, err := strconv.Atoi(limitStr)
if err != nil || l < 1 || l > 100 {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "limit must be an integer between 1 and 100")
return
}
limit = l
}
cursor := r.URL.Query().Get("cursor")
page, err := h.store.ListChats(r.Context(), caller.ID, limit, cursor)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusOK, page)
}
func (h *APIHandler) HandleGetChat(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id UUID")
return
}
chat, err := h.store.GetChat(r.Context(), caller.ID, chatID)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusOK, chat)
}
func (h *APIHandler) HandleCreateMessage(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id UUID")
return
}
idemKey := r.Header.Get("Idempotency-Key")
if !store.IdempotencyKeyRegex.MatchString(idemKey) {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "Idempotency-Key header is required and must match ^[A-Za-z0-9._:-]{1,128}$")
return
}
var req model.CreateMessageRequest
if err := decodeJSON(r, &req); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
return
}
msg, err := h.store.CreateMessage(r.Context(), caller.ID, chatID, idemKey, h.idempotencyTTL, req)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusCreated, msg)
}
func (h *APIHandler) HandleListMessages(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id UUID")
return
}
limit := 50
limitStr := r.URL.Query().Get("limit")
if limitStr != "" {
l, err := strconv.Atoi(limitStr)
if err != nil || l < 1 || l > 100 {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "limit must be an integer between 1 and 100")
return
}
limit = l
}
cursor := r.URL.Query().Get("cursor")
page, err := h.store.ListMessages(r.Context(), caller.ID, chatID, limit, cursor)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusOK, page)
}
func (h *APIHandler) HandleInternalStats(w http.ResponseWriter, r *http.Request) {
if r.URL.Query().Get("reset") == "1" {
h.store.ResetStats()
}
if mode := r.URL.Query().Get("mode"); mode != "" {
h.store.SetCacheMode(mode)
}
WriteJSON(w, r, http.StatusOK, h.store.Stats(r.Context()))
}
func (h *APIHandler) HandleOpenAPISpec(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Header().Set("X-Request-Id", GetRequestID(r.Context()))
w.WriteHeader(http.StatusOK)
_, _ = w.Write(openAPISpec)
}
func (h *APIHandler) HandleSwaggerUI(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("X-Request-Id", GetRequestID(r.Context()))
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(swaggerUIHTML))
}
func (h *APIHandler) HandleNotFound(w http.ResponseWriter, r *http.Request) {
WriteError(w, r, http.StatusNotFound, "not_found", fmt.Sprintf("route %s %s not found", r.Method, r.URL.Path))
}
func validateFilename(name string) bool {
if strings.TrimSpace(name) == "" {
return false
}
n := utf8.RuneCountInString(name)
if n < 1 || n > 255 {
return false
}
for _, r := range name {
if r == '/' || r == '\\' || r == 0 || unicode.IsControl(r) {
return false
}
}
return true
}
func (h *APIHandler) HandleUploadAttachment(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id UUID")
return
}
filename := r.URL.Query().Get("filename")
if !validateFilename(filename) {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid or missing filename")
return
}
contentTypeHeader := r.Header.Get("Content-Type")
if _, err := media.ParseAllowedContentType(contentTypeHeader); err != nil {
WriteError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "Content-Type must be image/png or image/jpeg")
return
}
if r.ContentLength > h.maxUploadBytes {
WriteError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "upload exceeds maximum allowed byte size")
return
}
// Enforce chat membership BEFORE spooling bytes or touching S3
isMember, err := h.store.IsChatMember(r.Context(), caller.ID, chatID)
if err != nil {
writeStoreError(w, r, err)
return
}
if !isMember {
WriteError(w, r, http.StatusNotFound, "not_found", "resource not found or access denied")
return
}
if h.s3 == nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage dependency is unavailable")
return
}
r.Body = http.MaxBytesReader(w, r.Body, h.maxUploadBytes+1024)
img, err := media.ValidateAndSpoolImage(r.Body, contentTypeHeader, h.maxUploadBytes, h.maxImagePixels)
if err != nil {
switch {
case errors.Is(err, media.ErrPayloadTooLarge):
WriteError(w, r, http.StatusRequestEntityTooLarge, "payload_too_large", "image exceeds byte or pixel limit")
case errors.Is(err, media.ErrUnsupportedMediaType):
WriteError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "payload is not a valid PNG or JPEG image matching Content-Type")
default:
WriteError(w, r, http.StatusBadRequest, "invalid_request", "failed to read upload stream")
}
return
}
defer img.Cleanup()
attID := uuid.New().String()
objectKey := fmt.Sprintf("attachments/%s/%s", chatID, attID)
if err := h.s3.PutObject(r.Context(), objectKey, img.File, img.SizeBytes, img.ContentType); err != nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage temporarily unavailable")
return
}
att, err := h.store.CreateAttachment(r.Context(), model.Attachment{
ID: attID,
ChatID: chatID,
OwnerID: caller.ID,
Filename: filename,
ContentType: img.ContentType,
SizeBytes: img.SizeBytes,
SHA256: img.SHA256,
ObjectKey: objectKey,
})
if err != nil {
// Immediate synchronous compensation: delete the unreferenced S3 object if DB commit failed.
compCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
_ = h.s3.RemoveObject(compCtx, objectKey)
cancel()
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusCreated, att)
}
func (h *APIHandler) HandleGetAttachment(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
attID := r.PathValue("attachment_id")
if _, err := uuid.Parse(attID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id UUID")
return
}
att, err := h.store.GetAttachment(r.Context(), caller.ID, attID)
if err != nil {
writeStoreError(w, r, err)
return
}
WriteJSON(w, r, http.StatusOK, att)
}
func (h *APIHandler) HandleDownloadAttachmentContent(w http.ResponseWriter, r *http.Request) {
caller := GetAuthUser(r.Context())
if caller == nil {
WriteBearerUnauthorized(w, r, "unauthenticated")
return
}
attID := r.PathValue("attachment_id")
if _, err := uuid.Parse(attID); err != nil {
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid attachment id UUID")
return
}
variant := r.URL.Query().Get("variant")
if variant != "" && variant != "original" {
if variant == "thumbnail" || variant == "crop" || variant == "optimized" {
WriteError(w, r, http.StatusNotFound, "not_found", "requested variant does not exist")
return
}
WriteError(w, r, http.StatusBadRequest, "invalid_request", "invalid variant query parameter")
return
}
att, err := h.store.GetAttachment(r.Context(), caller.ID, attID)
if err != nil {
writeStoreError(w, r, err)
return
}
if att.Status != "ready" {
WriteError(w, r, http.StatusConflict, "conflict", "attachment is not ready for download")
return
}
if h.s3 == nil {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage temporarily unavailable")
return
}
obj, objSize, err := h.s3.GetObject(r.Context(), att.ObjectKey)
if err != nil {
if errors.Is(err, s3store.ErrObjectNotFound) {
WriteError(w, r, http.StatusConflict, "conflict", "attachment binary object is unavailable")
return
}
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "object storage temporarily unavailable")
return
}
defer obj.Close()
w.Header().Set("Content-Type", att.ContentType)
w.Header().Set("Content-Length", strconv.FormatInt(objSize, 10))
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("X-Request-Id", GetRequestID(r.Context()))
w.WriteHeader(http.StatusOK)
_, _ = io.Copy(w, obj)
}
func RegisterRoutes(st store.Store, s3 *s3store.Client, sessionTTL, idempotencyTTL int, maxUploadBytes, maxImagePixels int64, instanceID string) (http.Handler, *APIHandler) {
api := NewAPIHandler(st, s3, sessionTTL, idempotencyTTL, maxUploadBytes, maxImagePixels, instanceID)
mux := http.NewServeMux()
// Documentation & schema
mux.HandleFunc("GET /docs", api.HandleSwaggerUI)
mux.HandleFunc("GET /docs/", api.HandleSwaggerUI)
mux.HandleFunc("GET /openapi.json", api.HandleOpenAPISpec)
// Internal diagnostics for experiments
mux.HandleFunc("GET /internal/stats", api.HandleInternalStats)
mux.HandleFunc("POST /internal/stats", api.HandleInternalStats)
// Public routes
mux.HandleFunc("GET /health/live", api.HandleLiveness)
mux.HandleFunc("GET /health/ready", api.HandleReadiness)
mux.HandleFunc("POST /api/v1/users", api.HandleRegisterUser)
mux.HandleFunc("POST /api/v1/auth/sessions", api.HandleCreateSession)
// Protected Bearer routes
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", RequireBearerAuth(st, api.HandleRevokeSession))
mux.HandleFunc("GET /api/v1/users/me", RequireBearerAuth(st, api.HandleCurrentUser))
mux.HandleFunc("POST /api/v1/chats", RequireBearerAuth(st, api.HandleCreateChat))
mux.HandleFunc("GET /api/v1/chats", RequireBearerAuth(st, api.HandleListChats))
mux.HandleFunc("GET /api/v1/chats/{chat_id}", RequireBearerAuth(st, api.HandleGetChat))
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", RequireBearerAuth(st, api.HandleCreateMessage))
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", RequireBearerAuth(st, api.HandleListMessages))
mux.HandleFunc("POST /api/v1/chats/{chat_id}/attachments", RequireBearerAuth(st, api.HandleUploadAttachment))
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}", RequireBearerAuth(st, api.HandleGetAttachment))
mux.HandleFunc("GET /api/v1/attachments/{attachment_id}/content", RequireBearerAuth(st, api.HandleDownloadAttachmentContent))
// Fallback 404 handler
mux.HandleFunc("/", api.HandleNotFound)
var handler http.Handler = mux
handler = LoggingMiddleware(instanceID, handler)
handler = RequestIDMiddleware(handler)
handler = InstanceIDMiddleware(instanceID, handler)
return handler, api
}
+168
View File
@@ -0,0 +1,168 @@
package handler
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"os"
"strings"
"time"
"github.com/google/uuid"
"messenger/internal/model"
"messenger/internal/store"
)
type contextKey string
const (
requestIDContextKey contextKey = "request_id"
userContextKey contextKey = "user"
tokenContextKey contextKey = "token"
)
type loggingResponseWriter struct {
http.ResponseWriter
statusCode int
}
func (lrw *loggingResponseWriter) WriteHeader(code int) {
lrw.statusCode = code
lrw.ResponseWriter.WriteHeader(code)
}
func InstanceIDMiddleware(instanceID string, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-Instance-Id", instanceID)
next.ServeHTTP(w, r)
})
}
func RequestIDMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
reqID := strings.TrimSpace(r.Header.Get("X-Request-Id"))
if reqID == "" {
reqID = uuid.New().String()
}
w.Header().Set("X-Request-Id", reqID)
ctx := context.WithValue(r.Context(), requestIDContextKey, reqID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
func LoggingMiddleware(instanceID string, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
lrw := &loggingResponseWriter{ResponseWriter: w, statusCode: http.StatusOK}
next.ServeHTTP(lrw, r)
reqID, _ := r.Context().Value(requestIDContextKey).(string)
duration := time.Since(start)
logEntry := map[string]interface{}{
"time": time.Now().UTC().Format(time.RFC3339Nano),
"instance_id": instanceID,
"method": r.Method,
"path": r.URL.Path,
"status": lrw.statusCode,
"duration_ms": float64(duration.Microseconds()) / 1000.0,
"request_id": reqID,
"remote_ip": r.RemoteAddr,
}
logBytes, _ := json.Marshal(logEntry)
fmt.Fprintln(os.Stdout, string(logBytes))
})
}
func GetRequestID(ctx context.Context) string {
if val, ok := ctx.Value(requestIDContextKey).(string); ok && val != "" {
return val
}
return uuid.New().String()
}
func WriteError(w http.ResponseWriter, r *http.Request, status int, code, message string) {
reqID := GetRequestID(r.Context())
w.Header().Set("Content-Type", "application/json")
w.Header().Set("X-Request-Id", reqID)
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(model.ErrorResponse{
Error: model.ErrorDetail{
Code: code,
Message: message,
RequestID: reqID,
},
})
}
func WriteBasicUnauthorized(w http.ResponseWriter, r *http.Request, message string) {
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
WriteError(w, r, http.StatusUnauthorized, "unauthorized", message)
}
func WriteBearerUnauthorized(w http.ResponseWriter, r *http.Request, message string) {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
WriteError(w, r, http.StatusUnauthorized, "unauthorized", message)
}
func WriteJSON(w http.ResponseWriter, r *http.Request, status int, data interface{}) {
reqID := GetRequestID(r.Context())
w.Header().Set("Content-Type", "application/json")
w.Header().Set("X-Request-Id", reqID)
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(data)
}
func RequireBearerAuth(st store.Store, next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// Note: X-User-Id is intentionally ignored in Lab 2+ per contract.
authHeader := strings.TrimSpace(r.Header.Get("Authorization"))
if authHeader == "" {
WriteBearerUnauthorized(w, r, "missing Authorization header")
return
}
parts := strings.SplitN(authHeader, " ", 2)
if len(parts) != 2 || !strings.EqualFold(parts[0], "Bearer") {
WriteBearerUnauthorized(w, r, "Bearer authentication required")
return
}
rawToken := strings.TrimSpace(parts[1])
if rawToken == "" || strings.ContainsAny(rawToken, " \t\r\n") {
WriteBearerUnauthorized(w, r, "invalid Bearer token")
return
}
user, err := st.GetUserByToken(r.Context(), rawToken)
if err != nil {
if errors.Is(err, store.ErrUnavailable) {
WriteError(w, r, http.StatusServiceUnavailable, "unavailable", "storage dependency is temporarily unavailable")
return
}
WriteBearerUnauthorized(w, r, "invalid, expired, or revoked session token")
return
}
ctx := context.WithValue(r.Context(), userContextKey, user)
ctx = context.WithValue(ctx, tokenContextKey, rawToken)
next(w, r.WithContext(ctx))
}
}
func GetAuthUser(ctx context.Context) *model.User {
if user, ok := ctx.Value(userContextKey).(*model.User); ok {
return user
}
return nil
}
func GetAuthToken(ctx context.Context) string {
if tok, ok := ctx.Value(tokenContextKey).(string); ok {
return tok
}
return ""
}
File diff suppressed because it is too large Load Diff
+314
View File
@@ -0,0 +1,314 @@
package media
import (
"bufio"
"bytes"
"crypto/sha256"
"encoding/binary"
"encoding/hex"
"errors"
"fmt"
"hash/crc32"
"image"
"image/jpeg"
"image/png"
"io"
"mime"
"net/http"
"os"
"strings"
)
var (
ErrPayloadTooLarge = errors.New("payload too large")
ErrUnsupportedMediaType = errors.New("unsupported or corrupted media")
ErrBadFilename = errors.New("invalid filename")
)
var pngSignature = []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a}
type ValidatedImage struct {
File *os.File
SizeBytes int64
SHA256 string
ContentType string
Width int
Height int
}
func (v *ValidatedImage) Cleanup() {
if v != nil && v.File != nil {
name := v.File.Name()
_ = v.File.Close()
_ = os.Remove(name)
v.File = nil
}
}
func ParseAllowedContentType(headerVal string) (string, error) {
mediaType, _, err := mime.ParseMediaType(strings.TrimSpace(headerVal))
if err != nil {
return "", ErrUnsupportedMediaType
}
mediaType = strings.ToLower(mediaType)
if mediaType != "image/png" && mediaType != "image/jpeg" {
return "", ErrUnsupportedMediaType
}
return mediaType, nil
}
// ValidateAndSpoolImage streams upload bytes into an ephemeral temp file while enforcing
// maxBytes, verifying magic bytes against declared Content-Type, checking pixel limits
// before bitmap allocation, and checking PNG/JPEG container integrity in bounded RAM.
func ValidateAndSpoolImage(r io.Reader, declaredContentType string, maxBytes int64, maxPixels int64) (*ValidatedImage, error) {
ct, err := ParseAllowedContentType(declaredContentType)
if err != nil {
return nil, err
}
if maxBytes <= 0 {
maxBytes = 10 * 1024 * 1024
}
if maxPixels <= 0 {
maxPixels = 40_000_000
}
tmpFile, err := os.CreateTemp("", "lab4-upload-*")
if err != nil {
return nil, fmt.Errorf("create temp spool file: %w", err)
}
cleanupTmp := true
defer func() {
if cleanupTmp && tmpFile != nil {
name := tmpFile.Name()
_ = tmpFile.Close()
_ = os.Remove(name)
}
}()
hasher := sha256.New()
buf := make([]byte, 32*1024)
n, err := io.CopyBuffer(io.MultiWriter(tmpFile, hasher), io.LimitReader(r, maxBytes+1), buf)
if err != nil {
return nil, ErrBadFilename
}
if n == 0 {
return nil, ErrUnsupportedMediaType
}
if n > maxBytes {
return nil, ErrPayloadTooLarge
}
if _, err := tmpFile.Seek(0, io.SeekStart); err != nil {
return nil, err
}
// Verify content magic bytes match declared Content-Type (prevents MIME spoofing).
head := make([]byte, 512)
headLen, _ := io.ReadFull(tmpFile, head)
if headLen == 0 {
return nil, ErrUnsupportedMediaType
}
sniffed := http.DetectContentType(head[:headLen])
if ct == "image/png" {
if headLen < len(pngSignature) || !bytes.Equal(head[:8], pngSignature) || sniffed != "image/png" {
return nil, ErrUnsupportedMediaType
}
} else {
if headLen < 3 || head[0] != 0xff || head[1] != 0xd8 || head[2] != 0xff || sniffed != "image/jpeg" {
return nil, ErrUnsupportedMediaType
}
}
// Parse image header BEFORE full pixel decode to prevent decompression-bomb OOMs.
if _, err := tmpFile.Seek(0, io.SeekStart); err != nil {
return nil, err
}
cfg, format, err := image.DecodeConfig(tmpFile)
if err != nil {
return nil, ErrUnsupportedMediaType
}
if (ct == "image/png" && format != "png") || (ct == "image/jpeg" && format != "jpeg") {
return nil, ErrUnsupportedMediaType
}
if cfg.Width <= 0 || cfg.Height <= 0 {
return nil, ErrUnsupportedMediaType
}
if int64(cfg.Width) > maxPixels/int64(cfg.Height) {
return nil, ErrPayloadTooLarge
}
// Verify structural integrity in bounded memory.
if _, err := tmpFile.Seek(0, io.SeekStart); err != nil {
return nil, err
}
if ct == "image/png" {
if err := verifyPNGChunks(tmpFile); err != nil {
return nil, ErrUnsupportedMediaType
}
if int64(cfg.Width)*int64(cfg.Height) <= 2_000_000 {
_, _ = tmpFile.Seek(0, io.SeekStart)
if _, err := png.Decode(tmpFile); err != nil {
return nil, ErrUnsupportedMediaType
}
}
} else {
if err := verifyJPEGStructure(tmpFile); err != nil {
return nil, ErrUnsupportedMediaType
}
if int64(cfg.Width)*int64(cfg.Height) <= 2_000_000 {
_, _ = tmpFile.Seek(0, io.SeekStart)
if _, err := jpeg.Decode(tmpFile); err != nil {
return nil, ErrUnsupportedMediaType
}
}
}
if _, err := tmpFile.Seek(0, io.SeekStart); err != nil {
return nil, err
}
cleanupTmp = false
return &ValidatedImage{
File: tmpFile,
SizeBytes: n,
SHA256: hex.EncodeToString(hasher.Sum(nil)),
ContentType: ct,
Width: cfg.Width,
Height: cfg.Height,
}, nil
}
func verifyPNGChunks(r io.Reader) error {
sig := make([]byte, 8)
if _, err := io.ReadFull(r, sig); err != nil || !bytes.Equal(sig, pngSignature) {
return errors.New("invalid PNG signature")
}
header := make([]byte, 8)
crcBuf := make([]byte, 4)
scratch := make([]byte, 32*1024)
seenIHDR := false
seenIEND := false
for {
_, err := io.ReadFull(r, header)
if err != nil {
return errors.New("truncated PNG chunk")
}
chunkLen := binary.BigEndian.Uint32(header[0:4])
if chunkLen > 10*1024*1024 {
return errors.New("PNG chunk too large")
}
chunkType := string(header[4:8])
if !seenIHDR && chunkType != "IHDR" {
return errors.New("first PNG chunk must be IHDR")
}
if chunkType == "IHDR" {
seenIHDR = true
}
crc := crc32.NewIEEE()
_, _ = crc.Write(header[4:8])
remaining := int64(chunkLen)
for remaining > 0 {
toRead := int64(len(scratch))
if remaining < toRead {
toRead = remaining
}
m, rErr := io.ReadFull(r, scratch[:toRead])
if rErr != nil {
return errors.New("truncated PNG chunk data")
}
_, _ = crc.Write(scratch[:m])
remaining -= int64(m)
}
if _, err := io.ReadFull(r, crcBuf); err != nil {
return errors.New("missing PNG CRC")
}
expectedCRC := binary.BigEndian.Uint32(crcBuf)
if crc.Sum32() != expectedCRC {
return errors.New("PNG CRC mismatch")
}
if chunkType == "IEND" {
seenIEND = true
break
}
}
if !seenIHDR || !seenIEND {
return errors.New("incomplete PNG structure")
}
return nil
}
func verifyJPEGStructure(r io.Reader) error {
br := bufio.NewReaderSize(r, 32*1024)
b0, err := br.ReadByte()
b1, err2 := br.ReadByte()
if err != nil || err2 != nil || b0 != 0xff || b1 != 0xd8 {
return errors.New("missing JPEG SOI")
}
seenSOF := false
seenSOS := false
seenEOI := false
for {
b, err := br.ReadByte()
if err != nil {
break
}
if b != 0xff {
if !seenSOS {
return errors.New("unexpected bytes before JPEG SOS")
}
continue
}
for {
b, err = br.ReadByte()
if err != nil {
return errors.New("truncated JPEG marker")
}
if b != 0xff {
break
}
}
marker := b
if marker == 0x00 || (marker >= 0xd0 && marker <= 0xd7) {
continue
}
if marker == 0xd9 {
seenEOI = true
break
}
if marker == 0x01 || marker == 0xd8 {
continue
}
var lenBuf [2]byte
if _, err := io.ReadFull(br, lenBuf[:]); err != nil {
return errors.New("truncated JPEG segment length")
}
segLen := int(binary.BigEndian.Uint16(lenBuf[:]))
if segLen < 2 {
return errors.New("invalid JPEG segment length")
}
if _, err := io.CopyN(io.Discard, br, int64(segLen-2)); err != nil {
return errors.New("truncated JPEG segment payload")
}
if (marker >= 0xc0 && marker <= 0xc3) || (marker >= 0xc5 && marker <= 0xc7) || (marker >= 0xc9 && marker <= 0xcb) || (marker >= 0xcd && marker <= 0xcf) {
seenSOF = true
}
if marker == 0xda {
seenSOS = true
}
}
if !seenSOF || !seenSOS || !seenEOI {
return errors.New("incomplete JPEG structure")
}
return nil
}
+102
View File
@@ -0,0 +1,102 @@
package model
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt string `json:"created_at"`
}
type CreateUserRequest struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
type Session struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt string `json:"expires_at"`
User User `json:"user"`
}
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt string `json:"created_at"`
}
type CreateChatRequest struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
type Variant struct {
Name string `json:"name"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
Width int `json:"width"`
Height int `json:"height"`
SHA256 string `json:"sha256"`
}
type Attachment struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
OwnerID string `json:"owner_id"`
Filename string `json:"filename"`
ContentType string `json:"content_type"`
SizeBytes int64 `json:"size_bytes"`
SHA256 string `json:"sha256"`
Status string `json:"status"`
Variants []Variant `json:"variants"`
ErrorCode *string `json:"error_code"`
CreatedAt string `json:"created_at"`
UpdatedAt string `json:"updated_at"`
ObjectKey string `json:"-"`
}
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt string `json:"created_at"`
AttachmentIDs []string `json:"attachment_ids"`
}
type CreateMessageRequest struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids,omitempty"`
}
type ChatPage struct {
Items []Chat `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type MessagePage struct {
Items []Message `json:"items"`
NextCursor *string `json:"next_cursor"`
}
type ErrorDetail struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
type ErrorResponse struct {
Error ErrorDetail `json:"error"`
}
type HealthResponse struct {
Status string `json:"status"`
}
type CursorData struct {
Scope string `json:"s"`
Time string `json:"t"`
ID string `json:"i"`
}
+173
View File
@@ -0,0 +1,173 @@
package s3store
import (
"context"
"errors"
"fmt"
"io"
"net"
"net/http"
"net/url"
"strings"
"time"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
var (
ErrObjectNotFound = errors.New("s3 object not found")
ErrS3Unavailable = errors.New("s3 storage unavailable")
)
type Config struct {
Endpoint string
Region string
Bucket string
AccessKey string
SecretKey string
}
type ObjectSummary struct {
Key string
Size int64
LastModified time.Time
}
type Client struct {
mc *minio.Client
bucket string
}
func NewClient(cfg Config) (*Client, error) {
u, err := url.Parse(strings.TrimSpace(cfg.Endpoint))
if err != nil || u.Host == "" {
return nil, fmt.Errorf("invalid S3 endpoint %q", cfg.Endpoint)
}
useSSL := strings.EqualFold(u.Scheme, "https")
region := strings.TrimSpace(cfg.Region)
if region == "" {
region = "us-east-1"
}
tr := &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 800 * time.Millisecond,
KeepAlive: 30 * time.Second,
}).DialContext,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 2 * time.Second,
ResponseHeaderTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
mc, err := minio.New(u.Host, &minio.Options{
Creds: credentials.NewStaticV4(cfg.AccessKey, cfg.SecretKey, ""),
Secure: useSSL,
Region: region,
BucketLookup: minio.BucketLookupPath,
Transport: tr,
MaxRetries: 1,
})
if err != nil {
return nil, fmt.Errorf("create minio client: %w", err)
}
return &Client{
mc: mc,
bucket: cfg.Bucket,
}, nil
}
func (c *Client) Bucket() string {
return c.bucket
}
func (c *Client) Ready(ctx context.Context) error {
rCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
exists, err := c.mc.BucketExists(rCtx, c.bucket)
if err != nil || !exists {
return ErrS3Unavailable
}
return nil
}
func (c *Client) PutObject(ctx context.Context, objectKey string, r io.Reader, size int64, contentType string) error {
pCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
_, err := c.mc.PutObject(pCtx, c.bucket, objectKey, r, size, minio.PutObjectOptions{
ContentType: contentType,
})
if err != nil {
return fmt.Errorf("%w: %v", ErrS3Unavailable, err)
}
return nil
}
func (c *Client) GetObject(ctx context.Context, objectKey string) (io.ReadCloser, int64, error) {
obj, err := c.mc.GetObject(ctx, c.bucket, objectKey, minio.GetObjectOptions{})
if err != nil {
return nil, 0, fmt.Errorf("%w: %v", ErrS3Unavailable, err)
}
info, err := obj.Stat()
if err != nil {
_ = obj.Close()
errResp := minio.ToErrorResponse(err)
if errResp.Code == "NoSuchKey" || errResp.StatusCode == 404 {
return nil, 0, ErrObjectNotFound
}
return nil, 0, fmt.Errorf("%w: %v", ErrS3Unavailable, err)
}
return obj, info.Size, nil
}
func (c *Client) StatObject(ctx context.Context, objectKey string) (bool, error) {
sCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
_, err := c.mc.StatObject(sCtx, c.bucket, objectKey, minio.StatObjectOptions{})
if err != nil {
errResp := minio.ToErrorResponse(err)
if errResp.Code == "NoSuchKey" || errResp.StatusCode == 404 {
return false, nil
}
return false, fmt.Errorf("%w: %v", ErrS3Unavailable, err)
}
return true, nil
}
func (c *Client) RemoveObject(ctx context.Context, objectKey string) error {
dCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if err := c.mc.RemoveObject(dCtx, c.bucket, objectKey, minio.RemoveObjectOptions{}); err != nil {
errResp := minio.ToErrorResponse(err)
if errResp.Code == "NoSuchKey" || errResp.StatusCode == 404 {
return nil
}
return fmt.Errorf("%w: %v", ErrS3Unavailable, err)
}
return nil
}
func (c *Client) ListObjects(ctx context.Context, prefix string) ([]ObjectSummary, error) {
lCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
var out []ObjectSummary
for obj := range c.mc.ListObjects(lCtx, c.bucket, minio.ListObjectsOptions{
Prefix: prefix,
Recursive: true,
}) {
if obj.Err != nil {
return nil, fmt.Errorf("%w: %v", ErrS3Unavailable, obj.Err)
}
out = append(out, ObjectSummary{
Key: obj.Key,
Size: obj.Size,
LastModified: obj.LastModified,
})
}
return out, nil
}
File diff suppressed because it is too large Load Diff
+130
View File
@@ -0,0 +1,130 @@
package store
import (
"context"
"encoding/base64"
"encoding/json"
"errors"
"regexp"
"time"
"github.com/google/uuid"
"messenger/internal/model"
"messenger/internal/s3store"
)
var (
ErrConflict = errors.New("conflict")
ErrNotFound = errors.New("not found")
ErrBadRequest = errors.New("bad request")
ErrUnauthorized = errors.New("unauthorized")
ErrUnavailable = errors.New("service unavailable")
usernameRegex = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
IdempotencyKeyRegex = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
)
const TimestampFormat = "2006-01-02T15:04:05.000000Z"
func FormatTime(t time.Time) string {
return t.UTC().Truncate(time.Microsecond).Format(TimestampFormat)
}
func NowUTC() time.Time {
return time.Now().UTC().Truncate(time.Microsecond)
}
type MigrationFile struct {
Version string
SQL string
}
type ReconcileReport struct {
DryRun bool `json:"dry_run"`
GracePeriodSeconds int64 `json:"grace_period_seconds"`
LockAcquired bool `json:"lock_acquired"`
S3ObjectsScanned int `json:"s3_objects_scanned"`
DBRowsScanned int `json:"db_rows_scanned"`
OrphanS3Found []string `json:"orphan_s3_found"`
OrphanS3Deleted []string `json:"orphan_s3_deleted"`
OrphanS3SkippedGrace []string `json:"orphan_s3_skipped_grace"`
MissingS3Found []string `json:"missing_s3_found"`
MissingS3MarkedFailed []string `json:"missing_s3_marked_failed"`
MissingS3Deleted []string `json:"missing_s3_deleted"`
MissingS3SkippedGrace []string `json:"missing_s3_skipped_grace"`
HealthyPreserved int `json:"healthy_preserved"`
S3ListCalls int `json:"s3_list_calls"`
S3RemoveCalls int `json:"s3_remove_calls"`
DBQueries int `json:"db_queries"`
DurationMs float64 `json:"duration_ms"`
}
type StoreStats struct {
SQLQueries int64 `json:"sql_queries"`
CacheHits int64 `json:"cache_hits"`
CacheMisses int64 `json:"cache_misses"`
SingleflightShared int64 `json:"singleflight_shared"`
CacheMode string `json:"cache_mode"`
WriteMode string `json:"write_mode"`
RedisConnected bool `json:"redis_connected"`
}
type Store interface {
Ready(ctx context.Context) error
RunMigrations(ctx context.Context, migrations []MigrationFile) error
CreateUser(ctx context.Context, req model.CreateUserRequest) (*model.User, error)
AuthenticateAndCreateSession(ctx context.Context, username, password string, ttlSeconds int) (*model.Session, error)
GetUserByToken(ctx context.Context, rawToken string) (*model.User, error)
RevokeSession(ctx context.Context, rawToken string) error
CreateChat(ctx context.Context, callerID string, req model.CreateChatRequest) (*model.Chat, error)
ListChats(ctx context.Context, callerID string, limit int, cursorStr string) (*model.ChatPage, error)
GetChat(ctx context.Context, callerID, chatID string) (*model.Chat, error)
IsChatMember(ctx context.Context, callerID, chatID string) (bool, error)
CreateAttachment(ctx context.Context, att model.Attachment) (*model.Attachment, error)
GetAttachment(ctx context.Context, callerID, attachmentID string) (*model.Attachment, error)
Reconcile(ctx context.Context, s3 *s3store.Client, gracePeriod time.Duration, dryRun bool) (*ReconcileReport, error)
CreateMessage(ctx context.Context, callerID, chatID, idempotencyKey string, idempotencyTTLSeconds int, req model.CreateMessageRequest) (*model.Message, error)
ListMessages(ctx context.Context, callerID, chatID string, limit int, cursorStr string) (*model.MessagePage, error)
Stats(ctx context.Context) StoreStats
ResetStats()
SetCacheMode(mode string)
Close()
}
func EncodeCursor(scope, timestamp, id string) string {
data := model.CursorData{
Scope: scope,
Time: timestamp,
ID: id,
}
b, _ := json.Marshal(data)
return base64.RawURLEncoding.EncodeToString(b)
}
func DecodeCursor(cursorStr, expectedScope string) (time.Time, string, error) {
b, err := base64.RawURLEncoding.DecodeString(cursorStr)
if err != nil {
b, err = base64.URLEncoding.DecodeString(cursorStr)
if err != nil {
b, err = base64.StdEncoding.DecodeString(cursorStr)
if err != nil {
return time.Time{}, "", ErrBadRequest
}
}
}
var data model.CursorData
if err := json.Unmarshal(b, &data); err != nil {
return time.Time{}, "", ErrBadRequest
}
if data.Scope != expectedScope || data.Time == "" || data.ID == "" {
return time.Time{}, "", ErrBadRequest
}
if _, err := uuid.Parse(data.ID); err != nil {
return time.Time{}, "", ErrBadRequest
}
t, err := time.Parse(time.RFC3339Nano, data.Time)
if err != nil {
return time.Time{}, "", ErrBadRequest
}
return t.UTC().Truncate(time.Microsecond), data.ID, nil
}
+53
View File
@@ -0,0 +1,53 @@
-- Migration 001: Initial schema for Lab 2 (PostgreSQL, Sessions, Chats, Messages)
-- Idempotent DDL with primary/foreign keys, constraints, and keyset pagination indexes.
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY,
username VARCHAR(32) NOT NULL UNIQUE
CONSTRAINT chk_users_username CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name VARCHAR(100) NOT NULL
CONSTRAINT chk_users_display_name CHECK (char_length(btrim(display_name)) >= 1 AND char_length(display_name) <= 100),
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE IF NOT EXISTS sessions (
token_hash CHAR(64) PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions (user_id);
CREATE INDEX IF NOT EXISTS idx_sessions_expires_at ON sessions (expires_at);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title VARCHAR(100) NOT NULL
CONSTRAINT chk_chats_title CHECK (char_length(btrim(title)) >= 1 AND char_length(title) <= 100),
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_chats_created_id ON chats (created_at ASC, id ASC);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
ord INT NOT NULL DEFAULT 0,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS idx_chat_members_user_chat ON chat_members (user_id, chat_id);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
text TEXT NOT NULL
CONSTRAINT chk_messages_text CHECK (char_length(btrim(text)) >= 1 AND char_length(text) <= 4000),
created_at TIMESTAMPTZ NOT NULL
);
-- Composite B-Tree index supporting keyset pagination:
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at ASC, id ASC LIMIT $4
CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id ON messages (chat_id, created_at ASC, id ASC);
+17
View File
@@ -0,0 +1,17 @@
-- Migration 002: Idempotency keys for POST /api/v1/chats/{chat_id}/messages (Lab 3)
-- Scope: (user_id, chat_id, idempotency_key), TTL 24h by default.
-- Message creation and idempotency key registration happen atomically in one PostgreSQL transaction.
CREATE TABLE IF NOT EXISTS idempotency_keys (
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
idempotency_key VARCHAR(128) NOT NULL
CONSTRAINT chk_idempotency_key_format CHECK (idempotency_key ~ '^[A-Za-z0-9._:-]{1,128}$'),
request_hash CHAR(64) NOT NULL,
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ NOT NULL,
expires_at TIMESTAMPTZ NOT NULL,
PRIMARY KEY (user_id, chat_id, idempotency_key)
);
CREATE INDEX IF NOT EXISTS idx_idempotency_keys_expires_at ON idempotency_keys (expires_at);
+35
View File
@@ -0,0 +1,35 @@
-- Migration 003: Attachments & Message-Attachment links for Lab 4 (S3 metadata in PostgreSQL)
ALTER TABLE messages DROP CONSTRAINT IF EXISTS chk_messages_text;
ALTER TABLE messages
ADD CONSTRAINT chk_messages_text CHECK (char_length(text) <= 4000);
CREATE TABLE IF NOT EXISTS attachments (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
owner_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
filename VARCHAR(255) NOT NULL,
content_type VARCHAR(32) NOT NULL
CONSTRAINT chk_attachments_content_type CHECK (content_type IN ('image/png', 'image/jpeg')),
size_bytes BIGINT NOT NULL
CONSTRAINT chk_attachments_size_bytes CHECK (size_bytes >= 1 AND size_bytes <= 10485760),
sha256 CHAR(64) NOT NULL,
object_key TEXT NOT NULL UNIQUE,
status VARCHAR(16) NOT NULL DEFAULT 'ready'
CONSTRAINT chk_attachments_status CHECK (status IN ('pending', 'ready', 'failed')),
error_code VARCHAR(64),
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_attachments_chat_id ON attachments (chat_id);
CREATE INDEX IF NOT EXISTS idx_attachments_status_created ON attachments (status, created_at);
CREATE TABLE IF NOT EXISTS message_attachments (
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE RESTRICT,
ord INT NOT NULL DEFAULT 0,
PRIMARY KEY (message_id, attachment_id)
);
CREATE INDEX IF NOT EXISTS idx_message_attachments_att_id ON message_attachments (attachment_id);
+8
View File
@@ -0,0 +1,8 @@
#!/bin/sh
set -eu
SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
ROOT_DIR=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
cd "$ROOT_DIR"
docker compose --env-file .env restart postgres redis s3 api lb >/dev/null
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env python3
"""Helper script to populate synthetic demo data (including image attachment) for Lab 4 Swagger UI."""
import base64
import json
from pathlib import Path
import sys
import urllib.request
import uuid
BASE_URL = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:8080"
FIXTURE = Path(__file__).resolve().parents[1] / "tests" / "fixtures" / "sample.png"
def req(method, path, body=None, raw=None, headers=None):
h = {"Accept": "application/json"}
data = raw
if body is not None:
data = json.dumps(body).encode("utf-8")
h["Content-Type"] = "application/json"
if headers:
h.update(headers)
r = urllib.request.Request(BASE_URL + path, data=data, headers=h, method=method)
with urllib.request.urlopen(r, timeout=15) as resp:
payload = resp.read()
inst = resp.headers.get("X-Instance-Id", "")
return (json.loads(payload.decode("utf-8")) if payload else None), inst
def main():
suffix = uuid.uuid4().hex[:6]
alice_username = f"alice_{suffix}"
bob_username = f"bob_{suffix}"
password = "DemoPassword-2026!"
alice, inst1 = req("POST", "/api/v1/users", {
"username": alice_username,
"display_name": "Alice Zamorskaya",
"password": password,
})
bob, inst2 = req("POST", "/api/v1/users", {
"username": bob_username,
"display_name": "Bob Bobrov",
"password": password,
})
alice_basic = base64.b64encode(f"{alice_username}:{password}".encode("utf-8")).decode("ascii")
bob_basic = base64.b64encode(f"{bob_username}:{password}".encode("utf-8")).decode("ascii")
alice_sess, _ = req("POST", "/api/v1/auth/sessions", headers={"Authorization": f"Basic {alice_basic}"})
bob_sess, _ = req("POST", "/api/v1/auth/sessions", headers={"Authorization": f"Basic {bob_basic}"})
alice_bearer = {"Authorization": f"Bearer {alice_sess['token']}"}
bob_bearer = {"Authorization": f"Bearer {bob_sess['token']}"}
chat, _ = req("POST", "/api/v1/chats", {
"title": "Lab 4 Attachments Chat",
"member_ids": [alice["id"], bob["id"]],
}, headers=alice_bearer)
img_bytes = FIXTURE.read_bytes()
att, inst3 = req(
"POST",
f"/api/v1/chats/{chat['id']}/attachments?filename=sample.png",
raw=img_bytes,
headers={**alice_bearer, "Content-Type": "image/png"},
)
_, inst4 = req("POST", f"/api/v1/chats/{chat['id']}/messages", {
"text": "Photo stored in private MinIO S3!",
"attachment_ids": [att["id"]],
}, headers={**alice_bearer, "Idempotency-Key": f"seed-att-{suffix}"})
_, inst5 = req("POST", f"/api/v1/chats/{chat['id']}/messages", {
"text": "Got it via another API replica!",
}, headers={**bob_bearer, "Idempotency-Key": f"seed-reply-{suffix}"})
print("=== LAB 4 DEMO DATA CREATED ===")
print(f"Swagger UI: {BASE_URL}/docs")
print(f"Observed IDs: {sorted({x for x in [inst1, inst2, inst3, inst4, inst5] if x})}")
print(f"Password: {password}")
print(f"Alice Username: {alice_username}")
print(f"Alice Token: {alice_sess['token']}")
print(f"Bob Username: {bob_username}")
print(f"Bob Token: {bob_sess['token']}")
print(f"Chat ID: {chat['id']}")
print(f"Attachment ID: {att['id']}")
if __name__ == "__main__":
main()
+25
View File
@@ -0,0 +1,25 @@
#!/bin/sh
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
ROOT_DIR=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
cd "$ROOT_DIR"
TARGET_CID=""
for cid in $(docker compose --env-file .env ps -q api); do
short_id=$(printf '%s' "$cid" | cut -c1-12)
hostname_val=$(docker inspect -f '{{.Config.Hostname}}' "$cid" 2>/dev/null || true)
if [ "$short_id" = "$TARGET_INSTANCE_ID" ] || [ "$cid" = "$TARGET_INSTANCE_ID" ] || [ "$hostname_val" = "$TARGET_INSTANCE_ID" ]; then
TARGET_CID="$cid"
break
fi
done
if [ -z "$TARGET_CID" ]; then
printf 'API container matching X-Instance-Id=%s not found\n' "$TARGET_INSTANCE_ID" >&2
exit 1
fi
docker stop -t 5 "$TARGET_CID" >/dev/null
+446
View File
@@ -0,0 +1,446 @@
#!/usr/bin/env python3
"""Grade 4 verification suite for Lab 4:
1. Validation & security negative tests (413 bytes, 413 >40M pixels bomb, 415 corrupted PNG/JPEG, 415 MIME spoof, 400 bad filenames, 404 cross-chat/foreign).
2. Cross-replica attachment download after stopping the uploading API replica + zero leftover temp files on API.
3. Private bucket & MinIO console isolation + least-privilege credentials + idempotent s3-init.
4. S3 unavailability graceful 503 handling (no 500).
5. >=10 concurrent streaming multi-MB uploads with API peak memory measurement.
"""
import base64
from concurrent.futures import ThreadPoolExecutor
import datetime as dt
import hashlib
import json
from pathlib import Path
import struct
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
import zlib
ROOT = Path(__file__).resolve().parents[1]
FIXTURE_PNG = ROOT / "tests" / "fixtures" / "sample.png"
EVIDENCE_PATH = ROOT / "evidence" / "grade4_checks.json"
BASE_URL = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:8080"
def run_cmd(cmd, check=True):
return subprocess.run(cmd, cwd=str(ROOT), text=True, capture_output=True, check=check)
def http_call(method, path, body=None, raw_bytes=None, headers=None, timeout=15):
h = {"Accept": "application/json"}
data = raw_bytes
if body is not None:
data = json.dumps(body).encode("utf-8")
h["Content-Type"] = "application/json"
if headers:
h.update(headers)
req = urllib.request.Request(BASE_URL + path, data=data, headers=h, method=method)
start = time.monotonic()
try:
with urllib.request.urlopen(req, timeout=timeout) as resp:
raw = resp.read()
hdrs = {k.lower(): v for k, v in resp.headers.items()}
ct = hdrs.get("content-type", "")
parsed = json.loads(raw.decode("utf-8")) if (raw and "application/json" in ct) else None
return resp.code, hdrs, parsed, raw, time.monotonic() - start
except urllib.error.HTTPError as err:
raw = err.read()
hdrs = {k.lower(): v for k, v in err.headers.items()}
ct = hdrs.get("content-type", "")
parsed = json.loads(raw.decode("utf-8")) if (raw and "application/json" in ct) else None
return err.code, hdrs, parsed, raw, time.monotonic() - start
def wait_ready(timeout_s=45):
deadline = time.monotonic() + timeout_s
while time.monotonic() < deadline:
try:
st, _, _, _, _ = http_call("GET", "/health/ready", timeout=2)
if st == 200:
return
except Exception:
pass
time.sleep(0.5)
raise RuntimeError("LB/API did not become ready within timeout")
def register_and_login(label):
username = f"g4_{label}_{uuid.uuid4().hex[:8]}"
password = f"Grade4Pass-{uuid.uuid4().hex}"
st, _, user, _, _ = http_call("POST", "/api/v1/users", {
"username": username,
"display_name": f"Student {label}",
"password": password,
})
assert st == 201
basic = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("ascii")
st, _, sess, _, _ = http_call("POST", "/api/v1/auth/sessions", headers={"Authorization": f"Basic {basic}"})
assert st == 201
return {"id": user["id"], "headers": {"Authorization": f"Bearer {sess['token']}"}}
def png_chunk(chunk_type, data):
return struct.pack(">I", len(data)) + chunk_type + data + struct.pack(">I", zlib.crc32(chunk_type + data) & 0xFFFFFFFF)
def make_synthetic_png(width, height, compress_level=6, color=2):
# color=2 -> RGB (3 bytes/px)
ihdr = struct.pack(">IIBBBBB", width, height, 8, color, 0, 0, 0)
row = b"\x00" + (b"\x2a\x7f\xc1" * width)
raw = row * height
compressed = zlib.compress(raw, level=compress_level)
return b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", ihdr) + png_chunk(b"IDAT", compressed) + png_chunk(b"IEND", b"")
def make_pixel_bomb_png(width=7000, height=7000):
# Valid IHDR declaring 49M pixels (> 40M limit) with tiny valid IDAT so DecodeConfig catches it in <4KB RAM
ihdr = struct.pack(">IIBBBBB", width, height, 8, 0, 0, 0, 0)
tiny_idat = zlib.compress(b"\x00\x00", level=1)
return b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", ihdr) + png_chunk(b"IDAT", tiny_idat) + png_chunk(b"IEND", b"")
def get_api_containers():
cids = run_cmd(["docker", "compose", "--env-file", ".env", "ps", "-q", "api"]).stdout.strip().splitlines()
out = []
for cid in cids:
cid = cid.strip()
if not cid:
continue
info = json.loads(run_cmd(["docker", "inspect", cid]).stdout)[0]
out.append({
"id": cid,
"short_id": cid[:12],
"name": info["Name"].lstrip("/"),
"env": info["Config"]["Env"],
"ports": info["NetworkSettings"]["Ports"],
})
return out
def wait_two_instances(headers, timeout_s=30):
deadline = time.monotonic() + timeout_s
seen = set()
while time.monotonic() < deadline:
try:
st, hdrs, _, _, _ = http_call("GET", "/api/v1/users/me", headers=headers, timeout=2)
if st == 200 and hdrs.get("x-instance-id"):
seen.add(hdrs["x-instance-id"])
if len(seen) >= 2:
return sorted(seen)
except Exception:
pass
time.sleep(0.2)
raise RuntimeError(f"Expected >=2 active instances, saw {seen}")
def test_negative_validation():
alice = register_and_login("neg_a")
bob = register_and_login("neg_b")
eve = register_and_login("neg_e")
st, _, chat1, _, _ = http_call("POST", "/api/v1/chats", {
"title": "Chat 1",
"member_ids": [alice["id"], bob["id"]],
}, headers=alice["headers"])
assert st == 201
st, _, chat2, _, _ = http_call("POST", "/api/v1/chats", {
"title": "Chat 2",
"member_ids": [alice["id"]],
}, headers=alice["headers"])
assert st == 201
sample = FIXTURE_PNG.read_bytes()
# 1. Oversized bytes (> 10 MiB) -> 413
oversized = b"\x89PNG\r\n\x1a\n" + (b"\x00" * (10 * 1024 * 1024 + 128))
st, _, err, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/attachments?filename=big.png", raw_bytes=oversized, headers={**alice["headers"], "Content-Type": "image/png"})
assert st == 413 and err["error"]["code"] == "payload_too_large", f"Expected 413 for >10MiB, got {st}"
# 2. Pixel bomb (> 40M pixels) -> 413
bomb = make_pixel_bomb_png(7000, 7000)
st, _, err, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/attachments?filename=bomb.png", raw_bytes=bomb, headers={**alice["headers"], "Content-Type": "image/png"})
assert st == 413 and err["error"]["code"] == "payload_too_large", f"Expected 413 for pixel bomb, got {st}"
# 3. Corrupted PNG (truncated before IEND) -> 415
corrupt_png = sample[:len(sample) // 2]
st, _, err, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/attachments?filename=bad.png", raw_bytes=corrupt_png, headers={**alice["headers"], "Content-Type": "image/png"})
assert st == 415 and err["error"]["code"] == "unsupported_media_type", f"Expected 415 for corrupt PNG, got {st}"
# 4. Corrupted JPEG -> 415
corrupt_jpg = b"\xff\xd8\xff\xe0\x00\x10JFIF\x00garbage-truncated"
st, _, err, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/attachments?filename=bad.jpg", raw_bytes=corrupt_jpg, headers={**alice["headers"], "Content-Type": "image/jpeg"})
assert st == 415 and err["error"]["code"] == "unsupported_media_type", f"Expected 415 for corrupt JPEG, got {st}"
# 5. MIME spoof (HTML/text labeled as image/png + PNG bytes labeled as image/jpeg) -> 415
st, _, _, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/attachments?filename=fake.png", raw_bytes=b"<html>not-an-image</html>", headers={**alice["headers"], "Content-Type": "image/png"})
assert st == 415
st, _, _, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/attachments?filename=wrong.jpg", raw_bytes=sample, headers={**alice["headers"], "Content-Type": "image/jpeg"})
assert st == 415
# 6. Bad filenames -> 400
for bad_name in ["../secret.png", "dir/file.png", "dir\\file.png", " "]:
from urllib.parse import quote
st, _, _, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/attachments?filename={quote(bad_name, safe='')}", raw_bytes=sample, headers={**alice["headers"], "Content-Type": "image/png"})
assert st == 400, f"Expected 400 for filename {bad_name!r}, got {st}"
# 7. Upload valid attachment in chat1, then test outsider & cross-chat attachment isolation
st, _, att1, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/attachments?filename=valid.png", raw_bytes=sample, headers={**alice["headers"], "Content-Type": "image/png"})
assert st == 201
st, _, _, _, _ = http_call("GET", f"/api/v1/attachments/{att1['id']}", headers=eve["headers"])
assert st == 404
st, _, _, _, _ = http_call("GET", f"/api/v1/attachments/{att1['id']}/content", headers=eve["headers"])
assert st == 404
st, _, _, _, _ = http_call("POST", f"/api/v1/chats/{chat2['id']}/messages", {
"text": "stealing attachment from chat1",
"attachment_ids": [att1["id"]],
}, headers=alice["headers"], timeout=5)
# Must add Idempotency-Key!
st, _, _, _, _ = http_call("POST", f"/api/v1/chats/{chat2['id']}/messages", {
"text": "stealing attachment from chat1",
"attachment_ids": [att1["id"]],
}, headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex})
assert st == 404, f"Cross-chat attachment must return 404, got {st}"
# Unknown attachment UUID -> 404
st, _, _, _, _ = http_call("POST", f"/api/v1/chats/{chat1['id']}/messages", {
"text": "missing att",
"attachment_ids": [str(uuid.uuid4())],
}, headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex})
assert st == 404
return {
"status": "PASS",
"oversized_10mib_status": 413,
"pixel_bomb_49mp_status": 413,
"corrupted_png_status": 415,
"corrupted_jpg_status": 415,
"mime_spoof_status": 415,
"bad_filename_status": 400,
"outsider_and_cross_chat_status": 404,
"sample_attachment": att1,
}
def test_cross_replica_and_no_local_files(att):
bob = register_and_login("cross_b")
# Actually use a shared chat between uploader and downloader
alice = register_and_login("cross_a")
st, _, chat, _, _ = http_call("POST", "/api/v1/chats", {
"title": "Cross Replica Chat",
"member_ids": [alice["id"], bob["id"]],
}, headers=alice["headers"])
assert st == 201
wait_two_instances(alice["headers"])
sample = FIXTURE_PNG.read_bytes()
expected_sha = hashlib.sha256(sample).hexdigest()
st, hdrs, uploaded, _, _ = http_call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments?filename=cross.png",
raw_bytes=sample,
headers={**alice["headers"], "Content-Type": "image/png"},
)
assert st == 201
uploader_inst = hdrs["x-instance-id"]
containers = get_api_containers()
uploader_c = next(c for c in containers if c["short_id"] == uploader_inst)
other_c = next(c for c in containers if c["short_id"] != uploader_inst)
# Confirm NO leftover temp files on API containers
leftover = run_cmd(["docker", "exec", uploader_c["id"], "find", "/tmp", "-name", "lab4-upload-*"]).stdout.strip()
assert leftover == "", f"Leftover temp files found on API: {leftover}"
# Stop the uploading API replica, then download via remaining replica!
run_cmd(["docker", "stop", "-t", "5", uploader_c["id"]])
try:
time.sleep(2.2)
st, dl_hdrs, _, dl_bytes, _ = http_call("GET", f"/api/v1/attachments/{uploaded['id']}/content", headers=bob["headers"])
assert st == 200, f"Download after stopping uploader failed: {st}"
assert dl_hdrs["x-instance-id"] == other_c["short_id"]
assert hashlib.sha256(dl_bytes).hexdigest() == expected_sha
assert dl_bytes == sample
finally:
run_cmd(["docker", "start", uploader_c["id"]])
wait_two_instances(alice["headers"])
return {
"status": "PASS",
"uploaded_by": uploader_inst,
"downloaded_from_after_stop": other_c["short_id"],
"sha256_verified": True,
"api_temp_files_remaining": 0,
"object_key_internal": f"attachments/{chat['id']}/{uploaded['id']}",
}
def test_private_bucket_and_least_privilege(object_key):
containers = get_api_containers()
# Verify NO API container exposes ports and NO MinIO root credentials exist in API env
for c in containers:
for p, binds in (c["ports"] or {}).items():
assert not binds, f"API exposes host port {p}: {binds}"
env_map = dict(item.split("=", 1) for item in c["env"] if "=" in item)
assert "MINIO_ROOT_USER" not in env_map and "MINIO_ROOT_PASSWORD" not in env_map, "API must not receive MinIO root creds"
assert env_map.get("S3_ACCESS_KEY_ID") == "messenger_api_key"
s3_info = json.loads(run_cmd(["docker", "inspect", run_cmd(["docker", "compose", "--env-file", ".env", "ps", "-q", "s3"]).stdout.strip()]).stdout)[0]
for p, binds in (s3_info["NetworkSettings"]["Ports"] or {}).items():
assert not binds, f"S3/console must not expose ports to host, got {p}: {binds}"
# Direct unauthenticated HTTP GET to private S3 bucket inside network -> must return 403
unauth = run_cmd(
["docker", "exec", containers[0]["id"], "wget", "-q", "-S", "-O", "/dev/null", f"http://s3:9000/messenger-attachments/{object_key}"],
check=False,
)
combined = (unauth.stdout + unauth.stderr)
assert unauth.returncode != 0 and ("403" in combined or "Forbidden" in combined), f"Expected 403 from private bucket, got: {combined}"
# Verify idempotent re-run of s3-init exits 0 cleanly
run_cmd(["docker", "compose", "--env-file", ".env", "up", "--exit-code-from", "s3-init", "s3-init"])
return {
"status": "PASS",
"s3_exposed_host_ports": 0,
"minio_console_disabled": True,
"api_uses_scoped_credentials": "messenger_api_key",
"direct_unauth_s3_get": "403 Forbidden",
"s3_init_idempotent_rerun": 0,
}
def test_s3_outage_handling(att_id, headers):
s3_cid = run_cmd(["docker", "compose", "--env-file", ".env", "ps", "-q", "s3"]).stdout.strip()
sample = FIXTURE_PNG.read_bytes()
alice = register_and_login("s3out")
st, _, chat, _, _ = http_call("POST", "/api/v1/chats", {"title": "Outage", "member_ids": [alice["id"]]}, headers=alice["headers"])
assert st == 201
st, _, ok_att, _, _ = http_call("POST", f"/api/v1/chats/{chat['id']}/attachments?filename=ok.png", raw_bytes=sample, headers={**alice["headers"], "Content-Type": "image/png"})
assert st == 201
run_cmd(["docker", "stop", "-t", "5", s3_cid])
try:
# HAProxy /health/ready will notice 503 too, so query API directly or via LB expecting 503 (never 500!)
c0 = get_api_containers()[0]
direct_ready = run_cmd(["docker", "exec", c0["id"], "wget", "-q", "-S", "-O", "/dev/null", "http://127.0.0.1:8080/health/ready"], check=False).stderr
assert "503" in direct_ready, f"Expected 503 on /health/ready during S3 outage, got {direct_ready}"
# Test upload/download during S3 outage via LB -> must return 503 (never 500)
st_up, _, err_up, _, _ = http_call("POST", f"/api/v1/chats/{chat['id']}/attachments?filename=down.png", raw_bytes=sample, headers={**alice["headers"], "Content-Type": "image/png"})
assert st_up == 503 and (err_up is None or err_up["error"]["code"] == "unavailable"), f"Expected 503 on upload during S3 outage, got {st_up}"
st_dl, _, err_dl, _, _ = http_call("GET", f"/api/v1/attachments/{ok_att['id']}/content", headers=alice["headers"])
assert st_dl == 503 and (err_dl is None or err_dl["error"]["code"] == "unavailable"), f"Expected 503 on download during S3 outage, got {st_dl}"
finally:
run_cmd(["docker", "start", s3_cid])
wait_ready(45)
return {"status": "PASS", "ready_during_s3_outage": 503, "upload_during_s3_outage": 503, "download_during_s3_outage": 503}
def test_concurrent_streaming_memory():
alice = register_and_login("conc")
st, _, chat, _, _ = http_call("POST", "/api/v1/chats", {"title": "Concurrent Uploads", "member_ids": [alice["id"]]}, headers=alice["headers"])
assert st == 201
# Valid ~4.6 MiB uncompressed PNG (1400x1100 RGB = 1.54M pixels <= 40M limit)
big_png = make_synthetic_png(1400, 1100, compress_level=0)
expected_sha = hashlib.sha256(big_png).hexdigest()
size_mb = round(len(big_png) / (1024 * 1024), 2)
containers = get_api_containers()
baseline_stats = {}
for line in run_cmd(["docker", "stats", "--no-stream", "--format", "{{.Name}}\t{{.MemUsage}}"]).stdout.strip().splitlines():
n, m = line.split("\t")
if n.startswith("lab4-api"):
baseline_stats[n] = m.strip()
peak_stats = {}
def upload_one(idx):
return http_call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments?filename=big_{idx}.png",
raw_bytes=big_png,
headers={**alice["headers"], "Content-Type": "image/png"},
timeout=30,
)
def poll_stats():
time.sleep(0.5)
for line in run_cmd(["docker", "stats", "--no-stream", "--format", "{{.Name}}\t{{.MemUsage}}\t{{.CPUPerc}}"]).stdout.strip().splitlines():
parts = line.split("\t")
if len(parts) == 3 and parts[0].startswith("lab4-"):
peak_stats[parts[0]] = {"mem": parts[1].strip(), "cpu": parts[2].strip()}
t0 = time.monotonic()
with ThreadPoolExecutor(max_workers=13) as pool:
stat_fut = pool.submit(poll_stats)
up_futs = [pool.submit(upload_one, i) for i in range(12)]
stat_fut.result()
results = [f.result() for f in up_futs]
elapsed = round(time.monotonic() - t0, 3)
for st_c, _, att, _, _ in results:
assert st_c == 201, f"Concurrent upload failed with {st_c}"
assert att["size_bytes"] == len(big_png)
assert att["sha256"] == expected_sha
for c in containers:
leftover = run_cmd(["docker", "exec", c["id"], "find", "/tmp", "-name", "lab4-upload-*"]).stdout.strip()
assert leftover == "", f"Leftover temp file on {c['name']}: {leftover}"
return {
"status": "PASS",
"concurrent_uploads": 12,
"file_size_bytes": len(big_png),
"file_size_mib": size_mb,
"total_payload_mib": round(12 * len(big_png) / (1024 * 1024), 2),
"elapsed_seconds": elapsed,
"api_memory_baseline": baseline_stats,
"stats_during_concurrent_upload": peak_stats,
"api_temp_files_after": 0,
}
def main():
wait_ready()
report = {
"timestamp_utc": dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
"base_url": BASE_URL,
"checks": {},
}
neg = test_negative_validation()
report["checks"]["negative_validation"] = {k: v for k, v in neg.items() if k != "sample_attachment"}
print("PASS: negative_validation", flush=True)
cross = test_cross_replica_and_no_local_files(neg["sample_attachment"])
report["checks"]["cross_replica_failover_download"] = cross
print("PASS: cross_replica_failover_download", flush=True)
priv = test_private_bucket_and_least_privilege(cross["object_key_internal"])
report["checks"]["private_bucket_and_iam"] = priv
print("PASS: private_bucket_and_iam", flush=True)
outage = test_s3_outage_handling(neg["sample_attachment"]["id"], {})
report["checks"]["s3_outage_handling"] = outage
print("PASS: s3_outage_handling", flush=True)
conc = test_concurrent_streaming_memory()
report["checks"]["concurrent_streaming_memory"] = conc
print("PASS: concurrent_streaming_memory", flush=True)
EVIDENCE_PATH.parent.mkdir(parents=True, exist_ok=True)
EVIDENCE_PATH.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
print(f"PASS: all Grade 4 checks succeeded; evidence saved to {EVIDENCE_PATH}")
if __name__ == "__main__":
main()
+234
View File
@@ -0,0 +1,234 @@
#!/usr/bin/env python3
"""Grade 5 Track 2: Two-Store (PostgreSQL <-> S3) Reconciler experiment for Lab 4.
1. Seeds >=25 healthy active attachments (some referenced by messages).
2. Injects faults on BOTH sides:
- 3 aged orphan S3 objects (> grace) without DB rows
- 1 aged missing-S3 'ready' attachment (referenced in message; S3 object deleted out-of-band)
- 1 aged missing-S3 'pending' attachment in DB (never committed to S3)
- 1 fresh orphan S3 object INSIDE grace period (simulating in-flight upload)
3. Runs Reconciler in --dry-run (proves 0 mutations, detects exact anomalies, skips fresh grace).
4. Runs Reconciler in --apply (deletes aged orphans & stale pending row, marks missing ready attachment as failed, preserves fresh grace & all >=25 healthy objects).
5. Runs Reconciler a second time (proves strict idempotency: 0 mutations, 0 anomalies).
6. Verifies all >=25 healthy attachments remain downloadable with exact SHA-256 and captures traversal cost.
"""
import base64
import datetime as dt
import hashlib
import json
from pathlib import Path
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
ROOT = Path(__file__).resolve().parents[1]
FIXTURE_PNG = ROOT / "tests" / "fixtures" / "sample.png"
EVIDENCE_PATH = ROOT / "evidence" / "track2_reconciler.json"
BASE_URL = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:8080"
def run_cmd(cmd, input_text=None):
return subprocess.run(cmd, cwd=str(ROOT), input=input_text, text=True, capture_output=True, check=True)
def http_call(method, path, body=None, raw_bytes=None, headers=None, timeout=15):
h = {"Accept": "application/json"}
data = raw_bytes
if body is not None:
data = json.dumps(body).encode("utf-8")
h["Content-Type"] = "application/json"
if headers:
h.update(headers)
req = urllib.request.Request(BASE_URL + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=timeout) as resp:
raw = resp.read()
ct = resp.headers.get("Content-Type", "")
parsed = json.loads(raw.decode("utf-8")) if (raw and "application/json" in ct) else None
return resp.code, parsed, raw
except urllib.error.HTTPError as err:
raw = err.read()
ct = err.headers.get("Content-Type", "")
parsed = json.loads(raw.decode("utf-8")) if (raw and "application/json" in ct) else None
return err.code, parsed, raw
def register_and_login():
uname = f"rec_{uuid.uuid4().hex[:8]}"
pw = f"Track2Pass-{uuid.uuid4().hex}"
st, u, _ = http_call("POST", "/api/v1/users", {"username": uname, "display_name": "Reconciler", "password": pw})
assert st == 201
basic = base64.b64encode(f"{uname}:{pw}".encode("utf-8")).decode("ascii")
st, sess, _ = http_call("POST", "/api/v1/auth/sessions", headers={"Authorization": f"Basic {basic}"})
assert st == 201
return {"id": u["id"], "headers": {"Authorization": f"Bearer {sess['token']}"}}
def mc_exec(s3_cid, script_body):
cmd = ["docker", "exec", "-i", s3_cid, "/bin/sh", "-e"]
return run_cmd(cmd, input_text=script_body).stdout
def s3_object_exists(s3_cid, obj_key):
res = subprocess.run(
["docker", "exec", s3_cid, "/bin/sh", "-c",
f"mc alias set local http://127.0.0.1:9000 minio_admin_local minio_admin_secret_lab4 >/dev/null && mc stat local/messenger-attachments/{obj_key} >/dev/null 2>&1"],
cwd=str(ROOT), text=True, capture_output=True,
)
return res.returncode == 0
def main():
api_cid = run_cmd(["docker", "compose", "--env-file", ".env", "ps", "-q", "api"]).stdout.strip().splitlines()[0].strip()
pg_cid = run_cmd(["docker", "compose", "--env-file", ".env", "ps", "-q", "postgres"]).stdout.strip()
s3_cid = run_cmd(["docker", "compose", "--env-file", ".env", "ps", "-q", "s3"]).stdout.strip()
sample = FIXTURE_PNG.read_bytes()
expected_sha = hashlib.sha256(sample).hexdigest()
actor = register_and_login()
st, chat, _ = http_call("POST", "/api/v1/chats", {
"title": "Track 2 Reconciler Chat",
"member_ids": [actor["id"]],
}, headers=actor["headers"])
assert st == 201
# 1. Upload 25 healthy active attachments (and link first 10 to messages)
healthy = []
for i in range(25):
st, att, _ = http_call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments?filename=healthy_{i}.png",
raw_bytes=sample,
headers={**actor["headers"], "Content-Type": "image/png"},
)
assert st == 201
healthy.append(att)
if i < 10:
st_m, _, _ = http_call("POST", f"/api/v1/chats/{chat['id']}/messages", {
"text": f"Attached #{i}",
"attachment_ids": [att["id"]],
}, headers={**actor["headers"], "Idempotency-Key": f"rec-msg-{i}-{uuid.uuid4().hex[:8]}"})
assert st_m == 201
# 2. Upload 1 legitimate attachment that will suffer out-of-band S3 object loss (Fault C)
st, victim_att, _ = http_call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments?filename=victim.png",
raw_bytes=sample,
headers={**actor["headers"], "Content-Type": "image/png"},
)
assert st == 201
st_m, _, _ = http_call("POST", f"/api/v1/chats/{chat['id']}/messages", {
"text": "Message referencing S3-lost attachment",
"attachment_ids": [victim_att["id"]],
}, headers={**actor["headers"], "Idempotency-Key": f"rec-victim-{uuid.uuid4().hex[:8]}"})
assert st_m == 201
victim_key = f"attachments/{chat['id']}/{victim_att['id']}"
# Inject Fault A (3 orphan S3 objects) & remove victim_key out-of-band (Fault C)
orphan_keys = [f"attachments/{chat['id']}/orphan_{uuid.uuid4()}" for _ in range(3)]
mc_script = "mc alias set local http://127.0.0.1:9000 minio_admin_local minio_admin_secret_lab4 >/dev/null\n"
for k in orphan_keys:
mc_script += f"printf 'orphan-bytes-%s' '{k}' | mc pipe local/messenger-attachments/{k} >/dev/null\n"
mc_script += f"mc rm local/messenger-attachments/{victim_key} >/dev/null\n"
mc_exec(s3_cid, mc_script)
# Inject Fault D: aged 'pending' DB row without S3 object
stale_pending_id = str(uuid.uuid4())
run_cmd([
"docker", "exec", "-i", pg_cid, "psql", "-v", "ON_ERROR_STOP=1", "-U", "messenger", "-d", "messenger",
], input_text=f"""
INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, object_key, status, error_code, created_at, updated_at)
VALUES ('{stale_pending_id}'::uuid, '{chat['id']}'::uuid, '{actor['id']}'::uuid, 'stale_pending.png', 'image/png', 100, '{expected_sha}', 'attachments/{chat['id']}/{stale_pending_id}', 'pending', NULL, NOW() - INTERVAL '20 seconds', NOW() - INTERVAL '20 seconds');
""")
# Wait 7 seconds so Faults A/C/D cross the 5s grace threshold
time.sleep(7.0)
# Inject Fault B: FRESH orphan S3 object INSIDE grace period (age ~0s < 5s)
fresh_key = f"attachments/{chat['id']}/fresh_{uuid.uuid4()}"
mc_exec(s3_cid, f"""
mc alias set local http://127.0.0.1:9000 minio_admin_local minio_admin_secret_lab4 >/dev/null
printf 'inflight-upload' | mc pipe local/messenger-attachments/{fresh_key} >/dev/null
""")
# 3. Run Reconciler in --dry-run (grace=5s)
dry_raw = run_cmd([
"docker", "exec", api_cid, "/app/messenger", "-reconcile-once", "-dry-run", "-grace-seconds=5",
]).stdout
dry_report = json.loads(dry_raw)
assert dry_report["lock_acquired"] is True
for k in orphan_keys:
assert k in dry_report["orphan_s3_found"], f"Dry-run missed orphan {k}"
assert fresh_key in dry_report["orphan_s3_skipped_grace"], "Dry-run must skip fresh in-flight S3 object inside grace"
assert victim_att["id"] in dry_report["missing_s3_found"]
assert stale_pending_id in dry_report["missing_s3_found"]
assert dry_report["orphan_s3_deleted"] == []
assert dry_report["missing_s3_marked_failed"] == []
assert dry_report["missing_s3_deleted"] == []
assert dry_report["healthy_preserved"] >= 25
print(f"PASS: dry-run scanned {dry_report['s3_objects_scanned']} S3 objs, {dry_report['db_rows_scanned']} DB rows in {dry_report['duration_ms']}ms")
# 4. Run Reconciler in --apply (grace=5s)
apply_raw = run_cmd([
"docker", "exec", api_cid, "/app/messenger", "-reconcile-once", "-grace-seconds=5",
]).stdout
apply_report = json.loads(apply_raw)
assert set(orphan_keys).issubset(set(apply_report["orphan_s3_deleted"]))
assert fresh_key in apply_report["orphan_s3_skipped_grace"], "Apply must NOT delete fresh object inside grace!"
assert victim_att["id"] in apply_report["missing_s3_marked_failed"]
assert stale_pending_id in apply_report["missing_s3_deleted"]
assert apply_report["healthy_preserved"] >= 25
# Verify S3 state: aged orphans gone, fresh orphan STILL present!
for k in orphan_keys:
assert not s3_object_exists(s3_cid, k), f"Aged orphan {k} was not removed"
assert s3_object_exists(s3_cid, fresh_key), "Fresh object inside grace was wrongly deleted!"
# Verify DB/API state: victim attachment marked failed & download returns 409; stale pending deleted!
st_v, _, _ = http_call("GET", f"/api/v1/attachments/{victim_att['id']}/content", headers=actor["headers"])
assert st_v == 409, f"Expected 409 on missing_s3_object download, got {st_v}"
# 5. Re-run Reconciler immediately (repeatability / idempotency check!)
rerun_raw = run_cmd([
"docker", "exec", api_cid, "/app/messenger", "-reconcile-once", "-grace-seconds=5",
]).stdout
rerun_report = json.loads(rerun_raw)
assert rerun_report["orphan_s3_deleted"] == []
assert rerun_report["missing_s3_marked_failed"] == []
assert rerun_report["missing_s3_deleted"] == []
assert rerun_report["healthy_preserved"] >= 25
# 6. Verify ALL 25 healthy active attachments remain downloadable with exact SHA-256
for att in healthy:
st_h, _, raw_h = http_call("GET", f"/api/v1/attachments/{att['id']}/content", headers=actor["headers"])
assert st_h == 200 and hashlib.sha256(raw_h).hexdigest() == expected_sha
# Cleanup our synthetic fresh_key test artifact in S3 so bucket stays tidy
mc_exec(s3_cid, f"mc alias set local http://127.0.0.1:9000 minio_admin_local minio_admin_secret_lab4 >/dev/null && mc rm local/messenger-attachments/{fresh_key} >/dev/null")
out = {
"timestamp_utc": dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
"healthy_attachments_verified": len(healthy),
"injected_faults": {
"aged_orphan_s3_objects": len(orphan_keys),
"fresh_orphan_s3_inside_grace": 1,
"missing_s3_ready_referenced": 1,
"missing_s3_pending_stale": 1,
},
"dry_run_report": dry_report,
"apply_report": apply_report,
"idempotent_rerun_report": rerun_report,
"status": "PASS",
}
EVIDENCE_PATH.parent.mkdir(parents=True, exist_ok=True)
EVIDENCE_PATH.write_text(json.dumps(out, indent=2) + "\n", encoding="utf-8")
print(f"PASS: Track 2 two-store reconciler experiment verified; evidence saved to {EVIDENCE_PATH}")
if __name__ == "__main__":
main()