From 9347fe35ae9c5166d6085f41dff900965c7f88bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=B0=D0=BC=D0=BE=D1=85=D0=B2=D0=B0=D0=BB=D0=BE?= =?UTF-8?q?=D0=B2=20=D0=90=D0=BD=D0=B4=D1=80=D0=B5=D0=B9=20=D0=A0=D0=B5?= =?UTF-8?q?=D0=BC=D0=BE=D0=B2=D0=B8=D1=87?= Date: Fri, 2 Oct 2026 14:00:53 +0300 Subject: [PATCH] feat: Authorize attachment reads and message links (U4) --- REPORT.md | 18 +++--- evidence/attachment-access-2026-10-02.txt | 25 ++++++++ scripts/restart.sh | 2 +- src/api.py | 13 ++++ src/attachment_read.py | 54 ++++++++++++++++ src/models.py | 21 ++++--- src/store.py | 40 +++++++++--- student-tests/test_attachment_access.py | 75 +++++++++++++++++++++++ student-tests/test_attachment_failover.py | 58 ++++++++++++++++++ 9 files changed, 282 insertions(+), 24 deletions(-) create mode 100644 evidence/attachment-access-2026-10-02.txt create mode 100644 src/attachment_read.py create mode 100644 student-tests/test_attachment_access.py create mode 100644 student-tests/test_attachment_failover.py diff --git a/REPORT.md b/REPORT.md index 2b0a83ef..97a830d6 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,7 +1,7 @@ # Отчёт — лабораторная 4 - Автор, группа: Самохвалов Андрей Ремович, БПИ-2302. -- Целевая оценка: 5, трек 2 «Согласованность двух хранилищ». Реализованы перенос lab3, приватное S3 и ограниченный синхронный upload; download, связь с сообщением и reconciler выполняются далее. +- Целевая оценка: 5, трек 2 «Согласованность двух хранилищ». Перенос lab3, приватное S3, синхронный upload, доступ к вложениям и связь с сообщениями проверены; 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 — после реализации download/связи с сообщением в следующем блоке +make test ``` `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`. @@ -24,7 +24,7 @@ make check ## Архитектура и решения -Клиент → HAProxy → две API-реплики. PostgreSQL хранит пользователей, сессии, чаты, сообщения, ключи идемпотентности и метаданные вложений. MinIO хранит только байты оригиналов в private bucket `messenger-attachments`; локальная файловая система API не хранит оригиналы. Миграция `004_attachments.sql` связывает вложение с чатом; состав сообщения хранится в `message_attachments` с FK по паре `(id, chat_id)`, чтобы исключить межчатовые ссылки на уровне БД. Статусы таблицы допускают дальнейший переход к асинхронной lab5, но lab4 будет возвращать только `ready` после обеих устойчивых записей. +Клиент → HAProxy → две API-реплики. PostgreSQL хранит пользователей, сессии, чаты, сообщения, ключи идемпотентности и метаданные вложений. MinIO хранит только байты оригиналов в private bucket `messenger-attachments`; локальная файловая система API не хранит оригиналы. Миграция `004_attachments.sql` связывает вложение с чатом; `005_attachment_owner.sql` добавляет владельца и время обновления по OpenAPI. Состав сообщения хранится в `message_attachments` с FK по паре `(id, chat_id)`, чтобы исключить межчатовые ссылки на уровне БД. Статусы таблицы допускают дальнейший переход к асинхронной lab5, но lab4 возвращает только `ready` после обеих устойчивых записей. | Сервис | Образ/роль | Health и volume | Секреты и доступ | | --- | --- | --- | --- | @@ -36,21 +36,25 @@ 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 проверяет его до чтения тела, metadata/content — до доступа к S3. Публичный ответ не содержит object key, endpoint и credentials. 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. +POST сообщения принимает до 10 уникальных ID из этого чата, включая пустой текст с вложением. Проверка вложений, запись сообщения, связей и результата идемпотентности выполняются в одной транзакции; порядок ID сохраняется. Повтор ключа с тем же содержимым возвращает прежний Message. `GET` metadata и content сначала проверяют действующую сессию и членство в чате; неизвестный и чужой ID одинаково дают 404. Исходник отдаётся потоково через API, отсутствующий вариант — 404, недоступный S3-объект — 503. + ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Доказательство | | --- | --- | --- | --- | | Перенос 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` | +| Миграция и транзакции | `docker compose exec -T api python - < student-tests/test_database.py`; `... test_auth.py` | Миграции 1–5 применены повторяемо, 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` | +| Промежуток 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` | +| Сообщения, ACL и скачивание | `python3 -m unittest discover -s student-tests -p test_attachment_access.py -v`; `make test BASE_URL=http://127.0.0.1:8084` | 3 собственных теста OK; публичный сценарий PASS; link/replay и bytes на обеих репликах, чужой объект 404 | `evidence/attachment-access-2026-10-02.txt` | +| Сохранность S3 и отказ API | `make test-persistence ... ACTION_SCRIPT=scripts/restart.sh`; `make test-failover ... ACTION_SCRIPT=scripts/stop-one.sh`; `python3 student-tests/test_attachment_failover.py` | Токен, Message, metadata и bytes пережили restart API/DB/S3; публичный failover восстановил запись за 2,826 и 3,020 с; адресный тест остановил каждую загрузившую реплику и скачал те же bytes через другую | `evidence/attachment-access-2026-10-02.txt` | ## Эксперименты и отказы @@ -58,4 +62,4 @@ Upload читает raw body в `SpooledTemporaryFile` с порогом RAM 1 M ## Ограничения и следующие шаги -Полный `make test` пока останавливается на последующих маршрутах attachment metadata/content и привязке к сообщению; U4 реализует их отдельно. Проверки уровня 4 и трека 5 не заявляются завершёнными до повторяемой сверки. Один MinIO/PostgreSQL/LB и один Docker-host остаются одиночными точками отказа. Локальный HTTP допустим только для изолированного стенда с синтетическими данными; удалённой демонстрации нужен TLS. +Публичный `make test` проходит; он не доказывает все отказные сценарии. Проверки уровня 4 и трека 5 не заявляются завершёнными до повторяемой сверки. Один MinIO/PostgreSQL/LB и один Docker-host остаются одиночными точками отказа. Локальный HTTP допустим только для изолированного стенда с синтетическими данными; удалённой демонстрации нужен TLS. diff --git a/evidence/attachment-access-2026-10-02.txt b/evidence/attachment-access-2026-10-02.txt new file mode 100644 index 00000000..1d4e574f --- /dev/null +++ b/evidence/attachment-access-2026-10-02.txt @@ -0,0 +1,25 @@ +Lab4 U4 local verification, 2026-10-02, Colima arm64, APP_PORT=8084. +Synthetic data only; no tokens, passwords, object keys or image bodies recorded. + +docker compose -f compose.yaml -f compose.local.yaml --env-file .env up -d --build --wait --scale api=2 +Result: postgres/s3/lb and both API replicas healthy; migrate/bootstrap one-shots exited 0. + +BASE_URL=http://127.0.0.1:8084 python3 -m unittest discover -s student-tests -p test_attachment_access.py -v +Result: 3 tests OK: message link/replay, ACL and invalid links, bytes served by both replicas. + +make test BASE_URL=http://127.0.0.1:8084 +Result: PASS lab4 public API scenario. + +make test-persistence BASE_URL=http://127.0.0.1:8084 ACTION_SCRIPT=scripts/restart.sh +Result: PASS; hook stopped API, LB, PostgreSQL and S3, then restarted without removing volumes. +Existing token, confirmed message, attachment metadata and original bytes survived. + +make test-failover BASE_URL=http://127.0.0.1:8084 ACTION_SCRIPT=scripts/stop-one.sh +Result, run 1: two instances observed; 112 confirmed writes, 1 failed attempt, +first recovery 2.826 seconds; existing token/message/original preserved. +Result, run 2 after restore: two instances observed; 113 confirmed writes, +1 failed attempt, first recovery 3.020 seconds; existing token/message/original preserved. + +BASE_URL=http://127.0.0.1:8084 python3 student-tests/test_attachment_failover.py +Result: stopped each of the two distinct replicas after it accepted an upload; +the other replica served byte-identical original; both were restored between runs. diff --git a/scripts/restart.sh b/scripts/restart.sh index c9148ca0..3e7912fb 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -1,5 +1,5 @@ #!/bin/sh set -eu cd "$(dirname "$0")/.." -docker compose --env-file .env stop api lb postgres +docker compose --env-file .env stop api lb postgres s3 docker compose --env-file .env up -d --wait --scale api=2 diff --git a/src/api.py b/src/api.py index cef93bdd..c8776edf 100644 --- a/src/api.py +++ b/src/api.py @@ -7,6 +7,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query, Request, Response from .auth import basic_credentials, bearer_token from .attachments import storage_ready, upload +from .attachment_read import download, get_view from .models import CreateChat, CreateMessage, CreateUser from .store import store @@ -86,6 +87,18 @@ async def upload_attachment(chat_id: UUID, request: Request, filename: str = Que return await upload(request, str(chat_id), actor["id"], filename) +@router.get("/api/v1/attachments/{attachment_id}") +def get_attachment(attachment_id: UUID, actor: dict = Depends(current_user)): + return get_view(actor["id"], attachment_id) + + +@router.get("/api/v1/attachments/{attachment_id}/content") +def get_attachment_content( + attachment_id: UUID, variant: str = Query("original"), actor: dict = Depends(current_user) +): + return download(actor["id"], attachment_id, variant) + + @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") diff --git a/src/attachment_read.py b/src/attachment_read.py new file mode 100644 index 00000000..2171b3e8 --- /dev/null +++ b/src/attachment_read.py @@ -0,0 +1,54 @@ +"""Authorize metadata and stream originals from the private bucket.""" + +import logging +from uuid import UUID + +from fastapi import HTTPException +from fastapi.responses import StreamingResponse + +from .attachments import BUCKET, attachment_view, storage +from .store import connection + + +logger = logging.getLogger(__name__) + + +def metadata(actor_id: str, attachment_id: UUID) -> dict: + with connection() as conn: + row = conn.execute( + "SELECT a.* FROM attachments a " + "JOIN memberships m ON m.chat_id=a.chat_id " + "WHERE a.id=%s AND m.user_id=%s", + (attachment_id, UUID(actor_id)), + ).fetchone() + if row is None: + raise HTTPException(404) + return row + + +def download(actor_id: str, attachment_id: UUID, variant: str) -> StreamingResponse: + row = metadata(actor_id, attachment_id) + if row["status"] != "ready": + raise HTTPException(409) + if variant != "original": + raise HTTPException(404) + try: + obj = storage().get_object(BUCKET, row["object_key"]) + except Exception as exc: + logger.warning("S3 read failed for attachment %s (%s)", attachment_id, type(exc).__name__) + raise HTTPException(503) from None + + def chunks(): + try: + yield from obj.stream(64 * 1024) + finally: + obj.close() + obj.release_conn() + + return StreamingResponse( + chunks(), media_type=row["content_type"], headers={"Content-Length": str(row["size_bytes"])} + ) + + +def get_view(actor_id: str, attachment_id: UUID) -> dict: + return attachment_view(metadata(actor_id, attachment_id)) diff --git a/src/models.py b/src/models.py index 7ee9ec7c..06b16beb 100644 --- a/src/models.py +++ b/src/models.py @@ -2,7 +2,7 @@ from uuid import UUID -from pydantic import BaseModel, ConfigDict, Field, field_validator +from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator class StrictBody(BaseModel): @@ -50,12 +50,19 @@ class CreateChat(StrictBody): class CreateMessage(StrictBody): - text: str = Field(min_length=1, max_length=4000) + text: str = Field(max_length=4000) attachment_ids: list[str] = Field(default_factory=list, max_length=10) - @field_validator("text") + @field_validator("attachment_ids") @classmethod - def nonblank_text(cls, value: str) -> str: - if not value.strip(): - raise ValueError("blank text") - return value + def valid_attachments(cls, value: list[str]) -> list[str]: + ids = [str(UUID(item)) for item in value] + if len(set(ids)) != len(ids): + raise ValueError("duplicate attachment") + return ids + + @model_validator(mode="after") + def text_or_attachment(self): + if not self.text.strip() and not self.attachment_ids: + raise ValueError("message needs text or attachment") + return self diff --git a/src/store.py b/src/store.py index fa918d26..298109a7 100644 --- a/src/store.py +++ b/src/store.py @@ -80,13 +80,17 @@ def message_view(row: dict) -> dict: "id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": row["text"], "created_at": timestamp(row["created_at"]), - "attachment_ids": [], + "attachment_ids": [str(attachment_id) for attachment_id in row.get("attachment_ids", [])], } CHAT_COLUMNS = """c.id, c.title, c.created_at, ARRAY(SELECT m.user_id FROM memberships m WHERE m.chat_id=c.id ORDER BY m.position) AS member_ids""" +MESSAGE_COLUMNS = """m.id, m.chat_id, m.sender_id, m.text, m.created_at, + ARRAY(SELECT a.attachment_id FROM message_attachments a + WHERE a.message_id=m.id ORDER BY a.position) AS attachment_ids""" + class Store: def ready(self) -> dict: @@ -208,10 +212,13 @@ class Store: return {"items": items, "next_cursor": encode_cursor(f"chats:{actor_id}", items[-1]) if len(rows) > limit else None} def create_message(self, actor_id: str, chat_id: str, text: str, key: str, attachment_ids: list[str] | None = None) -> dict: - if attachment_ids: - raise HTTPException(404) + ids = [UUID(item) for item in attachment_ids or []] + if len(ids) > 10 or len(set(ids)) != len(ids) or (not text.strip() and not ids): + raise HTTPException(400) chat_uuid, actor_uuid = UUID(chat_id), UUID(actor_id) - request_hash = hashlib.sha256(json.dumps({"text": text, "attachment_ids": []}, ensure_ascii=False, sort_keys=True).encode()).digest() + request_hash = hashlib.sha256(json.dumps( + {"text": text, "attachment_ids": [str(item) for item in ids]}, ensure_ascii=False, sort_keys=True, + ).encode()).digest() with connection() as conn: member = conn.execute( "SELECT 1 FROM memberships WHERE chat_id=%s AND user_id=%s", (chat_uuid, actor_uuid) @@ -230,7 +237,7 @@ class Store: ).fetchone() if reserved is None: replay = conn.execute( - "SELECT r.request_hash,m.id,m.chat_id,m.sender_id,m.text,m.created_at " + f"SELECT r.request_hash,{MESSAGE_COLUMNS} " "FROM message_replays r JOIN messages m ON m.id=r.message_id " "WHERE r.user_id=%s AND r.chat_id=%s AND r.request_key=%s", (actor_uuid, chat_uuid, key), @@ -240,26 +247,41 @@ class Store: if replay["request_hash"] != request_hash: raise HTTPException(409) return message_view(replay) + if ids: + attachments = conn.execute( + "SELECT id,status FROM attachments WHERE chat_id=%s AND id=ANY(%s)", + (chat_uuid, ids), + ).fetchall() + if len(attachments) != len(ids): + raise HTTPException(404) + if any(item["status"] == "failed" for item in attachments): + raise HTTPException(409) row = conn.execute( "INSERT INTO messages (id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) " "RETURNING id,chat_id,sender_id,text,created_at", (uuid4(), chat_uuid, actor_uuid, text), ).fetchone() + for position, attachment_id in enumerate(ids): + conn.execute( + "INSERT INTO message_attachments (message_id,chat_id,attachment_id,position) " + "VALUES (%s,%s,%s,%s)", + (row["id"], chat_uuid, attachment_id, position), + ) conn.execute( "UPDATE message_replays SET message_id=%s WHERE user_id=%s AND chat_id=%s AND request_key=%s", (row["id"], actor_uuid, chat_uuid, key), ) - return message_view(row) + return message_view({**row, "attachment_ids": ids}) def list_messages(self, actor_id: str, chat_id: str, limit: int, cursor: str | None) -> dict: after = decode_cursor(cursor, f"messages:{chat_id}") chat_uuid, actor_uuid = UUID(chat_id), UUID(actor_id) - query = "SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s" + query = f"SELECT {MESSAGE_COLUMNS} FROM messages m WHERE m.chat_id=%s" params = [chat_uuid] if after: - query += " AND (created_at,id)>(%s,%s)" + query += " AND (m.created_at,m.id)>(%s,%s)" params.extend(after) - query += " ORDER BY created_at,id LIMIT %s" + query += " ORDER BY m.created_at,m.id LIMIT %s" params.append(limit + 1) with connection() as conn: member = conn.execute( diff --git a/student-tests/test_attachment_access.py b/student-tests/test_attachment_access.py new file mode 100644 index 00000000..00bca6cc --- /dev/null +++ b/student-tests/test_attachment_access.py @@ -0,0 +1,75 @@ +"""Black-box attachment ACL, message links and idempotency on a running lab4 stack.""" + +import sys +import unittest +from pathlib import Path +from uuid import uuid4 + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests")) +from client import Client + + +class AttachmentAccessTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.client = Client() + cls.alice, cls.bob, cls.eve, cls.chat = cls.client.bootstrap() + cls.other_chat = cls.client.call( + "POST", "/api/v1/chats", 201, actor=cls.alice, + body={"title": "Other", "member_ids": [cls.alice["id"], cls.bob["id"]]}, schema="Chat", + )["json"] + cls.attachment, cls.content = cls.client.attachment(cls.alice, cls.chat) + cls.other_attachment, _ = cls.client.attachment(cls.alice, cls.other_chat) + + def test_message_links_and_replay(self): + key = uuid4().hex + path = f"/api/v1/chats/{self.chat['id']}/messages" + body = {"text": "", "attachment_ids": [self.attachment["id"]]} + first = self.client.call("POST", path, 201, body=body, actor=self.bob, + headers={"Idempotency-Key": key}, schema="Message")["json"] + same = self.client.call("POST", path, 201, body={"attachment_ids": body["attachment_ids"], "text": ""}, + actor=self.bob, headers={"Idempotency-Key": key}, schema="Message")["json"] + self.assertEqual(first, same) + self.assertEqual(first["attachment_ids"], [self.attachment["id"]]) + items = self.client.call("GET", path, actor=self.alice, schema="MessagePage")["json"]["items"] + self.assertEqual([item["id"] for item in items].count(first["id"]), 1) + self.client.call("POST", path, 409, body={"text": "changed", "attachment_ids": body["attachment_ids"]}, + actor=self.bob, headers={"Idempotency-Key": key}) + + def test_access_and_invalid_links(self): + attachment_path = f"/api/v1/attachments/{self.attachment['id']}" + metadata = self.client.call("GET", attachment_path, actor=self.bob, schema="Attachment")["json"] + self.assertEqual(metadata["id"], self.attachment["id"]) + self.assertNotIn("object_key", metadata) + self.assertNotIn("s3", str(metadata).lower()) + self.assertEqual(self.client.call("GET", attachment_path + "/content", actor=self.bob)["bytes"], self.content) + self.client.call("GET", attachment_path + "/content?variant=thumbnail", 404, actor=self.bob) + for suffix in ("", "/content"): + self.client.call("GET", attachment_path + suffix, 401) + for suffix in ("", "/content"): + self.client.call("GET", attachment_path + suffix, 404, actor=self.eve) + path = f"/api/v1/chats/{self.chat['id']}/messages" + for attachment_id in (str(uuid4()), self.other_attachment["id"]): + self.client.call("POST", path, 404, actor=self.alice, + body={"text": "", "attachment_ids": [attachment_id]}, + headers={"Idempotency-Key": uuid4().hex}) + self.client.call("POST", path, 400, actor=self.alice, body={"text": ""}, + headers={"Idempotency-Key": uuid4().hex}) + self.client.call("POST", path, 400, actor=self.alice, + body={"text": "", "attachment_ids": [self.attachment["id"]] * 2}, + headers={"Idempotency-Key": uuid4().hex}) + + def test_other_replica_reads_same_bytes(self): + path = f"/api/v1/attachments/{self.attachment['id']}/content" + seen = set() + for _ in range(20): + result = self.client.call("GET", path, actor=self.bob) + self.assertEqual(result["bytes"], self.content) + seen.add(result["headers"]["X-Instance-Id"]) + if len(seen) >= 2: + break + self.assertGreaterEqual(len(seen), 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_attachment_failover.py b/student-tests/test_attachment_failover.py new file mode 100644 index 00000000..ce87077e --- /dev/null +++ b/student-tests/test_attachment_failover.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python3 +"""Stop the replica that accepted an upload, then read its bytes elsewhere.""" + +import json +import os +from pathlib import Path +import subprocess +import sys +import time + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) +from client import Client, Failure # noqa: E402 + + +def main(): + client = Client(timeout=2) + alice, bob, _, chat = client.bootstrap() + original = (ROOT / "tests/fixtures/sample.png").read_bytes() + observed = {client.call("GET", "/api/v1/users/me", actor=bob)["headers"]["X-Instance-Id"] for _ in range(30)} + if len(observed) != 2: + raise Failure("two API replicas were not observed before stop") + for target in sorted(observed): + for _ in range(10): + result = client.call( + "POST", f"/api/v1/chats/{chat['id']}/attachments?filename=sample.png", 201, + actor=alice, raw=original, headers={"Content-Type": "image/png"}, schema="Attachment", + ) + if result["headers"]["X-Instance-Id"] == target: + break + else: + raise Failure("upload did not reach the selected replica") + attachment_id = result["json"]["id"] + env = {**os.environ, "TARGET_INSTANCE_ID": target} + try: + subprocess.run([str(ROOT / "scripts/stop-one.sh")], cwd=ROOT, env=env, check=True) + deadline = time.monotonic() + 10 + while True: + try: + read = client.call("GET", f"/api/v1/attachments/{attachment_id}/content", actor=bob) + if read["headers"]["X-Instance-Id"] == target: + raise Failure("stopped replica still answered") + if read["bytes"] != original: + raise Failure("attachment bytes changed after replica stop") + break + except Failure: + if time.monotonic() >= deadline: + raise + time.sleep(0.2) + finally: + subprocess.run(["docker", "compose", "--env-file", ".env", "up", "-d", "--wait", "--scale", "api=2"], + cwd=ROOT, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + print(json.dumps({"stopped_upload_replicas": len(observed), "download_on_other_replica": True, + "bytes_equal": True}, sort_keys=True)) + + +if __name__ == "__main__": + main()