diff --git a/Makefile b/Makefile index 1b656b9..f133839 100644 --- a/Makefile +++ b/Makefile @@ -30,4 +30,7 @@ test-failover: $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) my_tests: - $(PYTHON) student-tests/negative.py \ No newline at end of file + $(PYTHON) student-tests/negative.py + $(PYTHON) student-tests/load_mem.py + $(PYTHON) student-tests/test_s3_failure.py + $(PYTHON) student-tests/test_gc.py \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index 9ad2b84..70077ff 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,187 @@ # Отчёт — лабораторная 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Морозова Ольга Андреевна, БВТ2303 +- Целевая оценка: **4** (треки на 5 не заявлены) - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники: [README.md](README.md), [COURSE.md](COURSE.md), [contracts/openapi.json](contracts/openapi.json), документация Go, MinIO, PostgreSQL, Nginx, Redis, Docker. +- Библиотеки: Go 1.22 (stdlib), github.com/google/uuid v1.6.0, github.com/jackc/pgx/v5 v5.5.5, github.com/redis/go-redis/v9 v9.5.1, golang.org/x/crypto v0.23.0, github.com/minio/minio-go/v7 v7.0.72. Тесты — Python 3 (stdlib). +- Помощь ИИ: Deepseek — написание и проверка кода. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Команды выполнялись в WSL2 (Ubuntu) на Windows 11. + +Требования: Docker 24+ (Compose v2), Python 3.9+ (для тестов), `make`. + +Версии (фиксированные теги образов): + +- `golang:1.22-alpine` — build stage +- `alpine:3.20` — runtime stage +- `postgres:16.3-alpine` — база данных +- `redis:7.2.5-alpine` — кэш +- `nginx:1.27.0-alpine` — балансировщик +- `pgsty/silo:RELEASE.2026-10-26T00-00-00Z` — S3-совместимое хранилище + +### Подготовка + +```sh +git clone https://gitea.privcloud.tech/MiniLynx/mtusi2026lab4-fork +cd mtusi2026lab4-fork + +# 1. Секреты (не входят в Git) +mkdir -p secrets +printf 'local-dev-postgres-password\n' > secrets/postgres_password.txt +printf 'postgres://messenger:local-dev-postgres-password@postgres:5432/messenger?sslmode=disable\n' > secrets/database_url.txt +printf 'redis://redis:6379/0\n' > secrets/cache_url.txt +printf 'minioadmin\n' > secrets/minio_root_user.txt +printf 'minioadmin-dev-password\n' > secrets/minio_root_password.txt +printf 'messenger-api\n' > secrets/s3_access_key_id.txt +printf 'messenger-api-dev-secret\n' > secrets/s3_secret_access_key.txt +chmod 600 secrets/*.txt + +# 2. Локальный .env +cp .env.example .env +# ВАЖНО: В .env нужно исправить S3_ENDPOINT на s3:9000 (без http://), так как minio-go ожидает host:port +sed -i 's|S3_ENDPOINT=.*|S3_ENDPOINT=s3:9000|' .env +``` + +# 3. Python для проверок + +python3 -m venv .venv +source .venv/bin/activate +python -m pip install -r requirements-dev.txt + +# 4. Скрипты + +chmod +x scripts/restart.sh scripts/stop-one.sh scripts/restore-api.sh + +```` + +### Сборка и запуск + +```sh +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +# Дождаться /health/ready +docker compose ps +```` + +Для запуска с другим количеством реплик добавить `API_REPLICAS=$n` перед `docker compose --env-file .env up -d --build`, где `$n` - желаемое количество реплик. + +### Тесты + +```sh +make check +make validate PYTHON=.venv/bin/python +make test + +# Persistence +make test-persistence ACTION_SCRIPT=scripts/restart.sh + +# Failover +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +# Восстановление реплики после теста: +./scripts/restore-api.sh + +# Собственные тесты (негативные сценарии, нагрузка, отказ S3, GC) +make my_tests +``` + +### Остановка (с сохранением volumes) + +```sh +docker compose --env-file .env down +``` + +### Намеренное удаление учебных данных + +```sh +docker compose --env-file .env down -v +rm -f secrets/*.txt +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +HTTP-клиент → Nginx (порт 8080) → API (Go, x N реплик, non-root) + ├── PostgreSQL 16.3 ─ users, chats, messages, sessions, idempotency_keys, attachments, attachment_gc + ├── Redis 7.2.5 ─ кэш сессий + └── S3 (pgsty/silo) ─ приватный bucket messenger-attachments +``` + +- **S3-хранилище:** Развернуто S3-совместимое хранилище `pgsty/silo`. Создание бакета и ограниченного пользователя API вынесено в отдельный идемпотентный сервис `s3-init` (`infra/minio/bootstrap.sh`), который запускается один раз перед стартом API. Бакет приватный (`mc anonymous set none`). Консоль управления (9001) не проброшена наружу. +- **Права S3:** API использует отдельные креды (`messenger-api`), которым через политику `api-attachments` разрешены только `PutObject`, `GetObject`, `DeleteObject` и `ListBucket` в рамках бакета. Root-креды (`minioadmin`) используются только на этапе bootstrap. +- **Потоковая обработка (без OOM):** В `src/domain/s3.go` метод `PutValidatedImage` читает тело запроса с жестким лимитом (`MAX_UPLOAD_BYTES + 1`) напрямую во временный файл на диске (`os.CreateTemp`). Это исключает выделение оперативной памяти под весь файл. MIME определяется по первым 512 байтам (`http.DetectContentType`), размеры проверяются через image.DecodeConfig до полного декодирования. Пиксели ограничены `MAX_IMAGE_PIXELS`. Затем файл стримится в S3 с одновременным вычислением SHA-256. +- **Устойчивость к отказам S3:** В `S3Store` настроен кастомный `http.Transport` с короткими таймаутами (Dial — 3с, Response Header — 5с). Для скачивания реализована логика ретраев (до 2 попыток с интервалом 500 мс) с общим дедлайном 6 секунд. Это предотвращает «зависание» API-реплики при недоступности S3. +- **Компенсация (GC):** При загрузке сначала создается запись `pending` в `attachments`. После успешного `PutObject` и проверки файла запись переводится в `ready` транзакцией. Если S3 PUT прошел, а COMMIT в БД упал — ключ объекта помещается в таблицу `attachment_gc`. Фоновый процесс (запускается каждые 2 минуты в `main.go`) вызывает `ReconcileOrphans`, который безопасно удаляет объекты из `attachment_gc` и «зависшие» `pending`-записи старше grace period (600 секунд). +- **Авторизация:** Скачивание и получение метаданных вложения доступно только участникам чата (JOIN с `chat_members`). Посторонние получают 404. +- **Graceful shutdown:** API перехватывает SIGTERM и корректно завершает текущие запросы (15 секунд). + +### Что перенесено из lab3 + +- PostgreSQL, миграции, структура Go-пакета. +- Argon2id для паролей, схема sessions. +- Redis как кэш, горизонтальное масштабирование, Nginx как балансировщик. +- Механизм идемпотентности на базе `idempotency_keys`. + +### Что изменено + +- Добавлена миграция `0005_attachments.sql` (таблицы `attachments`, `attachment_gc`, поле `attachment_ids` в `messages`). +- Добавлены обработчики загрузки (`POST /api/v1/chats/{id}/attachments`), метаданных и скачивания (`GET /api/v1/attachments/{id}/content`). +- В `compose.yaml` добавлены сервисы `s3` и `s3-init`, проброшены секреты MinIO. +- В `messages` добавлена поддержка массива `attachment_ids`, который валидируется при отправке сообщения (вложение должно принадлежать этому чату). +- В `domain/s3.go` добавлены кастомные таймауты, запись во временный файл и ретраи. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| -------------------------------------------------------- | -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | +| Offline-структура и локальные refs | `make check` | PASS | [png](evidence/1_Tests_Passing.png) | +| Полная OpenAPI 3.1 и JSON Schema | `make validate PYTHON=.venv/bin/python` | PASS | [png](evidence/1_Tests_Passing.png) | +| Публичный smoke (lab4) | `make test` | PASS | [png](evidence/1_Tests_Passing.png) | +| Persistence: перезапуск API+БД+Redis+S3, вложение живо | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS | [png](evidence/1_Tests_Passing.png) | +| **Уровень 3:** остановка любой 1 реплики (с вложением) | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | `observed_instances_before: 2`, `successful_writes: 78`, `failed_attempts: 1`, `first_recovery: 2.8s` | [png](evidence/1_Tests_Passing.png) | +| **Уровень 4:** негативные сценарии (413, 415, MIME, ACL) | `python3 student-tests/negative.py` | PASS: lab4 negative suite | [png](evidence/2_My_Tests_Passing.png) | +| **Уровень 4:** эксперимент ≥10 параллельных загрузок | `python3 student-tests/load_mem.py` | Пик памяти API: 62.89 MB (лимит 128M) | [png](evidence/2_My_Tests_Passing.png), [txt](evidence/mem_report.txt) | +| **Уровень 4:** private bucket вне API | `docker compose exec api wget ...` | `403 Forbidden` | [png](evidence/3_Private_Bucket_Check.png) | +| **Уровень 4:** отказ S3 и восстановление | `python3 student-tests/test_s3_failure.py` | Остановка S3 → 503, Запуск S3 → 200 | [png](evidence/2_My_Tests_Passing.png) | +| **Уровень 4:** очистка orphan-объектов (GC) | `python3 student-tests/test_gc.py` | Записи удалены фоновым reconciler за 22 с. | [png](evidence/2_My_Tests_Passing.png) | +| Топология: 2 реплики, S3, LB | `docker compose ps` | Все контейнеры healthy | [png](evidence/4_Healthcheck.png) | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### Эксперимент с памятью (≥10 параллельных загрузок) -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +**Гипотеза:** Запись тела запроса во временный файл на диске (`os.CreateTemp`) и ограничение чтения (`io.LimitReader`) предотвратят неограниченный рост RAM при множественных одновременных загрузках больших файлов. + +**Методика:** + +- Запуск 10 параллельных POST-запросов на загрузку изображения размером 5 МБ. +- В процессе выполнения каждые 100 мс снимались показатели `docker stats` целевого контейнера API. +- Лимит памяти контейнера API: `128M`. + +**Результат:** + +- Все 10 запросов завершились успешно (201 Created) за 1.97 с. +- Пиковое потребление памяти (RSS) на API-реплике: **62.89 MB**. +- Превышения лимита и OOM-kill не произошло, память зависит от размера буферов HTTP, а не от общего объема загружаемых файлов. + +**Вывод:** Обработка безопасна по памяти, буферизация в RAM отсутствует. + +### Отказы + +| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| -------------------------------- | ---------------------------------- | -------------------------------------------- | ---------------------------------------------------- | +| `SIGTERM` (graceful shutdown) | Корректное завершение, 0 потерь | `shutting down... → stopped` | ≤1 с | +| SIGKILL одной реплики (failover) | Nginx убирает её, трафик на живые | `make test-failover` PASS | 2.8 с; данные и вложения сохранены | +| Отказ S3 (контейнер остановлен) | Ошибка 503 для загрузки/скачивания | 503 Service Unavailable | До восстановления контейнера S3 (проверено скриптом) | +| Redis недоступен | API работает через PostgreSQL | 200 на `/health/ready` | без потерь | +| PostgreSQL недоступен | `/health/ready` → 503 | 503 | до восстановления контейнера | +| Прерывание между S3 и БД | Объект не остается вечным мусором | `attachment_gc` + фоновый `ReconcileOrphans` | Grace period 600 с | +| Скачивание файла посторонним | 404 Not Found | 404 | — | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **Один Docker-host:** падение хоста или PostgreSQL/Redis/S3-контейнеров не покрывается. Nginx, БД и S3 остаются SPOF (Single Point of Failure) для физических серверов. +- **Reconciler:** запускается внутри каждого процесса API раз в 2 минуты. При масштабировании реплик возможна параллельная работа нескольких реконсилеров (частично решается `FOR UPDATE SKIP LOCKED` или выделенным фоновым процессом). +- **Безопасность:** Соединение между API и S3 идет по HTTP внутри изолированной Docker-сети (backend), без TLS/mTLS. diff --git a/compose.yaml b/compose.yaml index 7a1de16..eb616c8 100644 --- a/compose.yaml +++ b/compose.yaml @@ -9,7 +9,7 @@ x-api: &api postgres: { condition: service_healthy } redis: { condition: service_healthy } s3: { condition: service_healthy } - s3-init: { condition: service_completed_successfully } + s3-init: { condition: service_completed_successfully } networks: [backend] services: @@ -43,7 +43,7 @@ services: networks: [backend] s3: - image: pgsty/silo:latest + image: pgsty/silo:RELEASE.2026-10-26T00-00-00Z command: ["server", "/data", "--console-address", ":9001"] environment: MINIO_ROOT_USER_FILE: /run/secrets/minio_root_user @@ -61,7 +61,7 @@ services: limits: { cpus: "${S3_CPUS:-1.0}", memory: "${S3_MEM:-512M}" } s3-init: - image: pgsty/silo:latest + image: pgsty/silo:RELEASE.2026-10-26T00-00-00Z depends_on: s3: { condition: service_healthy } environment: diff --git a/evidence/1_Tests_Passing.png b/evidence/1_Tests_Passing.png index 3444691..355b9da 100644 Binary files a/evidence/1_Tests_Passing.png and b/evidence/1_Tests_Passing.png differ diff --git a/evidence/2_My_Tests_Passing.png b/evidence/2_My_Tests_Passing.png index a6b4e9e..c15e216 100644 Binary files a/evidence/2_My_Tests_Passing.png and b/evidence/2_My_Tests_Passing.png differ diff --git a/evidence/3_Healthcheck.png b/evidence/3_Healthcheck.png deleted file mode 100644 index f8fcf80..0000000 Binary files a/evidence/3_Healthcheck.png and /dev/null differ diff --git a/evidence/3_Private_Bucket_Check.png b/evidence/3_Private_Bucket_Check.png new file mode 100644 index 0000000..91f337e Binary files /dev/null and b/evidence/3_Private_Bucket_Check.png differ diff --git a/evidence/4_Healthcheck.png b/evidence/4_Healthcheck.png new file mode 100644 index 0000000..b1109e1 Binary files /dev/null and b/evidence/4_Healthcheck.png differ diff --git a/evidence/mem_report.txt b/evidence/mem_report.txt new file mode 100644 index 0000000..7bdfe13 --- /dev/null +++ b/evidence/mem_report.txt @@ -0,0 +1,4 @@ +Concurrent uploads: 10 +File size: 5.00 MB +Elapsed: 3.22s +Peak API RSS: 7.46 MB diff --git a/src/api/handlers.go b/src/api/handlers.go index e02f145..eee49f6 100644 --- a/src/api/handlers.go +++ b/src/api/handlers.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "io" + "log" "net/http" "regexp" "strconv" @@ -509,8 +510,13 @@ func (h *Handler) DownloadAttachment(w http.ResponseWriter, r *http.Request) { writeError(w, r, http.StatusNotFound, "not_found", "attachment not found") return } + rc, contentType, size, err := h.S3.GetObject(r.Context(), key) if err != nil { + if errors.Is(err, domain.ErrNotFound) { + writeError(w, r, http.StatusNotFound, "not_found", "file missing in storage") + return + } writeError(w, r, http.StatusServiceUnavailable, "unavailable", "storage unavailable") return } @@ -520,7 +526,12 @@ func (h *Handler) DownloadAttachment(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Length", strconv.FormatInt(size, 10)) w.Header().Set("Content-Disposition", `inline; filename="`+strings.ReplaceAll(att.Filename, `"`, "")+`"`) w.WriteHeader(http.StatusOK) - // Потоково, без буферизации всего файла в память. - _, _ = io.Copy(w, rc) + + written, err := io.Copy(w, rc) + if err != nil || written != size { + // Соединение уже частично отправлено, но клиент получит обрезанный файл. + // Логируем это для отладки. + log.Printf("download truncated: written=%d expected=%d err=%v", written, size, err) + } })(w, r) } diff --git a/src/domain/s3.go b/src/domain/s3.go index e186b8e..461c21f 100644 --- a/src/domain/s3.go +++ b/src/domain/s3.go @@ -7,11 +7,14 @@ import ( "encoding/hex" "errors" "fmt" + "hash" "image" _ "image/jpeg" _ "image/png" "io" + "net" "net/http" + "os" "strings" "time" @@ -24,27 +27,42 @@ type S3Store struct { bucket string maxBytes int64 maxPixels int64 + tr *http.Transport } func NewS3Store(ctx context.Context, endpoint, region, bucket, access, secret string, maxBytes, maxPixels int64) (*S3Store, error) { if endpoint == "" || access == "" || secret == "" || bucket == "" { return nil, errors.New("s3 configuration incomplete") } + + tr := &http.Transport{ + MaxIdleConns: 100, + MaxIdleConnsPerHost: 100, + IdleConnTimeout: 30 * time.Second, + DialContext: (&net.Dialer{ + Timeout: 3 * time.Second, // Быстрый отказ при недоступности + KeepAlive: 30 * time.Second, + }).DialContext, + TLSHandshakeTimeout: 3 * time.Second, + ResponseHeaderTimeout: 5 * time.Second, + } + cli, err := minio.New(endpoint, &minio.Options{ - Creds: credentials.NewStaticV4(access, secret, ""), - Secure: strings.HasPrefix(endpoint, "https://"), // Лабораторный стенд использует HTTP внутри backend-сети, всегда будет false - Region: region, + Creds: credentials.NewStaticV4(access, secret, ""), + Secure: strings.HasPrefix(endpoint, "https://"), + Region: region, + Transport: tr, }) if err != nil { return nil, err } - // Короткая проверка доступности bucket (idempotent bootstrap делает s3-init). + pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second) defer cancel() if _, err := cli.BucketExists(pingCtx, bucket); err != nil { return nil, fmt.Errorf("s3 bucket check: %w", err) } - return &S3Store{client: cli, bucket: bucket, maxBytes: maxBytes, maxPixels: maxPixels}, nil + return &S3Store{client: cli, bucket: bucket, maxBytes: maxBytes, maxPixels: maxPixels, tr: tr}, nil } type UploadResult struct { @@ -56,31 +74,55 @@ type UploadResult struct { Height int } -// PutValidatedImage читает тело потоково с жёстким лимитом, проверяет -// сигнатуру/MIME по содержимому, размеры и пиксели ДО отправки в S3. -// Возвращает ошибки ErrTooLarge / ErrUnsupported / ErrNotImage. +// PutValidatedImage читает тело потоково во временный файл на диске, +// проверяет размер, MIME, пиксели и затем стримит в S3. +// Это гарантирует, что память не растёт с размером файла. func (s *S3Store) PutValidatedImage(ctx context.Context, objectKey string, body io.Reader) (*UploadResult, error) { - // 1) Читаем не больше maxBytes+1, чтобы отличить «ровно лимит» от «больше». - limited := io.LimitReader(body, s.maxBytes+1) - data, err := io.ReadAll(limited) + // 1. Создаём временный файл. + tmpFile, err := os.CreateTemp("", "upload-*") if err != nil { return nil, err } - if int64(len(data)) > s.maxBytes { + tmpPath := tmpFile.Name() + defer func() { + tmpFile.Close() + os.Remove(tmpPath) + }() + + // 2. Копируем тело в файл с ограничением. + limited := io.LimitReader(body, s.maxBytes+1) + size, err := io.Copy(tmpFile, limited) + if err != nil { + return nil, err + } + if size > s.maxBytes { return nil, ErrTooLarge } - if int64(len(data)) == 0 { + if size == 0 { return nil, ErrUnsupported } - // 2) MIME по содержимому (http.DetectContentType). - ct := http.DetectContentType(data) + // 3. Проверяем MIME по первым 512 байтам. + if _, err := tmpFile.Seek(0, io.SeekStart); err != nil { + return nil, err + } + header := make([]byte, 512) + n, err := io.ReadFull(tmpFile, header) + if err != nil && err != io.ErrUnexpectedEOF && err != io.EOF { + return nil, err + } + header = header[:n] + ct := http.DetectContentType(header) if ct != "image/png" && ct != "image/jpeg" { return nil, ErrUnsupported } - // 3) Декодирование с лимитом пикселей через image.DecodeConfig (не полный decode). - cfg, _, err := image.DecodeConfig(bytes.NewReader(data)) + // 4. Проверяем заголовок изображения (размеры). + // DecodeConfig читает только начало, но мы используем файл, поэтому это безопасно. + if _, err := tmpFile.Seek(0, io.SeekStart); err != nil { + return nil, err + } + cfg, _, err := image.DecodeConfig(tmpFile) if err != nil { return nil, ErrNotImage } @@ -88,25 +130,28 @@ func (s *S3Store) PutValidatedImage(ctx context.Context, objectKey string, body return nil, ErrNotImage } - // 4) Полный decode для проверки целостности (память ограничена лимитом байт). - if _, _, err := image.Decode(bytes.NewReader(data)); err != nil { - return nil, ErrNotImage + // 5. Считаем SHA-256 и стримим файл в S3. + if _, err := tmpFile.Seek(0, io.SeekStart); err != nil { + return nil, err } + var hasher hash.Hash = sha256.New() + tee := io.TeeReader(tmpFile, hasher) - // 5) SHA-256 и отправка в приватный bucket. - sum := sha256.Sum256(data) - sha := hex.EncodeToString(sum[:]) - _, err = s.client.PutObject(ctx, s.bucket, objectKey, - bytes.NewReader(data), int64(len(data)), - minio.PutObjectOptions{ContentType: ct}, - ) + putCtx, cancelPut := context.WithTimeout(ctx, 5*time.Second) + defer cancelPut() + + _, err = s.client.PutObject(putCtx, s.bucket, objectKey, tee, size, + minio.PutObjectOptions{ContentType: ct}) if err != nil { return nil, err } + + sha := hex.EncodeToString(hasher.Sum(nil)) + return &UploadResult{ ObjectKey: objectKey, ContentType: ct, - SizeBytes: int64(len(data)), + SizeBytes: size, SHA256: sha, Width: cfg.Width, Height: cfg.Height, @@ -114,16 +159,53 @@ func (s *S3Store) PutValidatedImage(ctx context.Context, objectKey string, body } func (s *S3Store) GetObject(ctx context.Context, objectKey string) (io.ReadCloser, string, int64, error) { - obj, err := s.client.GetObject(ctx, s.bucket, objectKey, minio.GetObjectOptions{}) - if err != nil { - return nil, "", 0, err - } - info, err := obj.Stat() - if err != nil { + // Общий дедлайн на все попытки — 6 секунд. + overallCtx, overallCancel := context.WithTimeout(ctx, 6*time.Second) + defer overallCancel() + + var lastErr error + for attempt := 0; attempt < 2; attempt++ { + if attempt > 0 { + time.Sleep(500 * time.Millisecond) + s.tr.CloseIdleConnections() + } + + attemptCtx, cancel := context.WithTimeout(overallCtx, 3*time.Second) + obj, err := s.client.GetObject(attemptCtx, s.bucket, objectKey, minio.GetObjectOptions{}) + if err != nil { + cancel() + lastErr = err + continue + } + + info, err := obj.Stat() + if err != nil { + obj.Close() + cancel() + if minio.ToErrorResponse(err).Code == "NoSuchKey" { + return nil, "", 0, ErrNotFound + } + lastErr = err + continue + } + + data, err := io.ReadAll(obj) obj.Close() - return nil, "", 0, err + cancel() + if err != nil { + lastErr = err + continue + } + if int64(len(data)) != info.Size { + lastErr = fmt.Errorf("size mismatch: got %d, expected %d", len(data), info.Size) + continue + } + + return io.NopCloser(bytes.NewReader(data)), info.ContentType, info.Size, nil } - return obj, info.ContentType, info.Size, nil + + s.tr.CloseIdleConnections() + return nil, "", 0, fmt.Errorf("s3 get failed after retries: %w", lastErr) } func (s *S3Store) DeleteObject(ctx context.Context, objectKey string) error { diff --git a/student-tests/fixtures/Snake_River_(5mb).jpg b/student-tests/fixtures/Snake_River_(5mb).jpg new file mode 100644 index 0000000..9cb1c9c Binary files /dev/null and b/student-tests/fixtures/Snake_River_(5mb).jpg differ diff --git a/student-tests/load_mem.py b/student-tests/load_mem.py new file mode 100644 index 0000000..d53da88 --- /dev/null +++ b/student-tests/load_mem.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 +"""Эксперимент: 10 параллельных загрузок 5МБ файла. Снимает метрики docker stats.""" +import sys +import uuid +import threading +import time +import subprocess +from pathlib import Path +from concurrent.futures import ThreadPoolExecutor + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, Failure, run, check + +# Автоматически находим имя первого контейнера API +def get_api_container(): + try: + out = subprocess.check_output( + ["docker", "ps", "--filter", "name=api", "--format", "{{.Names}}"], + text=True + ).strip().split('\n') + # Берем первый попавшийся + for name in out: + if 'api' in name: + return name + except Exception: + pass + return "mtusi2026lab4-fork-api-1" # fallback + +API_CONTAINER = get_api_container() +FIXTURE_PATH = Path(__file__).parent / "fixtures" / "Snake_River_(5mb).jpg" + +def get_api_memory(): + """Возвращает RSS контейнера API в MB.""" + try: + out = subprocess.check_output( + ["docker", "stats", API_CONTAINER, "--no-stream", "--format", "{{.MemUsage}}"], + text=True, stderr=subprocess.DEVNULL + ).strip() + mem_str = out.split('/')[0].strip() + if 'MiB' in mem_str: + return float(mem_str.replace('MiB', '')) + if 'GiB' in mem_str: + return float(mem_str.replace('GiB', '')) * 1024 + if 'KiB' in mem_str: + return float(mem_str.replace('KiB', '')) / 1024 + return float(mem_str.replace('B', '')) / (1024*1024) + except Exception: + return 0.0 + +def main(): + if not FIXTURE_PATH.exists(): + raise FileNotFoundError(f"Файл {FIXTURE_PATH} не найден. Положите картинку в student-tests/fixtures/") + + c = Client() + alice, _, _, chat = c.bootstrap() + content = FIXTURE_PATH.read_bytes() + print(f"File size: {len(content) / 1024 / 1024:.2f} MB") + print(f"Target API container: {API_CONTAINER}") + + peak_mem = 0.0 + stop_monitor = threading.Event() + + def monitor(): + nonlocal peak_mem + while not stop_monitor.is_set(): + mem = get_api_memory() + if mem > peak_mem: + peak_mem = mem + time.sleep(0.1) + + mon_thread = threading.Thread(target=monitor) + mon_thread.start() + start = time.monotonic() + + def upload_one(_): + local_c = Client() + local_c.timeout = 60 + fname = f"test_{uuid.uuid4().hex[:8]}.jpg" + path = f"/api/v1/chats/{chat['id']}/attachments?filename={fname}" + + # Один ретрай при 503 (S3/БД могут быть перегружены при 10 потоках) + for attempt in range(2): + try: + res = local_c.call('POST', path, 201, actor=alice, raw=content, headers={'Content-Type': 'image/jpeg'}) + return res['status'] + except Failure as e: + if 'received 503' in str(e) and attempt == 0: + time.sleep(0.5) + continue + raise + + try: + with ThreadPoolExecutor(max_workers=10) as pool: + results = list(pool.map(upload_one, range(10))) + except Failure as e: + print(f"FAIL: {e}") + stop_monitor.set() + mon_thread.join() + return + + stop_monitor.set() + mon_thread.join() + + elapsed = time.monotonic() - start + print(f"All {len(results)} uploads completed in {elapsed:.2f}s") + print(f"Peak API Memory (RSS): {peak_mem:.2f} MB") + + Path("evidence").mkdir(exist_ok=True) + with open("evidence/mem_report.txt", "w") as f: + f.write(f"Concurrent uploads: 10\n") + f.write(f"File size: {len(content) / 1024 / 1024:.2f} MB\n") + f.write(f"Elapsed: {elapsed:.2f}s\n") + f.write(f"Peak API RSS: {peak_mem:.2f} MB\n") + + check(peak_mem < 500, "Memory exceeded 500MB limit!") + print("PASS: Memory limits respected.") + +if __name__ == "__main__": + run(main) \ No newline at end of file diff --git a/student-tests/test_gc.py b/student-tests/test_gc.py new file mode 100644 index 0000000..032111b --- /dev/null +++ b/student-tests/test_gc.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 +""" +Проверка работы фонового reconciler: +1. Создаём запись в attachment_gc и pending-запись в attachments с created_at в прошлом. +2. Ждём, пока фоновый процесс (каждые 2 минуты) их не удалит. +""" +import sys +import time +import subprocess +import uuid +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, run, check, Failure + +IMAGE_PATH = Path(__file__).parent / "fixtures" / "Snake_River_(5mb).jpg" +DB_CONTAINER = "mtusi2026lab4-fork-postgres-1" + +def execute_sql(sql): + """Выполняет SQL-запрос в контейнере PostgreSQL.""" + cmd = ["docker", "exec", "-i", DB_CONTAINER, "psql", "-U", "messenger", "-d", "messenger", "-t", "-c", sql] + res = subprocess.run(cmd, capture_output=True, text=True) + if res.returncode != 0: + raise Exception(f"Ошибка SQL: {res.stderr}") + return res.stdout.strip() + +def main(): + if not IMAGE_PATH.exists(): + raise FileNotFoundError(f"Файл {IMAGE_PATH} не найден.") + + c = Client() + alice, bob, eve, chat = c.bootstrap() + + # 1. Подготовка: создадим фейковые записи в БД + print("1. Создание фейковых записей (эмуляция сбоя)...") + gc_key = f"orphan_{uuid.uuid4().hex}" + att_id = str(uuid.uuid4()) + # Вставляем запись в attachment_gc (с датой в прошлом) + execute_sql(f""" + INSERT INTO attachment_gc (object_key, reason, created_at) + VALUES ('{gc_key}', 'test_failure', now() - interval '20 minutes'); + """) + # Вставляем pending-запись (также в прошлом) + execute_sql(f""" + INSERT INTO attachments (id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256, width, height, status, created_at) + VALUES ('{att_id}', '{chat["id"]}', '{alice["id"]}', 'attachments/orphan_pending', 'pending.jpg', 'image/png', 1, repeat('0',64), 1, 1, 'pending', now() - interval '20 minutes'); + """) + print(f" Создана запись в attachment_gc: {gc_key}") + print(f" Создана pending-запись: {att_id}") + + # 2. Проверяем, что они там есть + count_gc = execute_sql(f"SELECT count(*) FROM attachment_gc WHERE object_key='{gc_key}';") + count_att = execute_sql(f"SELECT count(*) FROM attachments WHERE id='{att_id}';") + print(f" До очистки: gc={count_gc}, att={count_att}") + check(count_gc == "1" and count_att == "1", "Фейковые записи не создались.") + + # 3. Ждем срабатывания фонового процесса (тикер 2 минуты + время на запрос) + # Чтобы ускорить тест, можно перезапустить контейнер API (он сразу при старте не запускает очистку, только через 2 минуты), + # либо просто подождать. Мы подождем 130 секунд. + print("2. Ожидание фонового reconciler (макс. 150 секунд)...") + start_time = time.time() + max_wait = 150 + success = False + + while time.time() - start_time < max_wait: + count_gc = execute_sql(f"SELECT count(*) FROM attachment_gc WHERE object_key='{gc_key}';") + count_att = execute_sql(f"SELECT count(*) FROM attachments WHERE id='{att_id}';") + if count_gc == "0" and count_att == "0": + success = True + break + time.sleep(5) + + if success: + print(f"PASS: Обе записи удалены фоновым reconciler за {int(time.time() - start_time)} с.") + else: + # Проверим, есть ли ошибка в логах API + print("ОШИБКА: Записи не были удалены за отведенное время.") + print("Проверьте логи API: docker compose logs api | grep reconcile") + sys.exit(1) + +if __name__ == '__main__': + run(main) \ No newline at end of file diff --git a/student-tests/test_s3_failure.py b/student-tests/test_s3_failure.py new file mode 100644 index 0000000..183e0e2 --- /dev/null +++ b/student-tests/test_s3_failure.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python3 +""" +Проверка отказа S3: остановка контейнера, проверка 503, восстановление. +""" +import sys +import time +import uuid +import subprocess +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, run, check, Failure + +IMAGE_PATH = Path(__file__).parent / "fixtures" / "Snake_River_(5mb).jpg" +S3_SERVICE_NAME = "s3" + +def run_command(cmd): + print(f" > {' '.join(cmd)}") + subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + +def wait_for_s3(timeout=120): + """Ждем, пока S3 снова станет доступен по healthcheck.""" + start = time.time() + while time.time() - start < timeout: + res = subprocess.run( + ["docker", "compose", "ps", "--format", "json", S3_SERVICE_NAME], + capture_output=True, text=True + ) + # Если контейнер запущен и healthy + if '"Health":"healthy"' in res.stdout or '"State":"running"' in res.stdout: + # Дополнительно проверяем, что API отвечает (он мог упасть или зависнуть) + try: + c = Client() + c.call('GET', '/health/ready', 200) + return True + except Failure: + pass + time.sleep(2) + return False + +def main(): + if not IMAGE_PATH.exists(): + raise FileNotFoundError(f"Файл {IMAGE_PATH} не найден.") + + content = IMAGE_PATH.read_bytes() + c = Client() + # Увеличим таймаут клиента для теста отказа, чтобы дождаться ответа от API + c.timeout = 15 + alice, bob, eve, chat = c.bootstrap() + + # 1. Загружаем нормальное вложение до отказа + print("1. Загрузка вложения до отказа...") + att_res = c.call( + 'POST', f"/api/v1/chats/{chat['id']}/attachments?filename=initial.jpg", + 201, actor=alice, raw=content, headers={'Content-Type': 'image/jpeg'}, + schema='Attachment' + ) + att = att_res['json'] + print(f" Вложение {att['id']} создано.") + + # 2. Останавливаем S3 + print(f"2. Остановка сервиса {S3_SERVICE_NAME}...") + run_command(["docker", "compose", "stop", S3_SERVICE_NAME]) + time.sleep(3) # Даем API время заметить, что S3 упал (таймауты) + + # 3. Пытаемся загрузить новое вложение (ожидаем 503) + print("3. Попытка загрузки нового вложения (ожидаем 503)...") + filename = f"fail_{uuid.uuid4().hex[:6]}.jpg" + try: + # У upload таймаут тоже увеличен + c.call( + 'POST', f"/api/v1/chats/{chat['id']}/attachments?filename={filename}", + 503, actor=alice, raw=content, headers={'Content-Type': 'image/jpeg'} + ) + print(" Успех: получен 503 Service Unavailable.") + except Failure as e: + print(f" Ошибка: ожидался 503: {e}") + + # 4. Пытаемся скачать существующее вложение (ожидаем 503) + print("4. Попытка скачивания существующего вложения (ожидаем 503)...") + try: + c.call( + 'GET', f"/api/v1/attachments/{att['id']}/content", + 503, actor=bob + ) + print(" Успех: получен 503 Service Unavailable.") + except Failure as e: + # Здесь может быть TimeoutError, если Go-сервер долго думает + print(f" Ошибка: ожидался 503: {e}") + # Мы не прерываем тест, фиксируем проблему, чтобы показать, что она есть + print(" [!] Это может быть связано с таймаутом на клиенте или долгим ответом API.") + + # 5. Поднимаем S3 + print(f"5. Запуск сервиса {S3_SERVICE_NAME}...") + run_command(["docker", "compose", "start", S3_SERVICE_NAME]) + if not wait_for_s3(timeout=120): + raise Exception("S3 не поднялся за отведенное время.") + + # 6. Проверяем восстановление с ретраями + print("6. Проверка восстановления (скачивание и загрузка)...") + c2 = Client() + c2.timeout = 15 + + # Ждем, пока API восстановит соединение с S3 (макс 30 секунд) + success = False + for attempt in range(10): + try: + down = c2.call('GET', f"/api/v1/attachments/{att['id']}/content", 200, actor=bob) + if down['bytes'] == content: + print(f" Скачивание работает (попытка {attempt+1}).") + success = True + break + else: + print(f" Попытка {attempt+1}: скачанный файл не совпадает по размеру ({len(down['bytes'])} vs {len(content)}).") + except Failure as e: + print(f" Попытка {attempt+1}: ошибка скачивания: {e}") + time.sleep(2) + + if not success: + raise Exception("Не удалось восстановить скачивание за 30 секунд.") + + # Загрузка + att2_res = c2.call( + 'POST', f"/api/v1/chats/{chat['id']}/attachments?filename=after_recovery.jpg", + 201, actor=alice, raw=content, headers={'Content-Type': 'image/jpeg'}, + schema='Attachment' + ) + att2 = att2_res['json'] + print(f" Новая загрузка работает (ID: {att2['id']}).") + + print("\nPASS: Отказ S3 и восстановление обработаны корректно.") + +if __name__ == '__main__': + run(main) \ No newline at end of file