Add bounded private image upload with safe S3 persistence
This commit is contained in:
@@ -1,7 +1,7 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: Самохвалов Андрей Ремович, БПИ-2302.
|
||||
- Целевая оценка: 5, трек 2 «Согласованность двух хранилищ». Пока реализованы перенос lab3 и приватное S3; остальные блоки выполняются далее.
|
||||
- Целевая оценка: 5, трек 2 «Согласованность двух хранилищ». Реализованы перенос lab3, приватное S3 и ограниченный синхронный upload; download, связь с сообщением и reconciler выполняются далее.
|
||||
- Ветка: `solution/bpi2302-samohvalov`; commit/PR указываются после публикации.
|
||||
- Источники: `README.md`, `COURSE.md`, `contracts/README.md`, `contracts/openapi.json`, публичные тесты, [MinIO release](https://github.com/minio/minio/releases/tag/RELEASE.2025-10-15T17-29-55Z), [образ](https://hub.docker.com/r/alpine/minio/tags), документация MinIO для IAM. Python/FastAPI, PostgreSQL, MinIO Python SDK; проект подготовлен с помощью ИИ Codex с локальной проверкой ниже.
|
||||
|
||||
@@ -15,7 +15,7 @@ python3 scripts/setup-local-secrets.py
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --wait --scale api=2
|
||||
make check
|
||||
# make test — после реализации upload в следующем блоке
|
||||
# make test — после реализации download/связи с сообщением в следующем блоке
|
||||
```
|
||||
|
||||
`setup-local-secrets.py` создаёт отсутствующие secret-файлы с правами 0600 и не перезаписывает существующие. Миграции выполняет одноразовый `migrate` под PostgreSQL advisory lock. `s3-volume-init` задаёт владельца нового volume, затем MinIO стартует без root; одноразовый `s3-bootstrap` идемпотентно создаёт закрытый bucket и две ограниченные учётные записи. Повторный `docker compose --env-file .env run --rm s3-bootstrap` безопасен. Для остановки — `docker compose --env-file .env down` без `-v`; для намеренного удаления **только учебных данных** после проверки — `docker compose --env-file .env down -v`.
|
||||
@@ -36,7 +36,9 @@ make check
|
||||
| `s3-bootstrap` | одноразовый MinIO Client | завершение 0 | root и создаваемые ограниченные credentials |
|
||||
| `s3-volume-init` | одноразовая настройка владельца volume | завершение 0 | секретов нет |
|
||||
|
||||
`infra/minio-api-policy.json` разрешает только операции над объектами одного bucket и чтение его location; создание bucket, изменение IAM и административные операции не разрешены. Отдельная maintenance policy добавляет list для будущей сверки. Bucket не имеет анонимного чтения. Приватность bucket не заменяет проверку членства в чате на API: эта проверка добавляется в блоках upload/download.
|
||||
`infra/minio-api-policy.json` разрешает только операции над объектами одного bucket и чтение его location; создание bucket, изменение IAM и административные операции не разрешены. Отдельная maintenance policy добавляет list для будущей сверки. Bucket не имеет анонимного чтения. Приватность bucket не заменяет проверку членства в чате на API: upload уже проверяет членство до чтения тела; download получит такую же проверку в следующем блоке.
|
||||
|
||||
Upload читает raw body в `SpooledTemporaryFile` с порогом RAM 1 MiB и останавливается после 10 MiB; проверяет формат и MIME через Pillow, до декодирования отклоняет свыше 40 млн пикселей, затем полностью проверяет PNG/JPEG. Имя файла применяется только для отображения, object key — случайный UUID в `originals/`. S3 PUT предшествует INSERT/COMMIT в PostgreSQL; `201 ready` возвращается лишь после обоих успехов. При достоверной ошибке до COMMIT объект удаляется. Если подтверждение COMMIT потеряно, удалять небезопасно: объект остаётся кандидатом для сверки после grace period. Если и компенсационное DELETE отказало, key записывается во внутренний лог; U5 добавит повторяемый reconciler. Клиенту при ошибке зависимости приходит `503`, а прозрачный retry POST не выполняется. Для S3 заданы connect/read timeouts 2/10 с без внутренних повторов; `/health/ready` проверяет БД и доступ к приватному S3 через разрешённый HEAD отсутствующего probe key.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
@@ -45,11 +47,15 @@ make check
|
||||
| Перенос lab3 | Compose ×2, текстовая часть `make test`, `make test-persistence`, адресный failover обеих реплик | Текстовый API совместим, прежний токен/сообщение после restart; восстановление записи после остановки каждой реплики 3,123 и 3,149 с | локальные тесты U1; полный smoke остановился на ещё не реализованном upload |
|
||||
| Приватный S3 и bootstrap | `docker compose run --rm s3-bootstrap` дважды; `docker compose exec -T api python - < student-tests/test_storage_bootstrap.py` | Два повтора завершились 0; S3 PUT/GET ограниченным API пользователем совпадают по байтам, анонимный GET — 403, создание чужого bucket — AccessDenied | `evidence/storage-bootstrap-2026-10-02.txt` |
|
||||
| Миграция и транзакции | `docker compose exec -T api python - < student-tests/test_database.py`; `... test_auth.py` | Миграции 1–4 применены повторяемо, 2 DB и 3 auth теста PASS | `evidence/storage-bootstrap-2026-10-02.txt` |
|
||||
| Raw PNG/JPEG upload и ограничения | `BASE_URL=http://localhost:8084 python3 -m unittest discover -s student-tests -p 'test_attachment_upload.py' -v` | 4 набора PASS: PNG/JPEG `201 ready`, корректные hash/size/type; 10 MiB+1 и >40 млн px — 413; повреждение/MIME spoof — 415; опасное имя — 400, чужой чат — 404 | `student-tests/test_attachment_upload.py`, синтетический JPEG fixture |
|
||||
| Отказ S3 | `docker compose stop s3`; `docker compose exec -T api python - < student-tests/test_s3_outage.py`; `docker compose start s3` | При реально остановленном S3 readiness=503, upload=503, число metadata строк не изменилось; S3 восстановлен и healthy | `student-tests/test_s3_outage.py` |
|
||||
| Промежуток S3/БД и обрыв потока | `docker compose exec -T api python - < student-tests/test_upload_failure.py` | PUT failure не вызывает SQL; ошибка БД до INSERT вызывает компенсацию DELETE; оборванный поток не начинает PUT. Неоднозначный COMMIT оставляет объект для сверки | `student-tests/test_upload_failure.py` |
|
||||
| Ограничение RAM | `BASE_URL=http://localhost:8084 python3 scripts/measure-upload-memory.py` | 10/10 одновременных upload одного PNG 9 441 653 байт, 10 разных ready ID и верный SHA-256, 6,145 с; sampled peak API-1/2 114,7/115,5 MiB при лимите 256 MiB | `evidence/upload-memory-2026-10-02.csv` |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
Запись S3/БД, компенсация после ошибки, ACL, failover файла, параллельные upload и reconciler ещё должны быть проверены. Пока `GET /health/ready` отражает обязательную PostgreSQL зависимость, а готовность MinIO проверяет Compose при запуске; после появления attachment path доступность S3 будет явно учтена в сценариях.
|
||||
Граница PUT/COMMIT проверена fault-инъекциями; полный reconciler и проверка восстановления при неизвестном результате COMMIT выполняются в U5/U6. Замер RAM проводился на локальном Colima/arm64, 2 CPU и 2 GiB, API ×2 с 0,5 CPU/256 MiB на экземпляр, 10 потоков с барьером старта. CSV содержит baseline и два Docker stats снимка во время 6,145 с серии: peak означает максимум **наблюдённых** снимков, а не точный аппаратный high-water mark. Все 10 ответов 201 имели уникальные ID и совпадающий SHA-256. Создание body по `os.urandom` оставляет воспроизводимыми размер/разрешение/алгоритм, но не конкретные байты и hash между прогонами.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
Полный `make test` сейчас ожидаемо получает 415 на `POST attachments`: синхронный upload, скачивание и привязка ещё не реализованы. Проверки уровня 4 и трека 5 не заявляются завершёнными до отдельных fault tests и воспроизводимых измерений. Один MinIO/PostgreSQL/LB и один Docker-host остаются одиночными точками отказа. Локальный HTTP допустим только для изолированного стенда с синтетическими данными; удалённой демонстрации нужен TLS.
|
||||
Полный `make test` пока останавливается на последующих маршрутах attachment metadata/content и привязке к сообщению; U4 реализует их отдельно. Проверки уровня 4 и трека 5 не заявляются завершёнными до повторяемой сверки. Один MinIO/PostgreSQL/LB и один Docker-host остаются одиночными точками отказа. Локальный HTTP допустим только для изолированного стенда с синтетическими данными; удалённой демонстрации нужен TLS.
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
seconds,container,used_mib,limit_mib
|
||||
0,mtusi2026lab4-api-1,48.58,256.0
|
||||
0,mtusi2026lab4-api-2,51.2,256.0
|
||||
2.129,mtusi2026lab4-api-1,114.7,256.0
|
||||
2.129,mtusi2026lab4-api-2,115.5,256.0
|
||||
4.141,mtusi2026lab4-api-1,114.7,256.0
|
||||
4.141,mtusi2026lab4-api-2,115.5,256.0
|
||||
|
@@ -0,0 +1,2 @@
|
||||
ALTER TABLE attachments ADD COLUMN owner_id uuid NOT NULL REFERENCES users(id);
|
||||
ALTER TABLE attachments ADD COLUMN updated_at timestamptz NOT NULL DEFAULT clock_timestamp();
|
||||
@@ -5,3 +5,5 @@ psycopg[binary,pool]==3.2.12
|
||||
psycopg-pool==3.3.3
|
||||
argon2-cffi==25.1.0
|
||||
minio==7.2.20
|
||||
Pillow==11.3.0
|
||||
urllib3==2.8.0
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
"""Ten concurrent bounded PNG uploads plus Docker memory samples; BASE_URL overrides localhost:8080."""
|
||||
|
||||
import csv
|
||||
import hashlib
|
||||
import os
|
||||
import re
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import zlib
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "tests"))
|
||||
from client import Client # noqa: E402
|
||||
|
||||
API_NAMES = ("mtusi2026lab4-api-1", "mtusi2026lab4-api-2")
|
||||
EVIDENCE = ROOT / "evidence/upload-memory-2026-10-02.csv"
|
||||
|
||||
|
||||
def png_chunk(name: bytes, data: bytes) -> bytes:
|
||||
return struct.pack(">I", len(data)) + name + data + struct.pack(">I", zlib.crc32(name + data))
|
||||
|
||||
|
||||
def large_png() -> bytes:
|
||||
width, height = 2048, 1536
|
||||
rows = b"".join(b"\0" + os.urandom(width * 3) for _ in range(height))
|
||||
return b"\x89PNG\r\n\x1a\n" + png_chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)) + png_chunk(b"IDAT", zlib.compress(rows, 1)) + png_chunk(b"IEND", b"")
|
||||
|
||||
|
||||
def mib(text: str) -> float:
|
||||
match = re.fullmatch(r"([0-9.]+)(B|KiB|MiB|GiB)", text.strip())
|
||||
if not match:
|
||||
raise ValueError("unexpected Docker memory unit")
|
||||
return float(match.group(1)) * {"B": 1 / 1048576, "KiB": 1 / 1024, "MiB": 1, "GiB": 1024}[match.group(2)]
|
||||
|
||||
|
||||
def memory_samples(elapsed: float) -> list[tuple[float, str, float, float]]:
|
||||
command = ["rtk", "proxy", "docker", "stats", "--no-stream", "--format", "{{.Name}},{{.MemUsage}}", *API_NAMES]
|
||||
output = subprocess.run(command, check=True, capture_output=True, text=True, timeout=10).stdout
|
||||
rows = []
|
||||
for line in output.splitlines():
|
||||
name, usage = line.split(",", 1)
|
||||
used, limit = usage.split("/", 1)
|
||||
rows.append((round(elapsed, 3), name, round(mib(used), 3), round(mib(limit), 3)))
|
||||
if len(rows) != 2:
|
||||
raise AssertionError("expected two API container memory samples")
|
||||
return rows
|
||||
|
||||
|
||||
def main() -> None:
|
||||
client = Client(timeout=60)
|
||||
actor, _, _, chat = client.bootstrap()
|
||||
data = large_png()
|
||||
if len(data) > 10 * 1024 * 1024:
|
||||
raise AssertionError("synthetic PNG exceeds upload limit")
|
||||
expected_hash = hashlib.sha256(data).hexdigest()
|
||||
barrier = threading.Barrier(10)
|
||||
|
||||
def send(index: int) -> dict:
|
||||
barrier.wait(timeout=10)
|
||||
result = Client(timeout=60).call(
|
||||
"POST", f"/api/v1/chats/{chat['id']}/attachments?filename=load-{index}.png", 201,
|
||||
actor=actor, raw=data, headers={"Content-Type": "image/png"}, schema="Attachment",
|
||||
)["json"]
|
||||
if result["sha256"] != expected_hash or result["size_bytes"] != len(data):
|
||||
raise AssertionError("upload bytes/hash mismatch")
|
||||
return result
|
||||
|
||||
start = time.monotonic()
|
||||
rows = memory_samples(0)
|
||||
with ThreadPoolExecutor(max_workers=10) as workers:
|
||||
futures = [workers.submit(send, index) for index in range(10)]
|
||||
while not all(future.done() for future in futures):
|
||||
rows.extend(memory_samples(time.monotonic() - start))
|
||||
results = [future.result() for future in futures]
|
||||
rows.extend(memory_samples(time.monotonic() - start))
|
||||
if len({result["id"] for result in results}) != 10:
|
||||
raise AssertionError("uploads did not create ten unique attachments")
|
||||
EVIDENCE.parent.mkdir(exist_ok=True)
|
||||
with EVIDENCE.open("w", newline="") as target:
|
||||
writer = csv.writer(target, lineterminator="\n")
|
||||
writer.writerow(("seconds", "container", "used_mib", "limit_mib"))
|
||||
writer.writerows(rows)
|
||||
peaks = {name: max(row[2] for row in rows if row[1] == name) for name in API_NAMES}
|
||||
print(f"PASS: 10/10 uploads; PNG={len(data)} bytes; elapsed={time.monotonic()-start:.3f}s; peaks={peaks}; evidence={EVIDENCE.name}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+9
-1
@@ -6,6 +6,7 @@ from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query, Request, Response
|
||||
|
||||
from .auth import basic_credentials, bearer_token
|
||||
from .attachments import storage_ready, upload
|
||||
from .models import CreateChat, CreateMessage, CreateUser
|
||||
from .store import store
|
||||
|
||||
@@ -19,7 +20,9 @@ def live():
|
||||
|
||||
@router.get("/health/ready")
|
||||
def ready():
|
||||
return store.ready()
|
||||
result = store.ready()
|
||||
storage_ready()
|
||||
return result
|
||||
|
||||
|
||||
@router.post("/api/v1/users", status_code=201)
|
||||
@@ -78,6 +81,11 @@ def get_chat(chat_id: UUID, actor: dict = Depends(current_user)):
|
||||
return store.chat(actor["id"], str(chat_id))
|
||||
|
||||
|
||||
@router.post("/api/v1/chats/{chat_id}/attachments", status_code=201)
|
||||
async def upload_attachment(chat_id: UUID, request: Request, filename: str = Query(...), actor: dict = Depends(current_user)):
|
||||
return await upload(request, str(chat_id), actor["id"], filename)
|
||||
|
||||
|
||||
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
def create_message(chat_id: UUID, body: CreateMessage, request: Request, actor: dict = Depends(current_user)):
|
||||
key = request.headers.get("Idempotency-Key")
|
||||
|
||||
@@ -1,13 +1,29 @@
|
||||
"""Private S3 access shared by attachment routes and maintenance jobs."""
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
import logging
|
||||
import os
|
||||
import unicodedata
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
from tempfile import SpooledTemporaryFile
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from fastapi import HTTPException, Request
|
||||
from minio import Minio
|
||||
from minio.error import S3Error
|
||||
from PIL import Image, UnidentifiedImageError
|
||||
from urllib3 import PoolManager, Retry, Timeout
|
||||
|
||||
from .store import connection, store, timestamp
|
||||
|
||||
|
||||
BUCKET = "messenger-attachments"
|
||||
MAX_BYTES = 10 * 1024 * 1024
|
||||
MAX_PIXELS = 40_000_000
|
||||
Image.MAX_IMAGE_PIXELS = MAX_PIXELS
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def secret(name: str) -> str:
|
||||
@@ -22,4 +38,114 @@ def storage() -> Minio:
|
||||
secret_key=secret("S3_SECRET_ACCESS_KEY"),
|
||||
secure=False,
|
||||
region="us-east-1",
|
||||
http_client=PoolManager(timeout=Timeout(connect=2, read=10), retries=Retry(total=0)),
|
||||
)
|
||||
|
||||
|
||||
def storage_ready() -> None:
|
||||
try:
|
||||
storage().stat_object(BUCKET, "health/ready-probe")
|
||||
except S3Error as exc:
|
||||
if exc.code != "NoSuchKey":
|
||||
raise HTTPException(503) from None
|
||||
except Exception:
|
||||
raise HTTPException(503) from None
|
||||
|
||||
|
||||
def attachment_view(row: dict) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]), "chat_id": str(row["chat_id"]), "owner_id": str(row["owner_id"]),
|
||||
"filename": row["filename"], "content_type": row["content_type"],
|
||||
"size_bytes": row["size_bytes"], "sha256": row["sha256"], "status": row["status"],
|
||||
"variants": [], "error_code": row["error_code"],
|
||||
"created_at": timestamp(row["created_at"]), "updated_at": timestamp(row["updated_at"]),
|
||||
}
|
||||
|
||||
|
||||
def validate_filename(filename: str) -> None:
|
||||
if not 1 <= len(filename) <= 255 or filename in {".", ".."}:
|
||||
raise HTTPException(400)
|
||||
if any(char in "/\\" or unicodedata.category(char) == "Cc" for char in filename):
|
||||
raise HTTPException(400)
|
||||
|
||||
|
||||
def validate_image(stream, declared_type: str) -> str:
|
||||
try:
|
||||
with Image.open(stream) as image:
|
||||
actual_type = {"PNG": "image/png", "JPEG": "image/jpeg"}.get(image.format)
|
||||
if actual_type is None or actual_type != declared_type:
|
||||
raise HTTPException(415)
|
||||
if image.width * image.height > MAX_PIXELS:
|
||||
raise HTTPException(413)
|
||||
image.verify()
|
||||
stream.seek(0)
|
||||
with Image.open(stream) as image:
|
||||
image.load()
|
||||
return actual_type
|
||||
except Image.DecompressionBombError:
|
||||
raise HTTPException(413) from None
|
||||
except (UnidentifiedImageError, OSError, ValueError, SyntaxError):
|
||||
raise HTTPException(415) from None
|
||||
|
||||
|
||||
def persist_attachment(chat_id: str, actor_id: str, filename: str, content_type: str, size: int, sha256: str, stream) -> dict:
|
||||
attachment_id = uuid4()
|
||||
object_key = f"originals/{attachment_id}"
|
||||
stream.seek(0)
|
||||
try:
|
||||
storage().put_object(BUCKET, object_key, stream, size, content_type=content_type)
|
||||
except Exception:
|
||||
logger.exception("S3 upload failed for attachment %s", attachment_id)
|
||||
raise HTTPException(503) from None
|
||||
|
||||
commit_uncertain = False
|
||||
try:
|
||||
with connection() as conn:
|
||||
row = conn.execute(
|
||||
"INSERT INTO attachments (id,chat_id,owner_id,filename,object_key,content_type,size_bytes,sha256) "
|
||||
"VALUES (%s,%s,%s,%s,%s,%s,%s,%s) "
|
||||
"RETURNING id,chat_id,owner_id,filename,content_type,size_bytes,sha256,status,error_code,created_at,updated_at",
|
||||
(attachment_id, UUID(chat_id), UUID(actor_id), filename, object_key, content_type, size, sha256),
|
||||
).fetchone()
|
||||
commit_uncertain = True
|
||||
except Exception:
|
||||
if commit_uncertain:
|
||||
# The COMMIT may have succeeded despite a lost acknowledgment. Reconciliation decides later.
|
||||
logger.error("Attachment commit outcome unknown; retain object %s for reconciliation", object_key)
|
||||
else:
|
||||
try:
|
||||
storage().remove_object(BUCKET, object_key)
|
||||
except Exception:
|
||||
logger.exception("Orphan cleanup failed for object %s", object_key)
|
||||
raise
|
||||
return attachment_view(row)
|
||||
|
||||
|
||||
async def upload(request: Request, chat_id: str, actor_id: str, filename: str) -> dict:
|
||||
await asyncio.to_thread(store.chat, actor_id, chat_id)
|
||||
validate_filename(filename)
|
||||
declared_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
|
||||
if declared_type not in {"image/png", "image/jpeg"}:
|
||||
raise HTTPException(415)
|
||||
length = request.headers.get("content-length")
|
||||
if length is not None:
|
||||
try:
|
||||
if int(length) > MAX_BYTES:
|
||||
raise HTTPException(413)
|
||||
except ValueError:
|
||||
raise HTTPException(400) from None
|
||||
|
||||
with SpooledTemporaryFile(max_size=1024 * 1024) as stream:
|
||||
digest = hashlib.sha256()
|
||||
size = 0
|
||||
async for chunk in request.stream():
|
||||
size += len(chunk)
|
||||
if size > MAX_BYTES:
|
||||
raise HTTPException(413)
|
||||
stream.write(chunk)
|
||||
digest.update(chunk)
|
||||
stream.seek(0)
|
||||
validate_image(stream, declared_type)
|
||||
return await asyncio.to_thread(
|
||||
persist_attachment, chat_id, actor_id, filename, declared_type, size, digest.hexdigest(), stream
|
||||
)
|
||||
|
||||
+2
-1
@@ -37,7 +37,8 @@ def error_response(request: Request, status: int, extra_headers: dict | None = N
|
||||
@app.middleware("http")
|
||||
async def request_contract(request: Request, call_next):
|
||||
request.state.request_id = str(uuid4())
|
||||
if request.method == "POST" and request.url.path.startswith("/api/v1/") and request.url.path != "/api/v1/auth/sessions":
|
||||
is_upload = request.url.path.startswith("/api/v1/chats/") and request.url.path.endswith("/attachments")
|
||||
if request.method == "POST" and request.url.path.startswith("/api/v1/") and request.url.path != "/api/v1/auth/sessions" and not is_upload:
|
||||
media_type, _, charset = request.headers.get("content-type", "").lower().partition(";")
|
||||
if media_type.strip() != "application/json" or (charset and charset.strip() != "charset=utf-8"):
|
||||
return error_response(request, 415)
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 633 B |
@@ -0,0 +1,63 @@
|
||||
"""Black-box upload and validation checks; BASE_URL defaults to localhost:8080."""
|
||||
|
||||
import hashlib
|
||||
import struct
|
||||
import sys
|
||||
import unittest
|
||||
import zlib
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "tests"))
|
||||
from client import Client # noqa: E402
|
||||
|
||||
|
||||
PNG = (ROOT / "tests/fixtures/sample.png").read_bytes()
|
||||
JPEG = (ROOT / "student-tests/fixtures/sample.jpg").read_bytes()
|
||||
|
||||
|
||||
class UploadTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.client = Client()
|
||||
cls.alice, _, cls.eve, cls.chat = cls.client.bootstrap()
|
||||
cls.path = f"/api/v1/chats/{cls.chat['id']}/attachments"
|
||||
|
||||
def upload(self, content=PNG, media_type="image/png", filename="sample.png", expected=201, actor=None):
|
||||
return self.client.call(
|
||||
"POST", self.path + "?filename=" + quote(filename, safe=""), expected,
|
||||
actor=actor or self.alice, raw=content, headers={"Content-Type": media_type},
|
||||
schema="Attachment" if expected == 201 else None,
|
||||
)
|
||||
|
||||
def test_png_and_jpeg(self):
|
||||
for content, media_type, filename in ((PNG, "image/png", "sample.png"), (JPEG, "image/jpeg", "sample.jpg")):
|
||||
attachment = self.upload(content, media_type, filename)["json"]
|
||||
self.assertEqual(attachment["status"], "ready")
|
||||
self.assertEqual(attachment["owner_id"], self.alice["id"])
|
||||
self.assertEqual(attachment["chat_id"], self.chat["id"])
|
||||
self.assertEqual(attachment["content_type"], media_type)
|
||||
self.assertEqual(attachment["size_bytes"], len(content))
|
||||
self.assertEqual(attachment["sha256"], hashlib.sha256(content).hexdigest())
|
||||
|
||||
def test_rejects_oversized_and_oversized_pixels(self):
|
||||
self.upload(b"x" * (10 * 1024 * 1024 + 1), expected=413)
|
||||
changed = bytearray(PNG)
|
||||
changed[16:24] = struct.pack(">II", 6325, 6325)
|
||||
changed[29:33] = struct.pack(">I", zlib.crc32(changed[12:29]))
|
||||
self.upload(bytes(changed), expected=413)
|
||||
|
||||
def test_rejects_invalid_image_and_mime_spoofing(self):
|
||||
self.upload(PNG[:-10], expected=415)
|
||||
self.upload(PNG, "image/jpeg", expected=415)
|
||||
self.upload(b"not an image", expected=415)
|
||||
|
||||
def test_rejects_unsafe_names_and_outsider(self):
|
||||
for name in ("../bad.png", "folder\\bad.png", "bad\x00name.png", "bad\nname.png", ""):
|
||||
self.upload(filename=name, expected=400)
|
||||
self.upload(expected=404, actor=self.eve)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -31,7 +31,7 @@ class DatabaseTests(unittest.TestCase):
|
||||
def test_migration_and_unique_username_race(self):
|
||||
with psycopg.connect(URL) as conn:
|
||||
versions = conn.execute("SELECT version FROM schema_migrations").fetchall()
|
||||
self.assertEqual(versions, [(1,), (2,), (3,), (4,)])
|
||||
self.assertEqual(versions, [(1,), (2,), (3,), (4,), (5,)])
|
||||
name = "u_" + uuid4().hex[:16]
|
||||
|
||||
def register(_):
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
"""Run inside an API container while S3 is stopped; no secrets are printed."""
|
||||
|
||||
import io
|
||||
import unittest
|
||||
from urllib.error import HTTPError
|
||||
from urllib.request import Request, urlopen
|
||||
from uuid import uuid4
|
||||
|
||||
from PIL import Image
|
||||
|
||||
from src.db import pool
|
||||
from src.store import store
|
||||
|
||||
|
||||
def status(path: str, data: bytes | None = None, headers: dict | None = None) -> int:
|
||||
request = Request("http://127.0.0.1:8080" + path, data=data, headers=headers or {}, method="POST" if data is not None else "GET")
|
||||
try:
|
||||
with urlopen(request, timeout=15) as response:
|
||||
return response.status
|
||||
except HTTPError as error:
|
||||
return error.code
|
||||
|
||||
|
||||
class S3OutageTests(unittest.TestCase):
|
||||
def test_unavailable_without_false_ready_or_metadata(self):
|
||||
username = "s3_outage_" + uuid4().hex[:16]
|
||||
user = store.register(username, "S3 outage", "Test-password-123")
|
||||
session = store.create_session(username, "Test-password-123")
|
||||
chat = store.create_chat(user["id"], "S3 outage", [user["id"]])
|
||||
with pool().connection() as conn:
|
||||
before = conn.execute("SELECT count(*) AS n FROM attachments WHERE chat_id=%s", (chat["id"],)).fetchone()["n"]
|
||||
data = io.BytesIO()
|
||||
Image.new("RGB", (4, 3), (20, 60, 120)).save(data, format="PNG")
|
||||
self.assertEqual(status("/health/ready"), 503)
|
||||
self.assertEqual(
|
||||
status(f"/api/v1/chats/{chat['id']}/attachments?filename=outage.png", data.getvalue(),
|
||||
{"Content-Type": "image/png", "Authorization": "Bearer " + session["token"]}),
|
||||
503,
|
||||
)
|
||||
with pool().connection() as conn:
|
||||
after = conn.execute("SELECT count(*) AS n FROM attachments WHERE chat_id=%s", (chat["id"],)).fetchone()["n"]
|
||||
self.assertEqual(after, before)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,68 @@
|
||||
"""Run inside an API image: python - < student-tests/test_upload_failure.py."""
|
||||
|
||||
import asyncio
|
||||
import io
|
||||
import unittest
|
||||
from contextlib import contextmanager
|
||||
from unittest.mock import Mock, patch
|
||||
from uuid import uuid4
|
||||
|
||||
from fastapi import HTTPException
|
||||
|
||||
from src import attachments
|
||||
|
||||
|
||||
class UploadFailureTests(unittest.TestCase):
|
||||
def test_post_put_database_failure_compensates(self):
|
||||
client = Mock()
|
||||
with patch.object(attachments, "storage", return_value=client), patch.object(
|
||||
attachments, "connection", side_effect=HTTPException(503)
|
||||
):
|
||||
with self.assertRaises(HTTPException) as failure:
|
||||
attachments.persist_attachment(str(uuid4()), str(uuid4()), "test.png", "image/png", 3, "0" * 64, io.BytesIO(b"png"))
|
||||
self.assertEqual(failure.exception.status_code, 503)
|
||||
key = client.put_object.call_args.args[1]
|
||||
client.remove_object.assert_called_once_with(attachments.BUCKET, key)
|
||||
|
||||
def test_s3_failure_does_not_touch_database(self):
|
||||
client = Mock()
|
||||
client.put_object.side_effect = OSError("simulated outage")
|
||||
with patch.object(attachments, "storage", return_value=client), patch.object(attachments, "connection") as db:
|
||||
with self.assertRaises(HTTPException) as failure:
|
||||
attachments.persist_attachment(str(uuid4()), str(uuid4()), "test.png", "image/png", 3, "0" * 64, io.BytesIO(b"png"))
|
||||
self.assertEqual(failure.exception.status_code, 503)
|
||||
db.assert_not_called()
|
||||
|
||||
def test_ambiguous_commit_keeps_object_for_reconciliation(self):
|
||||
@contextmanager
|
||||
def ambiguous_commit():
|
||||
connection = Mock()
|
||||
connection.execute.return_value.fetchone.return_value = {}
|
||||
yield connection
|
||||
raise HTTPException(503)
|
||||
|
||||
client = Mock()
|
||||
with patch.object(attachments, "storage", return_value=client), patch.object(
|
||||
attachments, "connection", side_effect=ambiguous_commit
|
||||
):
|
||||
with self.assertRaises(HTTPException) as failure:
|
||||
attachments.persist_attachment(str(uuid4()), str(uuid4()), "test.png", "image/png", 3, "0" * 64, io.BytesIO(b"png"))
|
||||
self.assertEqual(failure.exception.status_code, 503)
|
||||
client.remove_object.assert_not_called()
|
||||
|
||||
def test_interrupted_request_never_starts_s3_put(self):
|
||||
class Interrupted:
|
||||
headers = {"content-type": "image/png"}
|
||||
|
||||
async def stream(self):
|
||||
yield b"partial"
|
||||
raise OSError("client disconnected")
|
||||
|
||||
with patch.object(attachments.store, "chat"), patch.object(attachments, "storage") as client:
|
||||
with self.assertRaises(OSError):
|
||||
asyncio.run(attachments.upload(Interrupted(), str(uuid4()), str(uuid4()), "test.png"))
|
||||
client.assert_not_called()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user