This commit is contained in:
2026-11-10 19:24:33 +03:00
parent c594b88a46
commit b55b230533
23 changed files with 1200 additions and 73 deletions
+4
View File
@@ -2,6 +2,8 @@
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
# Host port published by the LB. Default 8080; change if that port is already taken.
LB_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# compose.yaml gives api/migrate DB_HOST/DB_USER/DB_NAME and
@@ -28,3 +30,5 @@ S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
# Reconciler does not delete originals younger than this (seconds). Overridable per run with --grace-seconds.
RECONCILE_GRACE_SECONDS=900
+11 -1
View File
@@ -4,10 +4,11 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test load test-persistence test-failover test-attachments check-private-bucket upload-mem
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "test-attachments: student negative cases; check-private-bucket: MinIO ACL; upload-mem: 10 concurrent uploads"
check:
$(PYTHON) scripts/check_contract.py
@@ -28,3 +29,12 @@ test-persistence:
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-attachments:
$(PYTHON) tests/attachments_negative.py --base-url "$(BASE_URL)" $(TLS_ARGS)
check-private-bucket:
$(PYTHON) scripts/check_private_bucket.py
upload-mem:
$(PYTHON) scripts/upload_mem.py --base-url "$(BASE_URL)" --output evidence/upload-concurrency.json
+69 -15
View File
@@ -1,37 +1,91 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Sunrise443 (указать группу)
- Целевая оценка; выбранный трек 5, если нужен: **4**; трек 5 не заявлен
- Commit/PR: TODO после публикации (рабочее дерево поверх `c594b88`)
- Использованные источники, библиотеки и помощь ИИ: OpenAPI/семантика курса; документация MinIO, boto3, HAProxy 3.2; FastAPI/Starlette; реализация с помощью Cursor (Grok)
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Compose v2, Python 3.9+ для публичных тестов, свободный порт для LB.
```sh
cp .env.example .env
# Задайте уникальные POSTGRES_PASSWORD, MINIO_ROOT_PASSWORD, S3_SECRET_ACCESS_KEY.
# Если 8080 занят (другая лабораторная), задайте LB_PORT, например 8084.
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# Дождаться healthy у lb/api. Миграции и minio-init — one-shot.
make test BASE_URL=http://localhost:${LB_PORT:-8080}
make test-attachments BASE_URL=http://localhost:${LB_PORT:-8080}
make check-private-bucket
# Остановка с сохранением volumes:
docker compose --env-file .env down
# Учебный сброс данных (уничтожает pgdata и miniodata):
docker compose --env-file .env down -v
```
Образы (закреплены тегом+digest в `compose.yaml` / `Dockerfile`):
| Роль | Service | Образ | Volume | Сеть | Порт на host | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| LB | lb | haproxy:3.2.26-alpine@sha256:96ec… | — | edge | 127.0.0.1 / ::1 `LB_PORT` | нет |
| API | api ×2 | messenger-lab4-app (python:3.14.8-slim) | нет оригиналов | edge+data | нет | DB и S3 из secret files uid 10001 |
| PostgreSQL | postgres | postgres:16.10-alpine@sha256:0296… | pgdata | data (internal) | нет | POSTGRES_PASSWORD_FILE |
| S3 | minio | minio RELEASE.2025-09-07…@sha256:14ce… | miniodata | data, alias `s3` | нет | root только у minio-init |
| Bootstrap | minio-init | тот же MinIO + `infra/minio/bootstrap.sh` | — | data | — | root + API keys |
| Сверка | reconcile (profile `ops`) | тот же app image | — | data | — | те же API S3 keys |
| Private probe | check-private-bucket (profile `ops`) | тот же MinIO | — | data | — | root + API keys |
Локально на этой машине `LB_PORT=8084`, потому что 8080 занят стендом lab3.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → HAProxy → API ×2 → PostgreSQL (метаданные) + приватный bucket MinIO (байты). Object key назначает сервер: `originals/{uuid}`. Filename только для отображения.
Источник истины для «файл принят»: строка в `attachments` **и** объект в S3. `201 ready` возвращается только после PUT и INSERT. Неудачный INSERT компенсируется `delete_object`. Обрыв клиента до PUT не создаёт объект. Crash между PUT и INSERT оставляет orphan; его забирает сверка после grace period (по умолчанию 900 с).
Upload не держит весь файл в Python heap: чанки считаются, SHA-256 копится на лету, заголовок PNG/JPEG смотрится без распаковки bitmap (`inspect_prefix`), тело уходит в `SpooledTemporaryFile` (64 KiB RAM, остальное ephemeral tempfile) и streaming `put_object`. Лимит 10 MiB применяется по `Content-Length` и по счётчику чанков; HAProxy отсекает `Content-Length > 10485760` до API. PUT S3 ограничен 30 с; в backend HAProxy `set-timeout server 30s` только для `POST .../attachments`.
Перенос из lab3: сессии, идемпотентность сообщений, две реплики, LB. Новое: S3, Attachment, сверка, негативные тесты файлов.
Закладки под оценку 5 (не реализованы): prefix только `originals/`; reconciler игнорирует другие ключи; HTTP upload остаётся proxy `201`; dry-run по умолчанию.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `python tests/smoke.py --base-url http://localhost:8084` | PASS lab4 public API | [evidence/smoke.txt](evidence/smoke.txt) |
| S3 в стенде, байты не в БД/диске API | compose: minio без host ports, API без volume оригиналов, ключ `originals/{uuid}` | minio ports `[]`, API не публикует 9000 | [evidence/compose-minio-exposure.json](evidence/compose-minio-exposure.json) |
| PNG/JPEG ≤10 MiB / 40M px, MIME по содержимому | smoke fixture + negative suite | 201 на sample.png; 413/415 на отказ | [evidence/attachments-negative.txt](evidence/attachments-negative.txt) |
| Другая реплика / restart volumes | `scripts/restart.sh`, `scripts/stop-one.sh` (уровень 3, сохранено) | hook перезапускает postgres+minio+api+lb; stop-one гасит одну реплику | scripts/restart.sh, scripts/stop-one.sh |
| Негативные вложения, не 500 | `make test-attachments BASE_URL=http://localhost:8084` | oversized CL и chunked → 413; corrupt/MIME spoof → 415; pixel bomb → 413; чужой id и чужой чат → 404 | [evidence/attachments-negative.txt](evidence/attachments-negative.txt) |
| Компенсация / сверка / grace | `docker compose --profile ops run --rm reconcile --seed-orphan` затем `--apply --grace-seconds 0` | dry-run: сирота в `orphans_protected_by_grace`; apply: ключ удалён; живые originals не тронуты | [evidence/reconcile-dry-run.json](evidence/reconcile-dry-run.json), [evidence/reconcile-apply.json](evidence/reconcile-apply.json) |
| RAM, ≥10 одновременных upload | `python scripts/upload_mem.py --base-url http://localhost:8084` | 10/10 ок, ~1.9 MiB PNG, пик RSS api 93.66 MiB при лимите 256M (N×size ≈ 19 MiB) | [evidence/upload-concurrency.json](evidence/upload-concurrency.json) |
| Идемпотентный bootstrap | два `docker compose --env-file .env run --rm --no-deps minio-init` | оба: `bucket messenger-attachments is private`, exit 0 | [evidence/minio-init-rerun.txt](evidence/minio-init-rerun.txt) |
| Узкие S3 creds, консоль закрыта, private bucket вне API | `python scripts/check_private_bucket.py` | anonymous GET 403; API user не листит чужой bucket; MINIO_BROWSER=off; нет host ports; не в edge | [evidence/private-bucket.txt](evidence/private-bucket.txt) |
| Трек 5 | не заявлен | — | — |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Гипотеза (RAM): десять одновременных ~1.9 MiB PNG не разгоняют RSS API пропорционально `N * size` и укладываются в 256 MiB. Стенд: Windows AMD64, Intel, compose limits api 256M × 2 реплики, MinIO 512M. Профиль: 10 POST, файл 1 994 104 байт, сгенерирован в рантайме. Результат: 10 успехов, 0 ошибок, p50 ≈ 0.52 с, p95 ≈ 0.55 с, пик RSS контейнера api-2 **93.66 MiB**. Ограничение: `docker stats` — RSS контейнера с шагом десятых долей секунды, не профилировщик кучи; в выборке 3 снимка, пик внутри запроса мог быть выше.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Content-Length > 10 MiB | 413 на LB, тело не читается | 413 `payload_too_large` | нет записи |
| Chunked тело > 10 MiB | 413 на API по счётчику чанков | 413 `payload_too_large` | нет объекта |
| Повреждённый PNG/JPEG, подмена MIME | 415 | 415 `unsupported_media_type` | нет объекта |
| IHDR 10000×5000 (50M px) | 413 до decode | 413 | нет объекта |
| GET чужого attachment_id | 404, без утечки | 404 `not_found` | — |
| attachment_id другого чата в POST message | 404 | 404 | сообщение не создано |
| S3 PUT прошёл, INSERT нет | компенсация DELETE; иначе orphan до сверки | `_discard_object`; сирота удаляется `--apply` после grace | объект без метаданных не вечный |
| Повтор minio-init | no-op, bucket private | два exit 0 | нет |
| Unauthenticated GET объекта | 403 мимо API | 403 | — |
В сверке на учебном volume есть два `missing_objects` с ключами без prefix `originals/` (старые строки БД с прошлых итераций). Reconciler **не** удаляет строки PostgreSQL — это зона трека 5. Живые `originals/{uuid}` после apply на месте.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Выдерживаются клиентские ошибки вложений (4xx, не 500), обрыв до PUT, неудачный INSERT, stale orphan после grace, недоступность bucket с хоста, повтор bootstrap. Не выдерживается потеря всего Docker-host; одна PostgreSQL и один MinIO не HA. Download оригинала пока буферизуется целиком (критерий 4 про загрузку). Spool — ephemeral tempfile запроса, не источник истины.
Трек 5 не делался: нет 202/worker/thumbnail, нет presigned, нет research-измерения стоимости обхода. Reconciler уже с dry-run и grace, prefix `originals/` не трогает будущий `staging/` / `variants/`.
+51 -16
View File
@@ -3,18 +3,25 @@
Dimensions come from IHDR or a JPEG SOF marker. The compressed pixel data is never unpacked,
so a small file cannot expand into an unbounded bitmap before the pixel limit is applied.
"""
from typing import NoReturn
from typing import NoReturn, Optional
from .errors import payload_too_large, unsupported_media_type
MAX_UPLOAD_BYTES = 10_485_760
MAX_IMAGE_PIXELS = 40_000_000
# SOF/IHDR almost always sit in the first tens of kilobytes. The rest of the
# object is hashed and stored without being held as one Python bytes object.
INSPECT_PREFIX = 256 * 1024
_PNG = b'\x89PNG\r\n\x1a\n'
# SOF markers that carry width and height. DHT/DAC/JPG are skipped by the length field.
_JPEG_SOF = {0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF}
class _NeedMore(Exception):
"""The prefix does not yet contain a complete PNG IHDR or JPEG SOF."""
def _reject() -> NoReturn:
raise unsupported_media_type('Файл не является PNG или JPEG')
@@ -26,18 +33,29 @@ def _check_pixels(width: int, height: int) -> None:
raise payload_too_large('Изображение превышает 40 миллионов пикселей')
def _png_size(data: bytes) -> None:
if len(data) < 24 or not data.startswith(_PNG):
def _png_size(data: bytes) -> str:
if len(data) < 8:
if _PNG.startswith(data):
raise _NeedMore()
_reject()
if not data.startswith(_PNG):
_reject()
if len(data) < 24:
raise _NeedMore()
if int.from_bytes(data[8:12], 'big') != 13 or data[12:16] != b'IHDR':
_reject()
width = int.from_bytes(data[16:20], 'big')
height = int.from_bytes(data[20:24], 'big')
_check_pixels(width, height)
return 'image/png'
def _jpeg_size(data: bytes) -> None:
if len(data) < 4 or data[0:2] != b'\xff\xd8':
def _jpeg_size(data: bytes) -> str:
if len(data) < 2:
if b'\xff\xd8'.startswith(data):
raise _NeedMore()
_reject()
if data[0:2] != b'\xff\xd8':
_reject()
index = 2
while index < len(data):
@@ -47,7 +65,7 @@ def _jpeg_size(data: bytes) -> None:
while index < len(data) and data[index] == 0xFF:
index += 1
if index >= len(data):
break
raise _NeedMore()
marker = data[index]
index += 1
if marker in (0x01, 0xD8, 0xD9) or 0xD0 <= marker <= 0xD7:
@@ -55,10 +73,12 @@ def _jpeg_size(data: bytes) -> None:
break
continue
if index + 2 > len(data):
break
raise _NeedMore()
segment_length = int.from_bytes(data[index:index + 2], 'big')
if segment_length < 2 or index + segment_length > len(data):
if segment_length < 2:
_reject()
if index + segment_length > len(data):
raise _NeedMore()
# Start of scan: entropy-coded bytes follow. Dimensions must already have been seen.
if marker == 0xDA:
break
@@ -68,17 +88,32 @@ def _jpeg_size(data: bytes) -> None:
height = int.from_bytes(data[index + 3:index + 5], 'big')
width = int.from_bytes(data[index + 5:index + 7], 'big')
_check_pixels(width, height)
return
return 'image/jpeg'
index += segment_length
_reject()
def inspect_prefix(data: bytes, *, complete: bool) -> Optional[str]:
"""Return image/png or image/jpeg, or None if `complete` is false and more bytes are required."""
if not data:
if complete:
_reject()
return None
try:
if data[0] == 0x89:
return _png_size(data)
if data[0] == 0xFF:
return _jpeg_size(data)
_reject()
except _NeedMore:
if complete:
_reject()
return None
def inspect_image(data: bytes) -> str:
"""Return image/png or image/jpeg after a header check. Raises 413 or 415."""
if data.startswith(_PNG):
_png_size(data)
return 'image/png'
if data.startswith(b'\xff\xd8'):
_jpeg_size(data)
return 'image/jpeg'
_reject()
result = inspect_prefix(data, complete=True)
if result is None:
_reject()
return result
+112 -5
View File
@@ -1,6 +1,9 @@
"""Private S3 bucket. Callers pass a server-generated key; the display filename never becomes one."""
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import TimeoutError as FutureTimeout
from dataclasses import dataclass
from datetime import datetime
from typing import BinaryIO, List
import boto3
from botocore.config import Config
@@ -8,9 +11,11 @@ from botocore.exceptions import BotoCoreError, ClientError
from .config import ObjectSettings
ORIGINAL_PREFIX = 'originals/'
# Docker DNS can spend several seconds on a stopped MinIO name. The HTTP handler
# must still answer inside HAProxy's one-second health check.
_POOL = ThreadPoolExecutor(max_workers=16, thread_name_prefix='s3')
_POOL = ThreadPoolExecutor(max_workers=32, thread_name_prefix='s3')
class MissingObject(Exception):
@@ -21,6 +26,20 @@ class StorageError(Exception):
"""The object store could not complete the call. The message stays internal."""
@dataclass(frozen=True)
class StoredObject:
key: str
last_modified: datetime
size: int
@dataclass(frozen=True)
class MultipartUpload:
key: str
upload_id: str
initiated: datetime
class ObjectStore:
def __init__(self, settings: ObjectSettings) -> None:
self._bucket = settings.bucket
@@ -34,7 +53,7 @@ class ObjectStore:
signature_version='s3v4',
s3={'addressing_style': 'path'},
connect_timeout=1,
read_timeout=2,
read_timeout=30,
retries={'max_attempts': 1},
),
)
@@ -43,14 +62,26 @@ class ObjectStore:
self._bounded(self._head, 0.7)
def put(self, key: str, body: bytes, content_type: str) -> None:
self._bounded(lambda: self._put(key, body, content_type), 8)
self._bounded(lambda: self._put_bytes(key, body, content_type), 30)
def put_stream(self, key: str, body: BinaryIO, size: int, content_type: str) -> None:
self._bounded(lambda: self._put_stream(key, body, size, content_type), 30)
def get(self, key: str) -> bytes:
return self._bounded(lambda: self._get(key), 8)
return self._bounded(lambda: self._get(key), 15)
def delete(self, key: str) -> None:
self._bounded(lambda: self._delete(key), 8)
def list_originals(self) -> List[StoredObject]:
return self._bounded(self._list_originals, 15)
def list_multipart(self) -> List[MultipartUpload]:
return self._bounded(self._list_multipart, 15)
def abort_multipart(self, key: str, upload_id: str) -> None:
self._bounded(lambda: self._abort_multipart(key, upload_id), 8)
def _bounded(self, fn, timeout: float):
future = _POOL.submit(fn)
try:
@@ -64,7 +95,7 @@ class ObjectStore:
except (BotoCoreError, ClientError):
raise StorageError() from None
def _put(self, key: str, body: bytes, content_type: str) -> None:
def _put_bytes(self, key: str, body: bytes, content_type: str) -> None:
try:
self._client.put_object(
Bucket=self._bucket,
@@ -76,6 +107,19 @@ class ObjectStore:
except (BotoCoreError, ClientError):
raise StorageError() from None
def _put_stream(self, key: str, body: BinaryIO, size: int, content_type: str) -> None:
body.seek(0)
try:
self._client.put_object(
Bucket=self._bucket,
Key=key,
Body=body,
ContentType=content_type,
ContentLength=size,
)
except (BotoCoreError, ClientError):
raise StorageError() from None
def _get(self, key: str) -> bytes:
try:
response = self._client.get_object(Bucket=self._bucket, Key=key)
@@ -97,3 +141,66 @@ class ObjectStore:
self._client.delete_object(Bucket=self._bucket, Key=key)
except (BotoCoreError, ClientError):
raise StorageError() from None
def _list_originals(self) -> List[StoredObject]:
objects: List[StoredObject] = []
token = None
try:
while True:
kwargs = {'Bucket': self._bucket, 'Prefix': ORIGINAL_PREFIX}
if token:
kwargs['ContinuationToken'] = token
response = self._client.list_objects_v2(**kwargs)
for item in response.get('Contents') or ():
key = item['Key']
if not key.startswith(ORIGINAL_PREFIX) or key.endswith('/'):
continue
objects.append(StoredObject(key, item['LastModified'], int(item['Size'])))
if not response.get('IsTruncated'):
return objects
token = response.get('NextContinuationToken')
if not token:
return objects
except (BotoCoreError, ClientError):
raise StorageError() from None
def _list_multipart(self) -> List[MultipartUpload]:
uploads: List[MultipartUpload] = []
key_marker = ''
upload_marker = ''
try:
while True:
kwargs = {'Bucket': self._bucket, 'Prefix': ORIGINAL_PREFIX}
if key_marker:
kwargs['KeyMarker'] = key_marker
if upload_marker:
kwargs['UploadIdMarker'] = upload_marker
response = self._client.list_multipart_uploads(**kwargs)
for item in response.get('Uploads') or ():
key = item['Key']
if not key.startswith(ORIGINAL_PREFIX):
continue
uploads.append(MultipartUpload(key, item['UploadId'], item['Initiated']))
if not response.get('IsTruncated'):
return uploads
key_marker = response.get('NextKeyMarker') or ''
upload_marker = response.get('NextUploadIdMarker') or ''
if not key_marker and not upload_marker:
return uploads
except ClientError as exc:
code = exc.response.get('Error', {}).get('Code', '')
if code in ('NotImplemented', 'AccessDenied'):
return []
raise StorageError() from None
except BotoCoreError:
raise StorageError() from None
def _abort_multipart(self, key: str, upload_id: str) -> None:
try:
self._client.abort_multipart_upload(
Bucket=self._bucket,
Key=key,
UploadId=upload_id,
)
except (BotoCoreError, ClientError):
raise StorageError() from None
+142
View File
@@ -0,0 +1,142 @@
"""Compare originals/ in the private bucket with attachment metadata.
Dry-run is the default. --apply deletes unreferenced originals and aborts stale
multipart uploads older than the grace period. Keys outside originals/ are ignored
so a later staging/ or variants/ prefix is not swept. Missing S3 objects for a DB
row are reported only; they are not deleted from PostgreSQL.
"""
from __future__ import annotations
import argparse
import asyncio
import json
import logging
import os
import uuid
from datetime import datetime, timezone
from typing import Any, Dict
from .config import load_object_settings, load_settings
from .db import open_pool
from .objects import ORIGINAL_PREFIX, ObjectStore, StorageError
from .store import Store
logger = logging.getLogger('messenger.reconcile')
_DEFAULT_GRACE = 900
def _grace_default() -> int:
raw = os.getenv('RECONCILE_GRACE_SECONDS', '').strip()
return int(raw) if raw else _DEFAULT_GRACE
def _age_seconds(moment: datetime, now: datetime) -> float:
if moment.tzinfo is None:
moment = moment.replace(tzinfo=timezone.utc)
return max(0.0, (now - moment).total_seconds())
async def _seed(objects: ObjectStore) -> str:
key = ORIGINAL_PREFIX + str(uuid.uuid4())
await asyncio.to_thread(objects.put, key, b'orphan-probe', 'application/octet-stream')
return key
async def _run(args: argparse.Namespace) -> Dict[str, Any]:
settings = load_settings()
objects = ObjectStore(load_object_settings())
pool = await open_pool(settings.database_url)
now = datetime.now(timezone.utc)
report: Dict[str, Any] = {
'apply': args.apply,
'grace_seconds': args.grace_seconds,
'seeded': None,
'scanned_originals': 0,
'referenced': 0,
'orphans_protected_by_grace': [],
'orphans_stale': [],
'multipart_protected_by_grace': [],
'multipart_stale': [],
'deleted': [],
'aborted_multipart': [],
'missing_objects': [],
}
try:
store = Store(
pool,
settings.session_ttl_seconds,
settings.idempotency_ttl_seconds,
objects=objects,
)
if args.seed_orphan:
report['seeded'] = await _seed(objects)
referenced = await store.listed_object_keys()
report['referenced'] = len(referenced)
stored = await asyncio.to_thread(objects.list_originals)
report['scanned_originals'] = len(stored)
stored_keys = {item.key for item in stored}
for key in sorted(referenced - stored_keys):
report['missing_objects'].append({'key': key})
for item in stored:
if item.key in referenced:
continue
age = _age_seconds(item.last_modified, now)
entry = {'key': item.key, 'age_seconds': int(age), 'size': item.size}
if age < args.grace_seconds:
report['orphans_protected_by_grace'].append(entry)
continue
report['orphans_stale'].append(entry)
if args.apply:
try:
await asyncio.to_thread(objects.delete, item.key)
report['deleted'].append(item.key)
except StorageError:
logger.warning('failed to delete orphan %s', item.key)
uploads = await asyncio.to_thread(objects.list_multipart)
for item in uploads:
age = _age_seconds(item.initiated, now)
entry = {'key': item.key, 'upload_id': item.upload_id, 'age_seconds': int(age)}
if age < args.grace_seconds:
report['multipart_protected_by_grace'].append(entry)
continue
report['multipart_stale'].append(entry)
if args.apply:
try:
await asyncio.to_thread(objects.abort_multipart, item.key, item.upload_id)
report['aborted_multipart'].append(entry)
except StorageError:
logger.warning('failed to abort multipart %s', item.key)
return report
finally:
await pool.close()
def main() -> None:
logging.basicConfig(level=logging.INFO, format='%(levelname)s %(message)s')
parser = argparse.ArgumentParser(description='Reconcile originals/ with attachment metadata')
parser.add_argument(
'--apply',
action='store_true',
help='delete stale orphans; default is dry-run',
)
parser.add_argument(
'--grace-seconds',
type=int,
default=_grace_default(),
help='do not delete objects younger than this (default 900, or RECONCILE_GRACE_SECONDS)',
)
parser.add_argument(
'--seed-orphan',
action='store_true',
help='put an unreferenced originals/ object, then scan (evidence only)',
)
args = parser.parse_args()
if args.grace_seconds < 0:
parser.error('grace-seconds must be >= 0')
report = asyncio.run(_run(args))
print(json.dumps(report, ensure_ascii=False, indent=2))
if __name__ == '__main__':
main()
+61 -24
View File
@@ -1,8 +1,9 @@
import hashlib
import json
import re
import tempfile
import uuid
from typing import Optional, Sequence, Type, TypeVar
from typing import BinaryIO, Optional, Sequence, Tuple, Type, TypeVar
from fastapi import APIRouter, Depends, Request
from fastapi.responses import JSONResponse
@@ -12,11 +13,15 @@ from starlette.responses import Response
from .auth import BASIC_CHALLENGE, BEARER_CHALLENGE, parse_basic, parse_bearer
from .drain import draining
from .errors import invalid_request, not_found, payload_too_large, unauthorized, unavailable, unsupported_media_type
from .images import MAX_UPLOAD_BYTES, inspect_image
from .images import INSPECT_PREFIX, MAX_UPLOAD_BYTES, inspect_image, inspect_prefix
from .pagination import encode_cursor, parse_page
from .schemas import CreateChat, CreateMessage, CreateUser
from .store import Chat, Store, User
# Bytes kept in RAM before SpooledTemporaryFile rolls over to an ephemeral file.
# The original is never persisted on the API volume; the spool dies with the request.
_SPOOL_RAM = 64 * 1024
router = APIRouter()
Body = TypeVar('Body', bound=BaseModel)
@@ -77,21 +82,50 @@ def _declared_image_type(value: Optional[str]) -> str:
return media
async def _read_upload(request: Request) -> bytes:
declared = request.headers.get('content-length')
if declared is not None:
async def _spool_upload(request: Request, declared: str) -> Tuple[BinaryIO, int, str, str]:
"""Stream the body into a size-capped spool, hash it, and inspect the header.
Returns (spool, size, sha256, sniffed_type). The caller must close the spool.
One request never holds more than INSPECT_PREFIX plus _SPOOL_RAM in Python heap;
the rest, if any, is an ephemeral tempfile deleted in finally.
"""
length = request.headers.get('content-length')
if length is not None:
try:
size = int(declared)
size = int(length)
except ValueError:
raise invalid_request('Некорректный Content-Length') from None
if size > MAX_UPLOAD_BYTES:
raise payload_too_large('Файл больше 10 МиБ')
buf = bytearray()
async for chunk in request.stream():
if len(buf) + len(chunk) > MAX_UPLOAD_BYTES:
raise payload_too_large('Файл больше 10 МиБ')
buf.extend(chunk)
return bytes(buf)
spool = tempfile.SpooledTemporaryFile(max_size=_SPOOL_RAM)
hasher = hashlib.sha256()
head = bytearray()
total = 0
sniffed: Optional[str] = None
try:
async for chunk in request.stream():
if not chunk:
continue
if total + len(chunk) > MAX_UPLOAD_BYTES:
raise payload_too_large('Файл больше 10 МиБ')
hasher.update(chunk)
spool.write(chunk)
total += len(chunk)
if len(head) < INSPECT_PREFIX:
head.extend(chunk[: INSPECT_PREFIX - len(head)])
if sniffed is None and len(head) >= 24:
sniffed = inspect_prefix(bytes(head), complete=False)
if sniffed is not None and sniffed != declared:
raise unsupported_media_type('Содержимое не соответствует Content-Type')
if sniffed is None:
sniffed = inspect_image(bytes(head))
if sniffed != declared:
raise unsupported_media_type('Содержимое не соответствует Content-Type')
spool.seek(0)
return spool, total, hasher.hexdigest(), sniffed
except BaseException:
spool.close()
raise
async def _member_chat(store: Store, chat_id: str, actor: User) -> Chat:
@@ -231,18 +265,21 @@ async def upload_attachment(
chat = await _member_chat(store, chat_id, actor)
filename = _filename(request.query_params.get('filename'))
declared = _declared_image_type(request.headers.get('content-type'))
data = await _read_upload(request)
actual = inspect_image(data)
if actual != declared:
raise unsupported_media_type('Содержимое не соответствует Content-Type')
attachment = await store.create_attachment(
chat.id,
actor.id,
filename,
actual,
data,
hashlib.sha256(data).hexdigest(),
)
spool = None
try:
spool, size, digest, actual = await _spool_upload(request, declared)
attachment = await store.create_attachment(
chat.id,
actor.id,
filename,
actual,
spool,
size,
digest,
)
finally:
if spool is not None:
spool.close()
return JSONResponse(attachment.to_dict(), status_code=201)
+15 -7
View File
@@ -7,13 +7,13 @@ import threading
import uuid
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from typing import Dict, List, Optional, Sequence, Tuple
from typing import BinaryIO, Dict, List, Optional, Sequence, Set, Tuple
import asyncpg
from .errors import conflict, invalid_request, not_found, unavailable
from .migrate import expected_versions
from .objects import MissingObject, ObjectStore, StorageError
from .objects import ORIGINAL_PREFIX, MissingObject, ObjectStore, StorageError
from .pagination import Key
from .passwords import hash_password, password_matches
@@ -376,7 +376,8 @@ class Store:
owner_id: str,
filename: str,
content_type: str,
body: bytes,
body: BinaryIO,
size_bytes: int,
sha256: str,
) -> Attachment:
chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id')
@@ -384,11 +385,12 @@ class Store:
attachment_id = uuid.uuid4()
# The key is not derived from filename. A crash after PUT and before INSERT leaves an
# unreferenced object; a failed INSERT deletes it. 201 is returned only after both succeed.
object_key = 'originals/%s' % attachment_id
object_key = ORIGINAL_PREFIX + str(attachment_id)
created = self._now()
try:
await asyncio.to_thread(self._objects.put, object_key, body, content_type)
await asyncio.to_thread(self._objects.put_stream, object_key, body, size_bytes, content_type)
except StorageError:
await self._discard_object(object_key)
raise unavailable('Хранилище недоступно') from None
try:
async with self._pool.acquire() as conn:
@@ -405,7 +407,7 @@ class Store:
owner_uuid,
filename,
content_type,
len(body),
size_bytes,
sha256,
object_key,
created,
@@ -420,12 +422,18 @@ class Store:
str(owner_uuid),
filename,
content_type,
len(body),
size_bytes,
sha256,
stamp,
stamp,
)
async def listed_object_keys(self) -> Set[str]:
"""Object keys that have a metadata row. Used by the reconciler, not by the HTTP API."""
async with self._pool.acquire() as conn:
rows = await conn.fetch('SELECT object_key FROM attachments')
return {row['object_key'] for row in rows}
async def find_attachment(self, attachment_id: str, user_id: str) -> Optional[Attachment]:
"""Metadata for a chat member. Missing and foreign attachments are both absent."""
attachment_uuid = _as_uuid(attachment_id, 'Некорректный attachment_id')
+73
View File
@@ -129,6 +129,79 @@ services:
depends_on:
minio:
condition: service_healthy
deploy:
resources:
limits:
cpus: "0.5"
memory: 256M
restart: "no"
# Operator one-shot: python -m app.reconcile (dry-run). Pass --apply / --seed-orphan as args.
# Not started by `up`; use: docker compose --env-file .env --profile ops run --rm reconcile
reconcile:
image: messenger-lab4-app:${APP_VERSION:-dev}
build: *app-build
profiles: ["ops"]
entrypoint: ["python", "-m", "app.reconcile"]
environment:
<<: *db-client
S3_ENDPOINT: ${S3_ENDPOINT:?set in .env}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:?set in .env}
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
RECONCILE_GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-900}
secrets:
- source: postgres_password
uid: "10001"
gid: "10001"
mode: 0400
- source: s3_access_key_id
uid: "10001"
gid: "10001"
mode: 0400
- source: s3_secret_access_key
uid: "10001"
gid: "10001"
mode: 0400
networks:
- data
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
minio-init:
condition: service_completed_successfully
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
restart: "no"
# Unauthenticated GET and console probe from the internal data network.
check-private-bucket:
image: ghcr.io/tsouza/cerberus-mirror/minio/minio:RELEASE.2025-09-07T16-13-09Z@sha256:14cea493d9a34af32f524e538b8346cf79f3321eff8e708c1e2960462bd8936e
profiles: ["ops"]
entrypoint: ["/bin/sh", "/bootstrap/check-private-bucket.sh"]
environment:
S3_BUCKET: ${S3_BUCKET:?set in .env}
MINIO_ENDPOINT: http://minio:9000
secrets:
- minio_root_user
- minio_root_password
- s3_access_key_id
- s3_secret_access_key
volumes:
- ./infra/minio/check-private-bucket.sh:/bootstrap/check-private-bucket.sh:ro
networks:
- data
depends_on:
minio:
condition: service_healthy
minio-init:
condition: service_completed_successfully
deploy:
resources:
limits:
Binary file not shown.
+23
View File
@@ -0,0 +1,23 @@
{
"minio_ports": [],
"MINIO_BROWSER": "off",
"networks": [
"data"
],
"lb_ports": [
{
"mode": "ingress",
"host_ip": "127.0.0.1",
"target": 8080,
"published": "8084",
"protocol": "tcp"
},
{
"mode": "ingress",
"host_ip": "::1",
"target": 8080,
"published": "8084",
"protocol": "tcp"
}
]
}
+7
View File
@@ -0,0 +1,7 @@
# Idempotent MinIO bootstrap. Secrets are not printed.
# docker compose --env-file .env run --rm --no-deps minio-init
# (two sequential runs after the 256M memory limit on minio-init)
run 1: bucket messenger-attachments is private
run 2: bucket messenger-attachments is private
exit: 0 both times
+7
View File
@@ -0,0 +1,7 @@
# python scripts/check_private_bucket.py
# (stack already up; in-network probe via compose profile ops)
PASS: bucket messenger-attachments is private; unauthenticated GET is 403; API user cannot list another bucket; console is closed
PASS: minio has no host ports, console env is off, in-network GET is 403
See also evidence/compose-minio-exposure.json
+29
View File
@@ -0,0 +1,29 @@
{
"apply": true,
"grace_seconds": 0,
"seeded": null,
"scanned_originals": 37,
"referenced": 38,
"orphans_protected_by_grace": [],
"orphans_stale": [
{
"key": "originals/44d0830b-a013-482c-ae07-83805b6470c1",
"age_seconds": 10,
"size": 12
}
],
"multipart_protected_by_grace": [],
"multipart_stale": [],
"deleted": [
"originals/44d0830b-a013-482c-ae07-83805b6470c1"
],
"aborted_multipart": [],
"missing_objects": [
{
"key": "a93d1b7ab79245ec95f792b569c3ee46"
},
{
"key": "c96e4c9da2114c9e837c372ef9e75e15"
}
]
}
+27
View File
@@ -0,0 +1,27 @@
{
"apply": false,
"grace_seconds": 900,
"seeded": "originals/44d0830b-a013-482c-ae07-83805b6470c1",
"scanned_originals": 37,
"referenced": 38,
"orphans_protected_by_grace": [
{
"key": "originals/44d0830b-a013-482c-ae07-83805b6470c1",
"age_seconds": 0,
"size": 12
}
],
"orphans_stale": [],
"multipart_protected_by_grace": [],
"multipart_stale": [],
"deleted": [],
"aborted_multipart": [],
"missing_objects": [
{
"key": "a93d1b7ab79245ec95f792b569c3ee46"
},
{
"key": "c96e4c9da2114c9e837c372ef9e75e15"
}
]
}
Binary file not shown.
+37
View File
@@ -0,0 +1,37 @@
{
"hypothesis": "Ten concurrent ~1.9 MiB PNG uploads stay inside the 256 MiB API limit and peak RSS is not proportional to N * file_size because the body is spooled, not held twice as bytes.",
"when": "2026-11-09T17:15:07Z",
"commit": "c594b88",
"host": {
"system": "Windows",
"machine": "AMD64",
"processor": "Intel64 Family 6 Model 165 Stepping 2, GenuineIntel"
},
"compose_limits": {
"api_memory": "256M",
"replicas": 2
},
"profile": {
"concurrency": 10,
"width": 900,
"height": 700,
"size_bytes": 1994104,
"sha256": "03f35c154abaa690cfc41d6d73715992df84d10f45ff48dc14722bd64e49a263"
},
"results": {
"ok": 10,
"errors": 0,
"elapsed_s": 1.995,
"p50_s": 0.5158,
"p95_s": 0.5466,
"p99_s": 0.5466,
"peak_api_rss_mib": 93.66,
"peak_rss_by_container_mib": {
"messenger-lab4-api-2": 93.66,
"messenger-lab4-api-1": 85.37
},
"samples": 3,
"naive_n_times_size_mib": 19.02
},
"limits_of_measurement": "docker stats RSS is container-level and sampled ~200 ms; it is not a cgroup memory profiler. Python heap is not separated from MinIO/HAProxy. Coordinated start of N POSTs from one client."
}
+7 -2
View File
@@ -36,7 +36,8 @@ defaults
timeout connect 1s
timeout client 30s
timeout server 10s
timeout http-request 10s
# Body arrival for a 10 MiB attachment; JSON posts finish well under this.
timeout http-request 30s
timeout http-keep-alive 5s
timeout queue 2s
timeout check 1s
@@ -55,7 +56,7 @@ frontend public
acl safe_request_id req.hdr(X-Request-Id) -m reg ^[A-Za-z0-9._:-]{1,128}$
http-request set-var(txn.reqid) req.hdr(X-Request-Id) if upload_too_large safe_request_id
http-request set-var(txn.reqid) str(lb) if upload_too_large !safe_request_id
http-request return status 413 content-type application/json lf-string "{\"error\":{\"code\":\"payload_too_large\",\"message\":\"Файл больше 10 МиБ\",\"request_id\":\"%[var(txn.reqid)]\"}}" hdr X-Request-Id %[var(txn.reqid)] if upload_too_large
http-request return status 413 content-type application/json lf-string "{\"error\":{\"code\":\"payload_too_large\",\"message\":\"Файл больше 10 МиБ\",\"request_id\":\"%[var(txn.reqid)]\"}}" hdr X-Request-Id %[var(txn.reqid)] hdr X-Instance-Id %[str(lb)] if upload_too_large
# Message POST carries a mandatory Idempotency-Key, so replaying it on another replica is safe.
# Other POSTs (users, chats, sessions) are retried only when the connection was never established.
@@ -67,6 +68,10 @@ frontend public
backend api
# Round robin, no stickiness: any replica serves any session from PostgreSQL.
# Attachment PUT to S3 can outlast the default 10 s server timeout under concurrent load.
acl attachment_upload method POST
acl attachment_upload_path path_reg ^/api/v1/chats/[^/]+/attachments$
http-request set-timeout server 30s if attachment_upload attachment_upload_path
balance roundrobin
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host lb
+7 -3
View File
@@ -70,7 +70,7 @@ cat > "$policy_file" <<EOF
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetBucketLocation", "s3:ListBucket"],
"Action": ["s3:GetBucketLocation", "s3:ListBucket", "s3:ListBucketMultipartUploads"],
"Resource": ["arn:aws:s3:::${bucket}"]
},
{
@@ -88,9 +88,13 @@ cat > "$policy_file" <<EOF
}
EOF
if ! mc admin policy info local "$policy_name" >/dev/null 2>&1; then
mc admin policy create local "$policy_name" "$policy_file" >/dev/null
# Recreate the canned policy on every run so added actions (multipart list) apply.
if mc admin user info local "$access_key" >/dev/null 2>&1; then
mc admin policy detach local "$policy_name" --user "$access_key" >/dev/null 2>&1 || true
fi
mc admin policy remove local "$policy_name" >/dev/null 2>&1 || \
mc admin policy rm local "$policy_name" >/dev/null 2>&1 || true
mc admin policy create local "$policy_name" "$policy_file" >/dev/null
if ! mc admin user info local "$access_key" >/dev/null 2>&1; then
mc admin user add local "$access_key" "$secret_key" >/dev/null
+41
View File
@@ -0,0 +1,41 @@
#!/bin/sh
# In-network proof that the bucket is private and API credentials cannot see other buckets.
# Run via: docker compose --env-file .env --profile ops run --rm check-private-bucket
set -eu
bucket=${S3_BUCKET:?S3_BUCKET is required}
endpoint=${MINIO_ENDPOINT:-http://minio:9000}
read_secret() {
tr -d '\r\n' < "$1"
}
root_user=$(read_secret /run/secrets/minio_root_user)
root_password=$(read_secret /run/secrets/minio_root_password)
access_key=$(read_secret /run/secrets/s3_access_key_id)
secret_key=$(read_secret /run/secrets/s3_secret_access_key)
mc alias set local "$endpoint" "$root_user" "$root_password" >/dev/null
# MINIO_BROWSER=off: nothing should answer on the console port.
if curl -sf --connect-timeout 2 "http://minio:9001/" >/dev/null 2>&1; then
echo "MinIO console answered on :9001" >&2
exit 1
fi
probe_key=".bootstrap/private-check"
printf 'probe' | mc pipe "local/${bucket}/${probe_key}" >/dev/null
code=$(curl -s -o /dev/null -w '%{http_code}' "${endpoint}/${bucket}/${probe_key}")
mc rm --force "local/${bucket}/${probe_key}" >/dev/null
if [ "$code" != "403" ]; then
echo "unauthenticated GET returned ${code}, expected 403" >&2
exit 1
fi
mc alias set api "$endpoint" "$access_key" "$secret_key" >/dev/null
if mc ls "api/not-this-bucket" >/dev/null 2>&1; then
echo "API credentials can list a different bucket" >&2
exit 1
fi
echo "PASS: bucket ${bucket} is private; unauthenticated GET is 403; API user cannot list another bucket; console is closed"
+66
View File
@@ -0,0 +1,66 @@
#!/usr/bin/env python3
"""Host-side private-bucket checks plus the in-network probe.
Confirms MinIO publishes no host ports, the console env is off, then runs the
compose service that performs an unauthenticated GET from the data network.
"""
from __future__ import annotations
import json
import os
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def _compose(args):
env_file = ROOT / '.env'
cmd = ['docker', 'compose']
if env_file.is_file():
cmd.extend(['--env-file', str(env_file)])
cmd.extend(args)
return subprocess.run(cmd, cwd=str(ROOT), check=True, capture_output=True, text=True)
def main() -> None:
os.chdir(ROOT)
result = _compose(['config', '--format', 'json'])
config = json.loads(result.stdout)
services = config.get('services') or {}
minio = services.get('minio')
if minio is None:
raise SystemExit('FAIL: compose config has no minio service')
ports = minio.get('ports') or []
if ports:
raise SystemExit('FAIL: minio publishes host ports: %s' % ports)
env = minio.get('environment') or {}
browser = str(env.get('MINIO_BROWSER', '')).strip().strip('"').lower()
if browser not in ('off', 'false', '0'):
raise SystemExit('FAIL: MINIO_BROWSER is %r, expected off' % env.get('MINIO_BROWSER'))
networks = (minio.get('networks') or {})
if 'edge' in networks:
raise SystemExit('FAIL: minio is attached to the edge network')
probe = subprocess.run(
[
'docker', 'compose',
*(['--env-file', str(ROOT / '.env')] if (ROOT / '.env').is_file() else []),
'--profile', 'ops',
'run', '--rm', 'check-private-bucket',
],
cwd=str(ROOT),
check=False,
text=True,
)
if probe.returncode != 0:
raise SystemExit(probe.returncode)
print('PASS: minio has no host ports, console env is off, in-network GET is 403')
if __name__ == '__main__':
try:
main()
except subprocess.CalledProcessError as exc:
sys.stderr.write(exc.stderr or exc.stdout or str(exc))
raise SystemExit(exc.returncode)
+238
View File
@@ -0,0 +1,238 @@
#!/usr/bin/env python3
"""Concurrent attachment uploads with peak RSS of API containers.
Generates a valid PNG at runtime (not stored in Git). Measures docker stats while
N workers POST the same image. Writes a sanitized JSON summary.
"""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import platform
import subprocess
import sys
import threading
import time
import uuid
import zlib
from concurrent.futures import ThreadPoolExecutor, as_completed
from datetime import datetime, timezone
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure # noqa: E402
def make_png(width: int, height: int) -> bytes:
rows = []
for _y in range(height):
row = bytearray(1 + width * 3)
row[0] = 0
row[1:] = os.urandom(width * 3)
rows.append(bytes(row))
raw = b''.join(rows)
compressed = zlib.compress(raw, 1)
def chunk(tag: bytes, data: bytes) -> bytes:
crc = zlib.crc32(tag + data) & 0xffffffff
return len(data).to_bytes(4, 'big') + tag + data + crc.to_bytes(4, 'big')
ihdr = width.to_bytes(4, 'big') + height.to_bytes(4, 'big') + bytes([8, 2, 0, 0, 0])
return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', ihdr) + chunk(b'IDAT', compressed) + chunk(b'IEND', b'')
def parse_mib(usage: str) -> float:
# "45.23MiB / 256MiB" or "123.4MB / 256MB"
left = usage.split('/', 1)[0].strip()
number = ''
unit = ''
for char in left:
if char.isdigit() or char in '.':
number += char
else:
unit += char
value = float(number or '0')
unit = unit.strip().lower()
if unit in ('gib', 'gb'):
return value * 1024
if unit in ('kib', 'kb'):
return value / 1024
if unit in ('b',):
return value / (1024 * 1024)
return value
def git_commit() -> str:
try:
return subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD'], cwd=str(ROOT), text=True).strip()
except (OSError, subprocess.CalledProcessError):
return 'unknown'
def docker_stats() -> list:
try:
ids = subprocess.check_output(
['docker', 'ps', '-q', '--filter', 'name=messenger-lab4-api'],
cwd=str(ROOT),
text=True,
timeout=5,
).split()
if not ids:
return []
output = subprocess.check_output(
['docker', 'stats', '--no-stream', '--format', '{{.Name}}\t{{.MemUsage}}\t{{.MemPerc}}', *ids],
cwd=str(ROOT),
text=True,
timeout=8,
)
except (OSError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
return []
rows = []
for line in output.splitlines():
parts = line.split('\t')
if len(parts) < 2:
continue
name, usage = parts[0], parts[1]
rows.append({'name': name, 'mem_usage': usage, 'rss_mib': round(parse_mib(usage), 2)})
return rows
def main() -> None:
parser = argparse.ArgumentParser(description='Concurrent upload memory experiment')
parser.add_argument('--base-url', default=os.environ.get('BASE_URL', 'http://localhost:8080'))
parser.add_argument('--concurrency', type=int, default=10)
parser.add_argument('--width', type=int, default=900)
parser.add_argument('--height', type=int, default=700)
parser.add_argument('--output', default=str(ROOT / 'evidence' / 'upload-concurrency.json'))
args = parser.parse_args()
if args.concurrency < 10:
raise SystemExit('concurrency must be >= 10')
image = make_png(args.width, args.height)
size = len(image)
digest = hashlib.sha256(image).hexdigest()
client = Client(args.base_url, timeout=60)
alice, _bob, _eve, chat = client.bootstrap()
path = '/api/v1/chats/%s/attachments?filename=load.png' % chat['id']
stop = threading.Event()
samples = []
def watch():
while not stop.is_set():
snapshot = docker_stats()
if snapshot:
samples.append({'ts': time.time(), 'containers': snapshot})
stop.wait(0.05)
watcher = threading.Thread(target=watch, daemon=True)
watcher.start()
baseline = docker_stats()
if baseline:
samples.append({'ts': time.time(), 'containers': baseline, 'phase': 'baseline'})
started = time.monotonic()
latencies = []
errors = 0
def one(_index: int):
response = client.call(
'POST',
path,
201,
actor=alice,
raw=image,
headers={'Content-Type': 'image/png'},
schema='Attachment',
)
body = response['json']
if body.get('sha256') != digest or body.get('size_bytes') != size:
raise Failure('checksum mismatch on concurrent upload')
return response['elapsed']
try:
with ThreadPoolExecutor(max_workers=args.concurrency) as pool:
futs = [pool.submit(one, i) for i in range(args.concurrency)]
for fut in as_completed(futs):
try:
latencies.append(fut.result())
except Exception:
errors += 1
finally:
stop.set()
watcher.join(timeout=2)
elapsed = time.monotonic() - started
latencies.sort()
def pct(p):
if not latencies:
return None
index = min(len(latencies) - 1, max(0, int(round((p / 100) * (len(latencies) - 1)))))
return round(latencies[index], 4)
peak = 0.0
per_container = {}
for sample in samples:
for row in sample['containers']:
peak = max(peak, row['rss_mib'])
prev = per_container.get(row['name'], 0.0)
per_container[row['name']] = max(prev, row['rss_mib'])
naive_bound_mib = round((args.concurrency * size) / (1024 * 1024), 2)
summary = {
'hypothesis': (
'Ten concurrent ~%.1f MiB PNG uploads stay inside the 256 MiB API limit and '
'peak RSS is not proportional to N * file_size because the body is spooled, not held twice as bytes.'
% (size / (1024 * 1024))
),
'when': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'),
'commit': git_commit(),
'host': {
'system': platform.system(),
'machine': platform.machine(),
'processor': platform.processor(),
},
'compose_limits': {'api_memory': '256M', 'replicas': 2},
'profile': {
'concurrency': args.concurrency,
'width': args.width,
'height': args.height,
'size_bytes': size,
'sha256': digest,
},
'results': {
'ok': len(latencies),
'errors': errors,
'elapsed_s': round(elapsed, 3),
'p50_s': pct(50),
'p95_s': pct(95),
'p99_s': pct(99),
'peak_api_rss_mib': round(peak, 2),
'peak_rss_by_container_mib': per_container,
'samples': len(samples),
'naive_n_times_size_mib': naive_bound_mib,
},
'limits_of_measurement': (
'docker stats RSS is container-level and sampled ~200 ms; it is not a cgroup memory profiler. '
'Python heap is not separated from MinIO/HAProxy. Coordinated start of N POSTs from one client.'
),
}
out = Path(args.output)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(json.dumps(summary, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
print('ok=%s errors=%s peak_rss_mib=%s naive_N_x_size_mib=%s file=%s' % (
len(latencies), errors, summary['results']['peak_api_rss_mib'], naive_bound_mib, out,
))
if errors:
raise SystemExit(1)
if __name__ == '__main__':
try:
main()
except Failure as exc:
print('FAIL:', exc)
raise SystemExit(1)
+173
View File
@@ -0,0 +1,173 @@
#!/usr/bin/env python3
"""Student negative suite for lab4 attachments. Public smoke.py is not modified."""
import http.client
import json
import os
import struct
import uuid
import zlib
from urllib.parse import urlparse
from client import Client, Failure, arguments, check, run, shape
MAX_UPLOAD_BYTES = 10_485_760
ROOT = os.path.dirname(os.path.abspath(__file__))
def png_header(width, height):
ihdr = struct.pack('>IIBBBBB', width, height, 8, 2, 0, 0, 0)
data = ihdr
crc = zlib.crc32(b'IHDR' + data) & 0xffffffff
chunk = struct.pack('>I', len(data)) + b'IHDR' + data + struct.pack('>I', crc)
return b'\x89PNG\r\n\x1a\n' + chunk
def error_payload(status, headers, body, where):
check(status != 500, where + ' returned 500 for a client error')
check(bool(headers.get('X-Request-Id')), where + ': missing X-Request-Id')
content_type = headers.get_content_type() if hasattr(headers, 'get_content_type') else (headers.get('Content-Type') or '').split(';', 1)[0].strip().lower()
check(content_type == 'application/json', where + ': expected JSON error')
try:
payload = json.loads(body)
except (ValueError, UnicodeError):
raise Failure(where + ': invalid error JSON') from None
shape(payload, 'Error')
check(payload['error']['request_id'] == headers.get('X-Request-Id'), where + ': request_id mismatch')
return payload
def raw_post(base, path, headers, body, extra_headers=None, chunked=False):
parsed = urlparse(base)
conn = http.client.HTTPConnection(parsed.hostname, parsed.port or 80, timeout=60)
try:
hdrs = dict(headers)
if extra_headers:
hdrs.update(extra_headers)
conn.putrequest('POST', path)
if chunked:
hdrs.pop('Content-Length', None)
for name, value in hdrs.items():
conn.putheader(name, value)
conn.putheader('Transfer-Encoding', 'chunked')
conn.endheaders()
if isinstance(body, (bytes, bytearray)):
pieces = [bytes(body)]
else:
pieces = body
for piece in pieces:
conn.send(('%x\r\n' % len(piece)).encode('ascii') + piece + b'\r\n')
conn.send(b'0\r\n\r\n')
else:
payload = body if isinstance(body, (bytes, bytearray)) else b''
if not any(name.lower() == 'content-length' for name in hdrs):
hdrs['Content-Length'] = str(len(payload))
for name, value in hdrs.items():
conn.putheader(name, value)
conn.endheaders()
if payload:
conn.send(payload)
response = conn.getresponse()
data = response.read(1024 * 1024)
hdr = response.headers
return response.status, hdr, data
finally:
conn.close()
def expect_error(c, actor, chat, *, filename='photo.png', content_type='image/png', body=b'', status=None, extra_headers=None, chunked=False, pieces=None, where='upload'):
path = '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], filename)
headers = {
'Authorization': 'Bearer ' + actor['token'],
'Content-Type': content_type,
'Accept': 'application/json',
}
payload_body = pieces if chunked and pieces is not None else body
code, hdr, data = raw_post(c.base, path, headers, payload_body, extra_headers=extra_headers, chunked=chunked)
payload = error_payload(code, hdr, data, where)
if status is not None:
check(code == status, '%s: expected %s, received %s (%s)' % (where, status, code, payload['error']['code']))
return code, payload
def main():
args = arguments('Lab4 attachment negative cases')
c = Client(args.base_url, args.ca_file, timeout=60)
alice, bob, eve, chat = c.bootstrap()
sample = open(os.path.join(ROOT, 'fixtures', 'sample.png'), 'rb').read()
code, payload = expect_error(
c, alice, chat,
extra_headers={'Content-Length': str(MAX_UPLOAD_BYTES + 1)},
body=b'x',
status=413,
where='oversized Content-Length',
)
check(payload['error']['code'] == 'payload_too_large', 'oversized Content-Length: wrong code')
header = png_header(32, 32)
remain = MAX_UPLOAD_BYTES + 1 - len(header)
chunk = b'\x00' * 65536
pieces = [header]
sent = len(header)
while sent < len(header) + remain:
take = min(len(chunk), len(header) + remain - sent)
pieces.append(chunk[:take])
sent += take
code, payload = expect_error(
c, alice, chat,
chunked=True,
pieces=pieces,
status=413,
where='oversized chunked body',
)
check(payload['error']['code'] == 'payload_too_large', 'oversized chunked body: wrong code')
expect_error(c, alice, chat, body=b'\x89PNG\r\n\x1a\n\x00\x00\x00\x0dnotH', status=415, where='corrupt PNG')
expect_error(c, alice, chat, body=b'\xff\xd8\xff\xe0\x00', status=415, where='truncated JPEG')
expect_error(c, alice, chat, body=b'GIF89a-not-an-image', status=415, where='foreign format')
code, payload = expect_error(
c, alice, chat,
content_type='image/jpeg',
body=sample,
status=415,
where='MIME spoof',
)
check(payload['error']['code'] == 'unsupported_media_type', 'MIME spoof: wrong code')
bomb = png_header(10000, 5000)
code, payload = expect_error(c, alice, chat, body=bomb, status=413, where='pixel bomb')
check(payload['error']['code'] == 'payload_too_large', 'pixel bomb: wrong code')
att, _content = c.attachment(alice, chat)
for suffix in ('', '/content'):
unknown = c.call('GET', '/api/v1/attachments/' + str(uuid.uuid4()) + suffix, 404, actor=alice)
check(unknown['json']['error']['code'] == 'not_found', 'random id: wrong code')
check(unknown['status'] != 500, 'random id returned 500')
foreign = c.call('GET', '/api/v1/attachments/' + att['id'] + suffix, 404, actor=eve)
check(foreign['json']['error']['code'] == 'not_found', 'outsider: wrong code')
other = c.call(
'POST',
'/api/v1/chats',
201,
actor=alice,
body={'title': 'Чужой чат', 'member_ids': [alice['id']]},
schema='Chat',
)['json']
linked = c.call(
'POST',
'/api/v1/chats/' + other['id'] + '/messages',
404,
actor=alice,
body={'text': '', 'attachment_ids': [att['id']]},
headers={'Idempotency-Key': uuid.uuid4().hex},
)
check(linked['json']['error']['code'] == 'not_found', 'cross-chat attach: wrong code')
check(linked['status'] != 500, 'cross-chat attach returned 500')
print('PASS: lab4 attachment negative cases (413/415/404, never 500)')
if __name__ == '__main__':
run(main)