feat:report
@@ -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
|
||||
$(PYTHON) student-tests/negative.py
|
||||
$(PYTHON) student-tests/load_mem.py
|
||||
$(PYTHON) student-tests/test_s3_failure.py
|
||||
$(PYTHON) student-tests/test_gc.py
|
||||
@@ -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.
|
||||
|
||||
@@ -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:
|
||||
|
||||
|
Before Width: | Height: | Size: 87 KiB After Width: | Height: | Size: 91 KiB |
|
Before Width: | Height: | Size: 14 KiB After Width: | Height: | Size: 84 KiB |
|
Before Width: | Height: | Size: 61 KiB |
|
After Width: | Height: | Size: 38 KiB |
|
After Width: | Height: | Size: 45 KiB |
@@ -0,0 +1,4 @@
|
||||
Concurrent uploads: 10
|
||||
File size: 5.00 MB
|
||||
Elapsed: 3.22s
|
||||
Peak API RSS: 7.46 MB
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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 {
|
||||
|
||||
|
After Width: | Height: | Size: 5.0 MiB |
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||