From 4ea6924db197bf6fb09fd4167a66b65d9d298b7d Mon Sep 17 00:00:00 2001 From: Alexey Bodanyuk <144894236+wfa22@users.noreply.github.com> Date: Sun, 25 Oct 2026 14:21:43 +0300 Subject: [PATCH] =?UTF-8?q?lab4:=20=D0=BF=D0=B0=D0=BC=D1=8F=D1=82=D1=8C=20?= =?UTF-8?q?=D0=B7=D0=B0=D0=B3=D1=80=D1=83=D0=B7=D0=BE=D0=BA=20=D0=B8=20S3?= =?UTF-8?q?=20=D0=BF=D0=BE=D0=B4=20=D0=BB=D0=B8=D0=BC=D0=B8=D1=82=D0=BE?= =?UTF-8?q?=D0=BC,=20=D0=B4=D0=BE=D0=BA=D1=83=D0=BC=D0=B5=D0=BD=D1=82?= =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8F=20=D0=B7=D0=B0=D1=89=D0=B8=D1=82=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - тело загрузки: один буфер ровно Content-Length, без копий до S3 и djpeg; - PNG: zlib получает вход кусками по 64 KiB (unconsumed_tail копировал остаток IDAT); - djpeg, убитый OOM-killer'ом, -> 503 (ресурсы сервера), а не 415; - api: memswap_limit = memory (жёсткий лимит без swap); S3: GOMEMLIMIT и лимиты одновременных загрузок SeaweedFS, память 1g; - docs: CONSISTENCY.md, DEFENSE.md, WINDOWS.md, DATA_MODEL.md под lab4; scripts/demo_attachments.py для сценария защиты; CI и collect_evidence под lab4; - bench/reconcile_faults.py: отчёты трека 2 (ошибки с обеих сторон, прерванный apply). Co-Authored-By: Claude Opus 5.5 --- .env.example | 2 +- .github/workflows/app.yml | 10 +- bench/reconcile_faults.py | 174 ++++++++++++++++++++++++++++++++++ bench/upload_memory.py | 43 +++++++-- compose.yaml | 7 +- docs/CONSISTENCY.md | 73 ++++++++++++++ docs/DATA_MODEL.md | 8 +- docs/DEFENSE.md | 39 ++++++++ docs/WINDOWS.md | 116 ++++++++++------------- evidence/test-failover.txt | 93 ++++++++++++++++++ evidence/test-persistence.txt | 19 ++++ infra/seaweedfs/start.sh | 9 +- scripts/collect_evidence.py | 19 ++-- scripts/demo_attachments.py | 126 ++++++++++++++++++++++++ src/messenger/app.py | 4 +- src/messenger/attachments.py | 44 ++++++--- src/messenger/images.py | 33 ++++--- src/messenger/storage.py | 2 +- 18 files changed, 701 insertions(+), 120 deletions(-) create mode 100644 bench/reconcile_faults.py create mode 100644 docs/CONSISTENCY.md create mode 100644 docs/DEFENSE.md create mode 100644 evidence/test-failover.txt create mode 100644 evidence/test-persistence.txt create mode 100644 scripts/demo_attachments.py diff --git a/.env.example b/.env.example index b05a114e..f6143d63 100644 --- a/.env.example +++ b/.env.example @@ -55,7 +55,7 @@ SHUTDOWN_TIMEOUT_SECONDS=8 API_CPUS=1.0 API_MEMORY=512m S3_CPUS=1.0 -S3_MEMORY=512m +S3_MEMORY=1g PG_CPUS=2.0 PG_MEMORY=1g VALKEY_CPUS=0.5 diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml index c13c7dd2..c838522c 100644 --- a/.github/workflows/app.yml +++ b/.github/workflows/app.yml @@ -1,4 +1,4 @@ -name: Application (lab3) +name: Application (lab4) on: [push, pull_request] permissions: contents: read @@ -13,16 +13,18 @@ jobs: python-version: '3.13' - name: Synthetic secrets and env (CI only, never committed) run: python scripts/init_secrets.py && cp .env.example .env - - name: Build, migrate once, start 2 API replicas behind HAProxy, wait for healthy + - name: Build, migrate once, bootstrap the S3 bucket, start 2 API replicas behind HAProxy run: docker compose --env-file .env up -d --build --wait - name: Contract and public smoke run: make check test PYTHON=python - - name: Persistence across restart of LB, API replicas and stores + - name: Persistence across restart of LB, API replicas, PostgreSQL, Valkey and S3 run: make test-persistence ACTION_SCRIPT=scripts/restart.sh PYTHON=python - name: Failover of the replica that served the test, then restore it run: | make test-failover ACTION_SCRIPT=scripts/stop-one.sh PYTHON=python sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 + - name: Reconciler (track 2) dry-run on the stand - read-only report + run: docker compose run --rm reconciler - name: Own tests (unit + stand; every failure is restored in finally) run: | python -m pip install --require-hashes --no-deps -r requirements.txt @@ -30,7 +32,7 @@ jobs: make student-test PYTHON=python - name: Logs if: always() - run: docker compose logs --tail 100 api lb + run: docker compose logs --tail 100 api lb s3 s3-init - name: Remove CI stand and its synthetic data if: always() run: docker compose down -v diff --git a/bench/reconcile_faults.py b/bench/reconcile_faults.py new file mode 100644 index 00000000..4c418125 --- /dev/null +++ b/bench/reconcile_faults.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Track 2 evidence: inject faults on both sides, run the reconciler, keep every JSON report. + +Scenario A (all fault kinds; the same as student-tests/test_reconcile.py, but the reports are saved): + S3 side: old orphan objects, object deleted under a USED ready row, object truncated under an + unused ready row, same-size corruption (found only with --verify-checksums); + DB side: stale intents (with / without object), quarantine mark on a healthy row; + fresh: orphan + intent younger than --grace. + Runs: dry-run (+ snapshot of both stores before/after) -> apply -> apply again -> restore of the + lost object from a "backup" -> apply (quarantine lifted). +Scenario B (interrupted apply): 400 old orphans, S3 is paused while --apply deletes them -> + the run stops with an error, nothing else is damaged; the next run finishes the rest; the + third run finds nothing. + + python bench/reconcile_faults.py --output evidence/reconcile +""" +from __future__ import annotations + +import argparse +import json +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "student-tests")) +import imagegen # noqa: E402 +from conftest import (Api, attachment_row, compose, findings_by_key, psql, s3_delete, s3_exec, s3_keys, # noqa: E402 + s3_put) +from test_reconcile import insert_intent, snapshot # noqa: E402 + +GRACE = ["--grace", "30", "--allow-small-grace"] +SAMPLE = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes() + + +def reconcile(*args: str) -> tuple[int, dict]: + r = compose("run", "--rm", "--no-deps", "-T", "reconciler", "--samples", "1000", *args, check=False, timeout=600) + return r.returncode, json.loads(r.stdout) + + +def save(out: Path, name: str, data) -> None: + (out / name).write_text(json.dumps(data, ensure_ascii=False, indent=1), encoding="utf-8") + + +def ours(report: dict, keys: dict[str, str]) -> dict: + """The findings of this scenario's keys only (the stand also holds other test data).""" + f = findings_by_key(report) + return {label: ({"kind": f[k]["kind"], "result": f[k]["result"], "used": f[k]["used"]} if k in f else None) + for label, k in keys.items()} + + +def scenario_a(out: Path) -> dict: + api = Api() + alice, bob = api.user("alice"), api.user("bob") + chat = api.chat(alice, bob) + up = {n: api.upload(alice, chat, imagegen.png(40 + i, 30)).json() for i, n in enumerate("ABCDEF")} + data = {n: api.call("GET", f"/api/v1/attachments/{a['id']}/content", 200, token=alice["token"]).content + for n, a in up.items()} + key = {n: attachment_row(a["id"])["object_key"] for n, a in up.items()} + api.post_message(alice, chat, {"text": "used", "attachment_ids": [up["A"]["id"], up["C"]["id"], up["E"]["id"]]}) + keys = {"healthy used A": key["A"], "healthy unused B": key["B"], "used, object deleted C": key["C"], + "unused, object truncated D": key["D"], "quarantined but healthy E": key["E"], + "same-size corruption F": key["F"]} + orphan = "o/" + uuid.uuid4().hex + stale_with, stale_without = "o/" + uuid.uuid4().hex, "o/" + uuid.uuid4().hex + s3_put(orphan, SAMPLE) + s3_put(stale_with, SAMPLE) + insert_intent(chat, alice, stale_with, SAMPLE, 600) + insert_intent(chat, alice, stale_without, SAMPLE, 600) + s3_delete(key["C"]) + s3_put(key["D"], data["D"][: len(data["D"]) // 2]) + s3_put(key["F"], data["F"][:200] + bytes([data["F"][200] ^ 1]) + data["F"][201:]) + psql(f"UPDATE attachments SET lost_at = clock_timestamp(), lost_reason = 'missing_object' WHERE id = '{up['E']['id']}'") + keys.update({"old orphan object": orphan, "stale intent + object": stale_with, "stale intent, no object": stale_without}) + time.sleep(32) + fresh_orphan, fresh_intent = "o/" + uuid.uuid4().hex, "o/" + uuid.uuid4().hex + s3_put(fresh_orphan, SAMPLE) + s3_put(fresh_intent, SAMPLE) + insert_intent(chat, alice, fresh_intent, SAMPLE, 0) + keys.update({"fresh orphan (in-flight)": fresh_orphan, "fresh intent (in-flight)": fresh_intent}) + + before = snapshot() + _, dry = reconcile("--verify-checksums", *GRACE) + after = snapshot() + _, apply1 = reconcile("--apply", "--verify-checksums", *GRACE) + _, apply2 = reconcile("--apply", "--verify-checksums", *GRACE) + s3_put(key["C"], data["C"]) # the lost object restored from a backup + _, apply3 = reconcile("--apply", "--verify-checksums", *GRACE) + for name, report in (("faults-1-dry-run.json", dry), ("faults-2-apply.json", apply1), + ("faults-3-apply-again.json", apply2), ("faults-4-after-restore.json", apply3)): + save(out, name, report) + rows = {label: attachment_row(up[n]["id"]) for label, n in (("C", "C"), ("D", "D"), ("E", "E"), ("F", "F"), ("A", "A"), ("B", "B"))} + content = {n: api.client.get(f"/api/v1/attachments/{up[n]['id']}/content", + headers={"Authorization": "Bearer " + bob["token"]}).status_code for n in "ABCDEF"} + present = s3_keys() + summary = { + "dry_run_changed_nothing": before == after, + "per_key": {"dry-run": ours(dry, keys), "apply": ours(apply1, keys), "apply again": ours(apply2, keys), + "after restore of C": ours(apply3, keys)}, + "objects_present_after": {label: k in present for label, k in keys.items()}, + "rows_after": {k: (v and {"status": v["status"], "lost_reason": v["lost_reason"]}) for k, v in rows.items()}, + "content_status_after": content, + "durations_s": [dry["duration_seconds"], apply1["duration_seconds"], apply2["duration_seconds"], + apply3["duration_seconds"]], + } + print(json.dumps(summary, ensure_ascii=False, indent=1), flush=True) + return summary + + +def scenario_b(out: Path, count: int = 400) -> dict: + keys = ["o/" + uuid.uuid4().hex for _ in range(count)] + s3_exec("ks = sys.stdin.read().split()\n" + "sem = asyncio.Semaphore(32)\n" + "async def one(k):\n" + " async with sem:\n" + " await s.put(k, b'orphan', 'image/png', {})\n" + "await asyncio.gather(*(one(k) for k in ks))", stdin="\n".join(keys)) + time.sleep(32) + result: dict = {} + + def run_apply() -> None: + result["code"], result["report"] = reconcile("--apply", "--max-orphan-fraction", "1", *GRACE) + + t = threading.Thread(target=run_apply) + t.start() + # pause S3 as soon as deletions are under way (the reconciler is planning/listing first) + deadline = time.monotonic() + 60 + while time.monotonic() < deadline: + left = len(s3_keys() & set(keys)) + if left < count: + break + time.sleep(0.2) + subprocess.run(["docker", "compose", "pause", "s3"], cwd=ROOT, check=True, capture_output=True) + t.join() + subprocess.run(["docker", "compose", "unpause", "s3"], cwd=ROOT, check=True, capture_output=True) + time.sleep(2) + left_after_interrupt = len(s3_keys() & set(keys)) + code2, second = reconcile("--apply", "--max-orphan-fraction", "1", *GRACE) + code3, third = reconcile("--apply", *GRACE) + save(out, "interrupted-1-apply.json", result["report"]) + save(out, "interrupted-2-rerun.json", second) + save(out, "interrupted-3-third.json", third) + summary = { + "orphans_injected": count, + "interrupted_run": {"exit_code": result["code"], "error": result["report"].get("error"), + "applied": result["report"]["actions"]["applied"]}, + "orphans_left_after_interrupt": left_after_interrupt, + "rerun": {"exit_code": code2, "applied": second["actions"]["applied"], "error": second["error"]}, + "third": {"exit_code": code3, "planned": third["actions"]["planned"]}, + "orphans_left_at_end": len(s3_keys() & set(keys)), + } + print(json.dumps(summary, ensure_ascii=False, indent=1), flush=True) + return summary + + +def main() -> int: + p = argparse.ArgumentParser() + p.add_argument("--output", default="evidence/reconcile") + args = p.parse_args() + out = ROOT / args.output + out.mkdir(parents=True, exist_ok=True) + a = scenario_a(out) + b = scenario_b(out) + commit = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT, capture_output=True, text=True).stdout.strip() + save(out, "faults-summary.json", {"date": time.strftime("%Y-%m-%d %H:%M:%S"), "commit": commit, + "grace_seconds": 30, "scenario_a": a, "scenario_b_interrupted": b}) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/bench/upload_memory.py b/bench/upload_memory.py index fa132061..92796c9e 100644 --- a/bench/upload_memory.py +++ b/bench/upload_memory.py @@ -57,6 +57,14 @@ def cg(cid: str, name: str) -> int: return int(sh("docker", "exec", cid, "cat", f"/sys/fs/cgroup/{name}").split()[0]) +def memory_stat(cid: str, key: str) -> int: + for line in sh("docker", "exec", cid, "cat", "/sys/fs/cgroup/memory.stat").splitlines(): + name, value = line.split() + if name == key: + return int(value) + return 0 + + def vmhwm(cid: str) -> int: for line in sh("docker", "exec", cid, "cat", "/proc/1/status").splitlines(): if line.startswith("VmHWM:"): @@ -64,6 +72,16 @@ def vmhwm(cid: str) -> int: return 0 +def container_events() -> dict[str, str]: + """restart count + OOM-kill events per container (cgroup memory.events oom_kill counter).""" + out = {} + for cid in sh("docker", "compose", "ps", "-q").split(): + name, restarts = sh("docker", "inspect", "-f", "{{.Name}} {{.RestartCount}}", cid).split() + events = dict(line.split() for line in sh("docker", "exec", cid, "cat", "/sys/fs/cgroup/memory.events").splitlines()) + out[name.lstrip("/")] = f"restarts={restarts} oom_kill={events.get('oom_kill', '?')}" + return out + + def recreate(env: dict) -> None: sh("docker", "compose", "up", "-d", "--force-recreate", "--no-deps", "--wait", "api", env=env, timeout=300) sh(sys.executable, "scripts/lbctl.py", "wait-up", str(len(replicas())), "--timeout", "90") # LB sees them UP @@ -129,7 +147,9 @@ def run_scenario(name: str, env: dict, files: list[tuple[bytes, str]]) -> dict: results[i] = (r.status_code, time.perf_counter() - started, r.headers.get("x-instance-id", "-")) c.close() - samplers = [Sampler(cid) for cid in ids] + s3_id = sh("docker", "compose", "ps", "-q", "s3").strip() + restarts_before = container_events() + samplers = [Sampler(cid) for cid in ids] + [Sampler(s3_id)] for s in samplers: s.start() time.sleep(0.5) @@ -144,7 +164,7 @@ def run_scenario(name: str, env: dict, files: list[tuple[bytes, str]]) -> dict: for s in samplers: s.stop() per_replica = {} - for cid, s in zip(ids, samplers): + for cid, s in zip(ids, samplers[:-1]): hostname = sh("docker", "inspect", "-f", "{{.Config.Hostname}}", cid).strip() per_replica[hostname] = { "idle_mib": round(idle[cid] / MiB, 1), @@ -162,6 +182,11 @@ def run_scenario(name: str, env: dict, files: list[tuple[bytes, str]]) -> dict: codes[str(r[0])] = codes.get(str(r[0]), 0) + 1 summary = { "scenario": name, "settings": env, "clients": len(files), + "s3_sampled_max_mib": round(max(samplers[-1].values or [0]) / MiB, 1), + "s3_anon_after_mib": round(memory_stat(s3_id, "anon") / MiB, 1), + "s3_limit_mib": round(cg(s3_id, "memory.max") / MiB, 1), + # OOM kills / restarts DURING the scenario (any container of the stand): must be empty + "incidents": {k: v for k, v in container_events().items() if v != restarts_before.get(k)}, "file_mib_each": round(statistics.mean(len(d) for d, _ in files) / MiB, 2), "types": sorted({t for _, t in files}), "status_codes": codes, "wall_seconds": round(wall, 2), "latency_s": {"p50": round(lat[len(lat) // 2], 2), "max": round(lat[-1], 2)} if lat else None, @@ -179,16 +204,20 @@ def main() -> int: out = ROOT / args.output out.mkdir(parents=True, exist_ok=True) print("generating files ...", flush=True) - pngs = [(imagegen.png_of_size(int(9.5 * MiB)), "image/png") for _ in range(args.clients)] + pngs = [(imagegen.png_of_size(int(9.5 * MiB)), "image/png") for _ in range(2 * args.clients)] jpegs = [(big_jpeg(8000, 5000, i), "image/jpeg") for i in range(args.clients)] base = {"UPLOAD_CONCURRENCY": "4", "IMAGE_VERIFY_CONCURRENCY": "1"} + n, n2 = args.clients, 2 * args.clients scenarios = [ - ("png-9.5MiB x16, slots=4 (default)", base, pngs), - ("png-9.5MiB x16, slots=16 (no bound)", {"UPLOAD_CONCURRENCY": "16", "IMAGE_VERIFY_CONCURRENCY": "1"}, pngs), - ("jpeg-40Mpx-progressive x16, slots=4, verify=1 (default)", base, jpegs), - ("jpeg-40Mpx-progressive x16, slots=4, verify=4", {"UPLOAD_CONCURRENCY": "4", "IMAGE_VERIFY_CONCURRENCY": "4"}, jpegs), + (f"png-9.4MiB x{n}, slots=4 (default)", base, pngs[:n]), + (f"png-9.4MiB x{n2}, slots=4 (default)", base, pngs), + (f"png-9.4MiB x{n2}, slots=16 (bound raised)", {"UPLOAD_CONCURRENCY": "16", "IMAGE_VERIFY_CONCURRENCY": "1"}, pngs), + (f"jpeg-40Mpx-progressive-4:4:4 x{n}, verify=1 (default)", base, jpegs), + (f"jpeg-40Mpx-progressive-4:4:4 x{n}, verify=4", {"UPLOAD_CONCURRENCY": "4", "IMAGE_VERIFY_CONCURRENCY": "4"}, jpegs), ] results = [] + sh("docker", "compose", "restart", "s3") # S3 memory counters start from an idle process + sh("docker", "compose", "up", "-d", "--wait", "s3") try: for name, env, files in scenarios: results.append(run_scenario(name, env, files)) diff --git a/compose.yaml b/compose.yaml index 4d427ce7..6899f048 100644 --- a/compose.yaml +++ b/compose.yaml @@ -111,6 +111,8 @@ services: entrypoint: ["/bin/sh", "/etc/seaweedfs/start.sh"] environment: S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + # Go heap target below the container limit: the GC returns memory before the cgroup OOM. + GOMEMLIMIT: ${S3_GOMEMLIMIT:-600MiB} secrets: - s3_admin_access_key_id - s3_admin_secret_access_key @@ -133,7 +135,7 @@ services: networks: [storage] deploy: resources: - limits: {cpus: "${S3_CPUS:-1.0}", memory: "${S3_MEMORY:-512m}"} + limits: {cpus: "${S3_CPUS:-1.0}", memory: "${S3_MEMORY:-1g}"} # One-shot schema migration: runs ONCE per `up`, before any API replica starts # (api depends_on service_completed_successfully). Replicas never migrate themselves. @@ -236,6 +238,9 @@ services: # 512m: UPLOAD_CONCURRENCY (4) x 10 MiB bodies + one djpeg (<= JPEG_MAX_MEMORY_MB) + runtime; # measured in evidence/memory/ (bench/upload_memory.py). limits: {cpus: "${API_CPUS:-1.0}", memory: "${API_MEMORY:-512m}"} + # No swap on top of the limit (Docker's default would allow as much swap again): the RAM bound + # of the experiments is a real bound, and running out of it is visible, not hidden in swap. + memswap_limit: ${API_MEMORY:-512m} lb: image: haproxy:3.2.26-alpine@sha256:254e6370f01cd654e0744edf607c67f33777c1b6a9dc0d4b28bcba7171460122 diff --git a/docs/CONSISTENCY.md b/docs/CONSISTENCY.md new file mode 100644 index 00000000..4614246d --- /dev/null +++ b/docs/CONSISTENCY.md @@ -0,0 +1,73 @@ +# Согласованность PostgreSQL и S3 (lab4: уровень 4 и трек 2) + +Байты вложения лежат в приватном bucket S3 (SeaweedFS), метаданные — в таблице `attachments` PostgreSQL. Общей транзакции у двух хранилищ нет, поэтому порядок записи и механизм уборки определяют, что остаётся после любого сбоя. + +## Инвариант и порядок записи + +**Объект никогда не существует без строки, которая называет его ключ.** Строка появляется раньше объекта, а при уборке исчезает позже. + +```text +upload: [проверки, тело в памяти, полная проверка изображения] + 1. INSERT attachments(status='pending', object_key=o/<128 бит>) COMMIT ← намерение + 2. S3 PUT o/ (Content-MD5) + 3. UPDATE status='ready' WHERE status='pending' COMMIT + 4. 201 ready +janitor: SELECT … WHERE status='pending' AND старше PENDING_GRACE FOR UPDATE SKIP LOCKED + S3 DELETE (идемпотентно) → DELETE строки COMMIT +``` + +| Сбой | Что остаётся | Кто и когда убирает | Что видит клиент | +| --- | --- | --- | --- | +| До шага 1 (лимит, 415, обрыв тела, таймаут) | ничего: до полной проверки в хранилища ничего не пишется | — | 4xx/обрыв | +| Шаг 1 не прошёл (БД недоступна) | ничего | — | 503 | +| Между 1 и 2, S3 PUT упал или неизвестно, записан ли объект | строка `pending` (+ возможно объект) | janitor через `PENDING_GRACE_SECONDS` (900 с): удаляет объект, затем строку | 503, повтор создаёт новое вложение (контракт это разрешает) | +| Между 2 и 3 (процесс упал, БД пропала) — `FAULT_POINTS=after_s3_put` | строка `pending` + объект | janitor | 503 | +| Шаг 3 закоммичен, ответ потерян — `FAULT_POINTS=after_ready_commit` | корректное `ready`-вложение | **никто не трогает**: janitor работает только с `pending` | 503; файл скачивается по id ([test_consistency.py](../student-tests/test_consistency.py)) | + +В обработчике запроса **компенсации нет**. Если ответ на COMMIT потерян, неизвестно, стала ли строка `ready`. Удалить объект «на всякий случай» значило бы получить `ready` без байтов — именно это преподаватель нашёл в чужом PR. Решение принимает только janitor, по зафиксированному состоянию и под блокировкой строки: «зависшая» загрузка, если бы она ещё шла, ждала бы на этой строке и затем получила бы 503. + +**Почему grace 900 с безопасен.** Самая долгая загрузка: ожидание слота 5 с + тело 30 с + проверка 10 с + S3 PUT ≈ 4 с, итого < 60 с. Grace на порядок больше. Reconciler отказывается работать с `--grace` < 60 с без явного флага `--allow-small-grace` (флаг нужен только тестам). + +**Когда честно вернуть 201.** Только после шага 3: объект записан (S3 подтвердил PUT и проверил Content-MD5), строка `ready` закоммичена. До этого клиент не получает id. + +## Reconciler (трек 2) + +`python -m messenger.reconcile` — отдельный CLI в том же образе, compose-сервис `reconciler` (профиль `tools`, запускается по требованию). У него свои ключи S3 (`Read+Write+List` на bucket), у API права `List` нет. + +### Как он обходит хранилища + +Оба хранилища читаются как упорядоченные по ключу потоки, и над ними выполняется merge-join: + +- S3: `ListObjectsV2(prefix=o/, StartAfter, MaxKeys=1000)` — ключи в порядке байтов; +- PostgreSQL: keyset-страницы `SELECT … FROM attachments WHERE object_key > $1 ORDER BY object_key LIMIT 1000` — колонка `COLLATE "C"`, тот же порядок байтов, уникальный индекс. + +Память не зависит от размера bucket. Стоимость прохода ≈ N/1000 запросов листинга + N/1000 страниц БД; с `--verify-checksums` добавляется чтение всех байтов. + +### Что находит и что исправляет `--apply` + +| Вид | Условие | `--apply` | +| --- | --- | --- | +| `orphan_object` | объект без строки, старше `--grace` | удалить объект (перед этим заново проверить, что строки нет и объект всё ещё старый) | +| `stale_intent` | строка `pending` старше `--grace` (с объектом или без) | под `FOR UPDATE`: удалить объект, затем строку | +| `missing_object` | строка `ready`, объекта нет, старше `--grace` | **карантин** строки: `lost_at`, `lost_reason` | +| `size_mismatch` | у `ready` размер объекта ≠ `size_bytes` | карантин | +| `checksum_mismatch` | SHA-256 объекта ≠ сохранённому (`--verify-checksums`) | карантин | +| `restored_object` | строка в карантине, объект снова на месте и верный | снять карантин | +| `fresh_*` | то же, но моложе `--grace` (загрузка в процессе) | ничего | + +Карантин: `GET …/content` → 404 «оригинал утрачен», прикрепить к новому сообщению нельзя (409, как failed-вложение). Метаданные и ссылки из старых сообщений сохраняются. Карантин обратим: когда объект восстановят из резервной копии, следующий проход его снимет. + +### Почему исправление безопасно + +1. **Dry-run read-only конструктивно, а не «по if-у».** Сессия PostgreSQL открывается с `default_transaction_read_only=on`: любая запись упадёт в самой БД. Объект S3 в dry-run обёрнут в `ReadOnlyStorage` без метода `delete`. Тест сравнивает отпечаток всех строк `attachments` и список ключей bucket до и после dry-run. Это закрывает ошибку, которую нашли в чужом PR: «dry-run продолжает частично завершённое удаление». +2. **`ready`-строки никогда не удаляются**, ни используемые, ни неиспользуемые: только обратимый карантин. Удаляются лишь объекты без строк и строки-намерения `pending`. Ссылки `message_attachments → attachments` защищены FK, поэтому используемое вложение не удалить даже по ошибке. +3. **Всё, что моложе `--grace`, не трогается.** +4. **Перепроверка перед каждым действием**, под `FOR UPDATE`, где есть строка. `post_message_v2` берёт `FOR SHARE` на прикрепляемые вложения, поэтому карантин и отправка сообщения сериализуются. +5. **Объект первым, строка второй.** Прерванный проход оставляет состояние, которое следующий проход доводит до конца. Повторный запуск идемпотентен. +6. **Предохранитель.** Если «сиротами» выглядят больше `--max-orphan-fraction` (50 %) объектов — например, reconciler направили не в ту БД, — `--apply` завершается с кодом 3, ничего не удалив. +7. **Отказ хранилища** во время прохода: выход с кодом 1 и JSON-отчётом `store_unavailable`; уже сделанное зафиксировано, остальное сделает следующий запуск. + +### Janitor и reconciler — зачем оба + +- **Janitor** (в каждой реплике API, раз в ~60 с, advisory-замок — работает одна реплика за раз) дёшев: частичный индекс по `pending` и ничего больше. Он убирает типичный мусор — незавершённые загрузки. +- **Reconciler** проходит оба хранилища целиком и находит то, о чём БД не знает: объекты без строк (ручные действия, баги прошлых версий, восстановление bucket из другой копии), пропавшие и испорченные объекты. Его запускают по расписанию или вручную, всегда сначала в dry-run. diff --git a/docs/DATA_MODEL.md b/docs/DATA_MODEL.md index 27c3e95d..815b0dcb 100644 --- a/docs/DATA_MODEL.md +++ b/docs/DATA_MODEL.md @@ -1,6 +1,6 @@ -# Модель данных lab3 +# Модель данных lab4 -Схема: [0001_init.sql](../migrations/0001_init.sql) (lab2), [0002_idempotency_keys.sql](../migrations/0002_idempotency_keys.sql) и [0003_post_message_function.sql](../migrations/0003_post_message_function.sql) (lab3). Миграции применяет один раз отдельный сервис `migrate` до старта реплик API; обе миграции lab3 только добавляют объекты, поэтому совместимы с работающей предыдущей версией (rolling update). Источник истины для пользователей, чатов, участников и сообщений — PostgreSQL 18. Для сессий источник истины — хранилище, выбранное через `SESSION_STORE`. По умолчанию это Valkey с AOF, его можно переключить на таблицу `sessions` в PostgreSQL. +Схема: [0001_init.sql](../migrations/0001_init.sql) (lab2), [0002_idempotency_keys.sql](../migrations/0002_idempotency_keys.sql) и [0003_post_message_function.sql](../migrations/0003_post_message_function.sql) (lab3), [0004_attachments.sql](../migrations/0004_attachments.sql) (lab4). Миграции применяет один раз отдельный сервис `migrate` до старта реплик API; миграции lab3 и lab4 только добавляют объекты (0004 ещё ослабляет `CHECK` длины текста), поэтому совместимы с работающей предыдущей версией. Байты вложений живут **только** в приватном bucket S3 (SeaweedFS), в PostgreSQL — их метаданные; согласованность двух хранилищ — [CONSISTENCY.md](CONSISTENCY.md). Источник истины для пользователей, чатов, участников и сообщений — PostgreSQL 18. Для сессий источник истины — хранилище, выбранное через `SESSION_STORE`. По умолчанию это Valkey с AOF, его можно переключить на таблицу `sessions` в PostgreSQL. ## Таблицы и ограничения @@ -12,6 +12,8 @@ | `messages` | `id uuid` | FK `(chat_id, sender_id) → chat_members`, длина `text` | отправитель обязан быть участником — это гарантирует сама БД | | `sessions` | `token_hash bytea` | FK `user_id → users`, длина хеша 32 байта | хранится SHA-256 токена; сам токен не хранится нигде | | `idempotency_keys` | `(user_id, chat_id, key)` | FK на `users`, `chats`; `message_id → messages` (DEFERRABLE, `UNIQUE`); `CHECK` формата ключа и длины SHA-256 | общая для всех реплик идемпотентность отправки: ключ → отпечаток тела → сообщение. Хранится ≥ `IDEMPOTENCY_TTL_SECONDS` (24 ч), очистка — пачками раз в 10 мин под advisory-замком | +| `attachments` (lab4) | `id uuid` | FK `(chat_id, owner_id) → chat_members`; `UNIQUE object_key` (`COLLATE "C"`, формат `o/<32 hex>`); `CHECK` статуса `pending/ready`, типа `image/png|jpeg`, размера 1…10 MiB, пикселей ≤ 40 млн, длины SHA-256, карантина (`lost_at`/`lost_reason` только у `ready`) | метаданные оригинала; `object_key` генерирует сервер (128 случайных бит), с id и filename не связан. `pending` — намерение загрузки (строка раньше объекта), `ready` — объект записан. Частичный индекс `(created_at) WHERE status='pending'` — для janitor | +| `message_attachments` (lab4) | `(message_id, position)` | FK на `messages` и `attachments`, `UNIQUE (message_id, attachment_id)`, индекс по `attachment_id` | целостность ссылок (вложение, на которое ссылается сообщение, удалить нельзя) и обратный поиск «используется ли вложение» | | `schema_migrations` | `version` | checksum файла | какие миграции применены; изменённую задним числом миграцию мигратор не применит | **Почему `bytea` для текста.** Контракт разрешает символ U+0000, а тип `text` в PostgreSQL не может содержать байт NUL (`DataError`). Поэтому `display_name`, `title` и `text` хранятся как байты UTF-8. Длину в code points проверяет API, а `CHECK` в байтах — страховка (1 code point ≤ 4 байта). @@ -30,6 +32,8 @@ | Регистрация | один `INSERT` | `UniqueViolation` → 409; ровно одна строка при гонке | | Создание чата | `INSERT chats` → `INSERT chat_members` (все участники одним запросом) → `COMMIT` | неизвестный участник вызывает FK-ошибку **после** вставки чата; откат удаляет и чат, и частичное членство | | Сообщение (lab3, с ключом) | проверка членства → `INSERT idempotency_keys … ON CONFLICT DO UPDATE … WHERE ключ старше 24 ч` → если вставлен: `UPDATE chats … RETURNING` → `INSERT messages`; если нет: прочитать сохранённое сообщение и сравнить отпечаток → `COMMIT`. По умолчанию всё это — одна SQL-функция `post_message` в autocommit (одно обращение к БД) | ключ, сообщение и «результат» коммитятся вместе или не коммитятся вовсе: «висящего» ключа нет. Конкурентный повтор ждёт на уникальном индексе завершения первой транзакции и затем видит её результат (READ COMMITTED, новый снимок на каждый оператор). Другое тело → 409, тот же — тот же Message | +| Сообщение с `attachment_ids` (lab4) | в той же функции `post_message_v2`: проверка членства → проверка вложений (`ready`, этого чата, не в карантине; `FOR SHARE`) → только если всё хорошо — захват ключа → `UPDATE chats` → `INSERT messages (…, attachment_ids)` → `INSERT message_attachments` | чужое/неизвестное/незавершённое вложение — 404, в карантине — 409, ключ при этом не «сгорает». Порядок `attachment_ids` хранится массивом в строке сообщения: страница истории остаётся одним диапазонным сканом индекса | +| Загрузка вложения (lab4) | `INSERT attachments … 'pending'` (autocommit) → S3 PUT (Content-MD5) → `UPDATE … SET status='ready' WHERE status='pending'` (autocommit) → 201 | 201 только когда и объект, и строка `ready` зафиксированы. Сбой между шагами оставляет `pending`, его убирает janitor после `PENDING_GRACE_SECONDS`. Компенсации в обработчике запроса нет: после потерянного ответа COMMIT неизвестно, `ready` ли строка | | Сообщение (lab2-часть) | проверка членства → `UPDATE chats SET last_message_at = greatest(clock_timestamp(), last_message_at + 1 мкс) RETURNING` → `INSERT messages` → `COMMIT` | строка чата заблокирована до конца транзакции, поэтому писатели одного чата идут по очереди. Время сообщений строго растёт **в порядке коммитов**: страница по cursor не пропустит сообщение, закоммиченное «задним числом» | | Вход | `SELECT` пользователя, проверка Argon2id, запись сессии | неверный пароль ничего не пишет | | Logout | `DELETE` сессии (или `DEL` в Valkey) | повтор с тем же токеном — 401 | diff --git a/docs/DEFENSE.md b/docs/DEFENSE.md new file mode 100644 index 00000000..f1381564 --- /dev/null +++ b/docs/DEFENSE.md @@ -0,0 +1,39 @@ +# Ответы на вопросы защиты ЛР 4 + +## Почему файл в Docker volume одной API-реплики не равен объектному хранилищу? + +- **Volume принадлежит одному контейнеру.** Файл, загруженный через реплику api-1, лежит только у неё. Запрос, который LB отправил на api-2, его не найдёт. Если api-1 остановлена (failover, rolling update, scale down), файл недоступен вовсе. В нашем стенде у сервиса `api` нет ни одного volume: реплики взаимозаменяемы, и тест «загрузка → kill обслужившей реплики → скачивание через другую» проходит ([test_storage_failures.py](../student-tests/test_storage_failures.py)). +- **Общий bind-mount на одном хосте** тоже не выход. Он привязывает все реплики к одной машине, не даёт атомарной записи объекта, проверки целостности (Content-MD5), отдельных прав доступа и HTTP-API для других сервисов (worker в lab5 возьмёт тот же объект по ключу). +- **S3-сервер** — отдельный процесс со своим жизненным циклом и своим volume (`s3data`): он переживает перезапуск и замену API. Права в нём задаются по ключам: у API — только Read+Write своего bucket, без List и без создания bucket. + +## Когда можно честно вернуть 201? + +Когда оба хранилища подтвердили запись: S3 ответил на PUT, проверив Content-MD5, и после этого закоммичен `UPDATE attachments SET status='ready'`. До этого клиент не получает id вложения. Перед записью проходят все проверки: лимиты, полная проверка изображения, SHA-256. Ответ 201 на «принял в память» или «записал строку, а PUT ещё идёт» был бы ложью: после сбоя по такому id ничего не скачать. Подробно: [CONSISTENCY.md](CONSISTENCY.md). + +## Что произойдёт, если S3 PUT прошёл, а COMMIT в PostgreSQL — нет? + +Строка-намерение `pending` с ключом объекта закоммичена **до** PUT, поэтому объект не «потеряется»: БД знает его ключ. + +- Клиент получает 503 и может повторить: получится новое вложение, контракт это разрешает. +- Строка остаётся `pending`, вложение невидимо (GET → 404, прикрепить → 404). +- Janitor через `PENDING_GRACE_SECONDS` (900 с) под `FOR UPDATE` удаляет объект, затем строку. Проверено внедрением отказа `FAULT_POINTS=after_s3_put`: строка и объект исчезают ([test_consistency.py](../student-tests/test_consistency.py)). +- Если упал не COMMIT, а **ответ** на него (COMMIT прошёл), в обработчике ничего не удаляется: неизвестно, стала ли строка `ready`. Проверено `FAULT_POINTS=after_ready_commit`: файл цел и скачивается. +- Объекты, о которых БД не знает вовсе (ручные действия, старые версии), находит reconciler (трек 2) и удаляет, если они старше grace. + +## Почему случайный object key и приватный bucket не заменяют ACL приложения? + +- **Приватный bucket** запрещает анонимный доступ к S3, но решение «может ли *этот пользователь* читать *этот файл*» принимает только приложение: оно знает участников чата. Ключи S3 у API одни на всех пользователей. Поэтому каждый `GET /attachments/{id}` и `/content` проверяет членство в чате, посторонний получает 404 (не 403 — существование чужого вложения не раскрывается). +- **Случайный ключ** — защита от перебора, а не авторизация. Ключ может утечь (логи, отладка, бывший участник чата). Удалённого из чата пользователя в нашем API нет, но в общем случае доступ должен отзываться — а ключ, если бы он был единственной защитой, остался бы действующим навсегда. Поэтому ключ не попадает ни в один ответ API, а байты отдаются только через авторизованный API, без redirect на S3. +- То же проверено снаружи: анонимный GET/LIST к S3 → 403 (bootstrap `s3-init` и тест), а запрос с ключом API работает — значит, права проверяет S3, а доступ пользователей — приложение. + +## Частые уточняющие вопросы + +**Как ограничена память?** Одна загрузка — один буфер ≤ 10 MiB (при известном Content-Length выделяется ровно этот объём, без копий). На реплику одновременно принимается не больше `UPLOAD_CONCURRENCY=4` тел. Остальные ждут ≤ 5 с, их байты остаются в TCP-буферах (backpressure), потом 503 + Retry-After. Полная проверка изображения выполняется по одной (`IMAGE_VERIFY_CONCURRENCY=1`). Пиксели проверяются по заголовку ещё до чтения остального тела. Замер ≥ 10 одновременных загрузок: [REPORT.md](../REPORT.md#эксперименты-и-отказы). + +**Почему не Pillow для проверки?** Для PNG Pillow создаёт растр целиком (40 Мпикс RGBA = 160 МБ), а наш валидатор проверяет CRC и zlib-поток потоково и ничего не хранит. Для JPEG Pillow игнорирует предупреждения libjpeg и возвращает серую картинку для файла без данных после SOS. `djpeg -strict` считает любое предупреждение ошибкой, а `-scale 1/8` декодирует все блоки, но пишет растр в 64 раза меньше. + +**Что если S3 недоступен?** `/health/ready` → 503 (S3 входит в обязательный синхронный путь). Загрузка и скачивание → 503 за ≤ `S3_TIMEOUT_SECONDS` (3 с). HAProxy переключается на backend `api_core` с проверкой `/health/ready/core` (БД + Valkey): чаты и текстовые сообщения продолжают работать. Если S3 потеряла одна реплика, она DOWN в основном backend, и трафик идёт на другую. + +**Почему SeaweedFS, а не MinIO?** Образы MinIO в Docker Hub больше не публикуются (репозиторий `minio/minio` удалён, проверено при выборе). SeaweedFS развивается и умеет identity с правами на bucket (`Read:bucket`, `Write:bucket`, `List:bucket`). Закреплён по digest (4.46, сентябрь 2026). Его web-интерфейсы (master, filer, volume) слушают только 127.0.0.1 внутри контейнера, телеметрия выключена. + +**Где dry-run гарантирует, что ничего не меняется?** Не в коде планировщика, а в окружении: сессия PostgreSQL в dry-run открыта с `default_transaction_read_only=on`, объект S3 обёрнут без метода `delete`. Тест сравнивает отпечаток всей таблицы `attachments` и список ключей bucket до и после. diff --git a/docs/WINDOWS.md b/docs/WINDOWS.md index e98718f5..9870a50a 100644 --- a/docs/WINDOWS.md +++ b/docs/WINDOWS.md @@ -1,4 +1,4 @@ -# Запуск на ноутбуке с Windows и сценарий защиты ЛР 3 +# Запуск на ноутбуке с Windows и сценарий защиты ЛР 4 Команды — в **PowerShell** из папки проекта (где лежит `compose.yaml`). Переменные `$env:...` действуют до закрытия окна. @@ -7,29 +7,23 @@ | Программа | Зачем | Важно | | --- | --- | --- | | [Git for Windows](https://git-scm.com/download/win) | clone и Git Bash | путь по умолчанию `C:\Program Files\Git`: оттуда `scripts\*.cmd` запускают `.sh`-хуки | -| [Docker Desktop](https://www.docker.com/products/docker-desktop/) | PostgreSQL, Valkey, HAProxy, API | backend WSL 2, виртуализация в BIOS; для трека 1 в Settings → Resources дать **8 CPU** | +| [Docker Desktop](https://www.docker.com/products/docker-desktop/) | PostgreSQL, Valkey, SeaweedFS (S3), HAProxy, API | backend WSL 2, виртуализация в BIOS; в Settings → Resources ≥ 4 CPU и ≥ 6 ГБ RAM | | [Python 3.12+](https://www.python.org/downloads/windows/) | secrets, публичные и свои тесты, скрипты замеров | галочка **Add python.exe to PATH** | -| GNU make (необязательно) | `make check/test/test-failover …` | `winget install ezwinports.make`, затем **новое** окно PowerShell. Рецептам Makefile нужен `sh`: в каждом окне PowerShell один раз `$env:Path += ";C:\Program Files\Git\usr\bin"` (или запускать make из Git Bash). Без make те же команды есть в таблице REPORT.md | - -Проверка: - -```powershell -git --version; docker version --format '{{.Server.Version}}'; docker compose version; python --version; make --version -``` +| GNU make (необязательно) | `make check/test/test-failover …` | `winget install ezwinports.make`, затем **новое** окно PowerShell. Рецептам Makefile нужен `sh`: в каждом окне один раз `$env:Path += ";C:\Program Files\Git\usr\bin"` | ## 2. Развернуть проект (дома, заранее — нужен интернет) ```powershell -git clone https://gitea.privcloud.tech/wfa/mtusi2026lab3 mtusi2026lab3 -cd mtusi2026lab3 +git clone https://gitea.privcloud.tech/wfa/mtusi2026lab4 mtusi2026lab4 +cd mtusi2026lab4 git checkout solution/bvt2302-bodanyuk -python scripts\init_secrets.py # случайные пароли в .\secrets (не в Git) +python scripts\init_secrets.py # случайные пароли и 3 пары ключей S3 в .\secrets (не в Git) Copy-Item .env.example .env -docker compose --env-file .env config --quiet # конфигурация собирается без ошибок +docker compose --env-file .env config --quiet docker compose --env-file .env up -d --build --wait ``` -Первый запуск качает образы (~800 МБ) и собирает API — 3–10 минут. Команда завершается, когда postgres, valkey, обе реплики api и lb в состоянии `healthy`, а `migrate` завершился с кодом 0. +Первый запуск качает образы (~1 ГБ) и собирает API — 3–10 минут. Команда завершается, когда postgres, valkey, s3, обе реплики api и lb в состоянии `healthy`, а `migrate` и `s3-init` завершились с кодом 0. Вердикты bootstrap S3 (приватность, права ключей): `docker compose logs s3-init`. Окружение для своих тестов и скриптов (один раз): @@ -37,102 +31,92 @@ docker compose --env-file .env up -d --build --wait python -m venv .venv .venv\Scripts\python -m pip install --require-hashes --no-deps -r requirements.txt .venv\Scripts\python -m pip install -r requirements-test.txt -r requirements-dev.txt -$env:PYTHONUTF8 = "1" # публичные тесты читают UTF-8 JSON +$env:PYTHONUTF8 = "1" ``` -Проверка в браузере: http://127.0.0.1:8080/health/ready → `{"status":"ok"}`; Swagger — http://127.0.0.1:8080/docs; состояние балансировщика (какие реплики UP/DOWN) — http://127.0.0.1:8404/. +Если запущен стенд lab3, он занимает порт 8080: `docker compose -p mtusi-lab3 stop` (данные lab3 сохранятся). -## 3. Перед защитой (в аудитории) +## 3. Перед защитой ```powershell -cd mtusi2026lab3 -$env:PYTHONUTF8 = "1" -$env:Path += ";C:\Program Files\Git\usr\bin" # sh для рецептов Makefile -docker compose up -d --wait # если стенд был остановлен -make check test PYTHON=python # или: python scripts\check_contract.py; python tests\smoke.py +cd mtusi2026lab4 +$env:PYTHONUTF8 = "1"; $env:Path += ";C:\Program Files\Git\usr\bin" +docker compose up -d --wait +make check test PYTHON=python # или: python tests\smoke.py python scripts\lbctl.py status # обе реплики UP ``` ## 4. Сценарий защиты из README — по шагам -**Шаг 1. ≥ 2 разных `X-Instance-Id` через LB с одной сессией.** +**Шаг 1. Загрузить fixture, отправить сообщение, скачать вторым участником, сравнить SHA-256.** ```powershell -python scripts\lbctl.py replicas # контейнеры api: имя, X-Instance-Id (= hostname), PID, IP -# Один пользователь, один токен, 6 запросов подряд через LB — номера реплик чередуются: -$u = "demo_" + (Get-Random); $p = "Demo-password-123" -Invoke-RestMethod -Method Post http://127.0.0.1:8080/api/v1/users -ContentType 'application/json' -Body (@{username=$u; display_name='Демо'; password=$p} | ConvertTo-Json) -$basic = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("${u}:${p}")) -$t = (Invoke-RestMethod -Method Post http://127.0.0.1:8080/api/v1/auth/sessions -Headers @{Authorization="Basic $basic"}).token -1..6 | ForEach-Object { (Invoke-WebRequest http://127.0.0.1:8080/api/v1/users/me -Headers @{Authorization="Bearer $t"} -UseBasicParsing).Headers['X-Instance-Id'] } +.venv\Scripts\python scripts\demo_attachments.py ``` -Повторный вход не нужен: сессия лежит в общем Valkey. То же автоматически: `.venv\Scripts\python -m pytest student-tests\test_balancing.py -k one_session -v`. +Скрипт печатает каждый запрос и ответ: регистрирует alice, bob и eve, создаёт чат alice+bob, загружает `tests/fixtures/sample.png` (201 ready, sha256), отправляет сообщение с `attachment_ids` и `text=""`. Затем bob скачивает файл, SHA-256 совпадает. Для eve (посторонний) — 404 на метаданные и на байты. Отдельно показано, что ключ объекта в S3 случайный и в API не раскрывается. -**Шаг 2. Отказ реплики публичным тестом.** +**Шаг 2. Прямой неаутентифицированный GET к S3 не отдаёт объект.** Скрипт из шага 1 в конце делает изнутри сети `storage` (снаружи S3 не опубликован) анонимный GET того же объекта и анонимный листинг bucket — оба 403. Тот же GET, подписанный ключом API, — 200. Вручную: ```powershell +docker compose logs s3-init # anonymous GET/LIST -> 403, права ключей api/reconciler +.venv\Scripts\python -m pytest student-tests\test_storage_failures.py -k private -v +``` + +**Шаг 3. Persistence и failover: общий тест сохраняет и заново читает оригинал через API.** + +```powershell +make test-persistence ACTION_SCRIPT=scripts/restart.cmd PYTHON=python # restart lb, api, postgres, valkey, s3 +docker compose ps # у всех «Up N seconds» make test-failover ACTION_SCRIPT=scripts/stop-one.cmd PYTHON=python -# без make: python tests\resilience.py --mode failover --action-script scripts\stop-one.cmd +python scripts\lbctl.py replicas # остановленная — exited +make restore PYTHON=python ``` -Тест сам выбирает реплику, обслужившую его первое сообщение, и передаёт её `X-Instance-Id` хуку. Хук останавливает именно этот контейнер и оставляет его остановленным. Вариант «падение процесса» — `$env:STOP_MODE = "kill"` перед командой (SIGKILL), вернуть — `Remove-Item Env:STOP_MODE`. +Для второй реплики: сдвинуть round-robin одним запросом (`Invoke-WebRequest http://127.0.0.1:8080/health/live -UseBasicParsing | Out-Null`) и повторить `make test-failover`. Загрузка → kill обслужившей реплики → скачивание через другую: `.venv\Scripts\python -m pytest student-tests\test_storage_failures.py -k failover -v`. -**Шаг 3. Показать, какой контейнер действительно остановлен, и повторить для второй.** +**Шаг 4. На API нет локального файла оригинала.** ```powershell -python scripts\lbctl.py replicas # у остановленной: exited, exit_code 0 (stop) или 137 (kill) -python scripts\lbctl.py status # её слот в HAProxy — MAINT/DOWN, вторая UP -docker compose logs --tail 20 api # drain_started -> shutdown_requested -> stopped у остановленной -make restore PYTHON=python # или: & "C:\Program Files\Git\bin\bash.exe" scripts/restore-api.sh; python scripts\lbctl.py wait-up 2 -make test-failover ACTION_SCRIPT=scripts/stop-one.cmd PYTHON=python -``` - -Тест останавливает ту реплику, которая обслужила его первое сообщение, поэтому для второй он может снова выбрать прежнюю. Детерминированно по очереди каждую реплику останавливает серия уровня 4 (~5 мин): `python bench\failover_series.py --output evidence\failover` (stop, kill и pause для каждой реплики, с восстановлением предыдущей). - -**Шаг 4. Restart всего стенда с сохранением volumes и прежним токеном.** - -```powershell -make test-persistence ACTION_SCRIPT=scripts/restart.cmd PYTHON=python -python scripts\lbctl.py replicas # у всех api свежий started и новый PID; LB снова видит обе реплики -docker compose ps # postgres, valkey, lb — тоже «Up N seconds» +.venv\Scripts\python -m pytest student-tests\test_attachments.py -k not_stored -v # find по ФС реплик +docker compose config --format json | Select-String '"volumes"' # у api нет volume ``` **Уровень 4 вживую.** ```powershell -# Неготовая, но живая реплика исключается из LB (pg_hba reject и docker network disconnect), ~1 мин: -.venv\Scripts\python -m pytest student-tests\test_balancing.py -k not_ready -v -s -# Rolling update под нагрузкой (~1,5 мин): новая ревизия на обеих репликах, 0 ошибок -python bench\rolling_under_load.py --output evidence\rolling-update -# Одновременные повторы с одним ключом через разные реплики: -.venv\Scripts\python -m pytest student-tests\test_idempotency.py -k concurrent -v +# Отказ S3 (stop и pause): readiness 503, загрузка 503 за < 8 с, текст работает (деградированный режим LB): +.venv\Scripts\python -m pytest student-tests\test_storage_failures.py -k outage -v +# Сбой между PUT и COMMIT убирает janitor; потерянный ответ после COMMIT ничего не удаляет: +.venv\Scripts\python -m pytest student-tests\test_consistency.py -v +# Все негативные кейсы файлов (413/415/400, чужой чат, MIME): +.venv\Scripts\python -m pytest student-tests\test_attachments.py -v ``` -**Трек 1.** Полная серия идёт часы, поэтому на защите — готовые результаты: [evidence/track1/summary.md](../evidence/track1/summary.md) и графики `evidence/track1/*/*/throughput.svg`. Вживую можно показать профиль одной реплики (~2 мин) и одну короткую серию (~6 мин): +**Трек 2 вживую.** ```powershell -docker compose stop # основной стенд не должен мешать замеру -python bench\track1\profile.py --label demo --rate 240 -python bench\track1\run.py --series demo --label now --rates 150,250,350 --repeats 1 --config replicas=2,MESSAGE_WRITE_PATH=multi --config replicas=2,MESSAGE_WRITE_PATH=function -docker compose up -d --wait # вернуть основной стенд +docker compose run --rm reconciler # dry-run: отчёт JSON, ничего не меняет +.venv\Scripts\python -m pytest student-tests\test_reconcile.py -k both_sides -v -s # ошибки на обеих сторонах, ~1,5 мин +docker compose run --rm reconciler --apply # исправить (на чистом стенде — 0 действий) ``` -**Все свои тесты** (~8 мин): `.venv\Scripts\python -m pytest student-tests -v`. +Готовые отчёты прогонов — [evidence/reconcile/](../evidence/reconcile/), стоимость обхода — [evidence/reconcile/cost.json](../evidence/reconcile/cost.json). + +**Все свои тесты** (~25 мин): `.venv\Scripts\python -m pytest student-tests -v`. ## 5. Если что-то пошло не так | Симптом | Что сделать | | --- | --- | | `error during connect … dockerDesktopLinuxEngine` | Docker Desktop не запущен — запустить и подождать минуту | -| `port is already allocated` на 8080/8404 | занято другим стендом (lab2: `docker compose -p mtusi-lab2 stop`) или в `.env` поставить `APP_PUBLISH_PORT=8081`, `LB_STATS_PORT=8405`; тестам — `--base-url http://127.0.0.1:8081` / `$env:BASE_URL` | +| `port is already allocated` на 8080/8404 | занято стендом lab3 (`docker compose -p mtusi-lab3 stop`) или в `.env` поставить `APP_PUBLISH_PORT=8081`, `LB_STATS_PORT=8405` | | `secrets/... not found` при `up` | не выполнен `python scripts\init_secrets.py` | +| `s3-init` exit 1 | `docker compose logs s3-init`: какая проверка доступа не прошла | | `UnicodeDecodeError` в `tests\*.py` | не задан `$env:PYTHONUTF8 = "1"` | | `*.cmd`: «не удаётся найти путь» | Git установлен не в `C:\Program Files\Git` — поправить путь в `scripts\*.cmd` | -| `make: command not found` | новое окно PowerShell после установки make или команды без make из REPORT.md | -| make: `'test' is not recognized` | в этом окне не добавлен `C:\Program Files\Git\usr\bin` в `$env:Path` (рецептам нужен `sh`) | | после `stop-one` в LB одна реплика | так и задумано; вернуть: `make restore PYTHON=python` | | api `unhealthy` после сна ноутбука | `docker compose restart` и `python scripts\lbctl.py wait-up 2` | -| нужно начать с чистого листа | `docker compose down -v` (удаляет учебные данные) → `docker compose up -d --build --wait` | +| нужно начать с чистого листа | `docker compose down -v` (удаляет учебные данные, включая bucket) → `docker compose up -d --build --wait` | Остановить стенд после защиты: `docker compose down` (данные сохранятся) или `docker compose down -v` (данные удаляются). diff --git a/evidence/test-failover.txt b/evidence/test-failover.txt new file mode 100644 index 00000000..5da8442e --- /dev/null +++ b/evidence/test-failover.txt @@ -0,0 +1,93 @@ +# 2026-10-25T11:06:22Z commit a2d867b +## round 1 +$ python scripts/lbctl.py replicas +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f running health=healthy pid=33267 started=2026-10-25T11:05:59.978 ip=172.25.0.3,172.26.0.4,172.27.0.2 +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 running health=healthy pid=33344 started=2026-10-25T11:06:00.330 ip=172.25.0.4,172.26.0.5,172.27.0.3 +$ python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 133, "failed_attempts": 0, "first_recovery_seconds": 6.008} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +exit=0 +$ python scripts/lbctl.py replicas (after hook) +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f exited health=unhealthy pid=0 started=2026-10-25T11:05:59.978 ip=- +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 running health=healthy pid=33344 started=2026-10-25T11:06:00.330 ip=172.25.0.4,172.26.0.5,172.27.0.3 +$ sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 +mtusi-lab4-api-1 Up 6 seconds (healthy) +mtusi-lab4-api-2 Up 46 seconds (healthy) +2 API replica(s) UP in HAProxy after 0.6 s: ['05c02ec0a89f', '4ddc189deda2'] +## round 2 +$ python scripts/lbctl.py replicas +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f running health=healthy pid=35395 started=2026-10-25T11:06:40.508 ip=172.25.0.3,172.26.0.4,172.27.0.2 +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 running health=healthy pid=33344 started=2026-10-25T11:06:00.330 ip=172.25.0.4,172.26.0.5,172.27.0.3 +$ python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 132, "failed_attempts": 0, "first_recovery_seconds": 5.738} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +exit=0 +$ python scripts/lbctl.py replicas (after hook) +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f exited health=unhealthy pid=0 started=2026-10-25T11:06:40.508 ip=- +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 running health=healthy pid=33344 started=2026-10-25T11:06:00.330 ip=172.25.0.4,172.26.0.5,172.27.0.3 +$ sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 +mtusi-lab4-api-1 Up 6 seconds (healthy) +mtusi-lab4-api-2 Up About a minute (healthy) +2 API replica(s) UP in HAProxy after 0.6 s: ['05c02ec0a89f', '4ddc189deda2'] +## round 3 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 133, "failed_attempts": 0, "first_recovery_seconds": 5.931} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +exit=0 +$ python scripts/lbctl.py replicas (after hook) +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f exited health=unhealthy pid=0 started=2026-10-25T11:07:06.512 ip=- +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 running health=healthy pid=33344 started=2026-10-25T11:06:00.330 ip=172.25.0.4,172.26.0.5,172.27.0.3 +$ sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 +mtusi-lab4-api-1 Up 6 seconds (healthy) +mtusi-lab4-api-2 Up About a minute (healthy) +2 API replica(s) UP in HAProxy after 0.7 s: ['05c02ec0a89f', '4ddc189deda2'] +## round 4 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 133, "failed_attempts": 0, "first_recovery_seconds": 6.053} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +exit=0 +$ python scripts/lbctl.py replicas (after hook) +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f exited health=unhealthy pid=0 started=2026-10-25T11:07:44.818 ip=- +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 running health=healthy pid=33344 started=2026-10-25T11:06:00.330 ip=172.25.0.4,172.26.0.5,172.27.0.3 +$ sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 +mtusi-lab4-api-1 Up 6 seconds (healthy) +mtusi-lab4-api-2 Up 2 minutes (healthy) +2 API replica(s) UP in HAProxy after 0.7 s: ['05c02ec0a89f', '4ddc189deda2'] +## round 5 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 133, "failed_attempts": 0, "first_recovery_seconds": 5.809} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +exit=0 +$ python scripts/lbctl.py replicas (after hook) +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f exited health=unhealthy pid=0 started=2026-10-25T11:08:10.900 ip=- +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 running health=healthy pid=33344 started=2026-10-25T11:06:00.330 ip=172.25.0.4,172.26.0.5,172.27.0.3 +$ sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 +mtusi-lab4-api-1 Up 6 seconds (healthy) +mtusi-lab4-api-2 Up 2 minutes (healthy) +2 API replica(s) UP in HAProxy after 0.6 s: ['05c02ec0a89f', '4ddc189deda2'] +## round 6 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 133, "failed_attempts": 0, "first_recovery_seconds": 5.952} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +exit=0 +$ python scripts/lbctl.py replicas (after hook) +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f exited health=unhealthy pid=0 started=2026-10-25T11:08:37.062 ip=- +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 running health=healthy pid=33344 started=2026-10-25T11:06:00.330 ip=172.25.0.4,172.26.0.5,172.27.0.3 +$ sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 +mtusi-lab4-api-1 Up 6 seconds (healthy) +mtusi-lab4-api-2 Up 3 minutes (healthy) +2 API replica(s) UP in HAProxy after 0.7 s: ['05c02ec0a89f', '4ddc189deda2'] +## round 7 (one extra GET /health/live first: shifts HAProxy round-robin so the OTHER replica serves the test's first message) +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 133, "failed_attempts": 0, "first_recovery_seconds": 6.146} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +exit=0 +$ python scripts/lbctl.py replicas (after hook) +mtusi-lab4-api-1 X-Instance-Id=05c02ec0a89f running health=healthy pid=42280 started=2026-10-25T11:09:03.178 ip=172.25.0.3,172.26.0.4,172.27.0.2 +mtusi-lab4-api-2 X-Instance-Id=4ddc189deda2 exited health=unhealthy pid=0 started=2026-10-25T11:06:00.330 ip=- +$ sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 +mtusi-lab4-api-1 Up 42 seconds (healthy) +mtusi-lab4-api-2 Up 6 seconds (healthy) +2 API replica(s) UP in HAProxy after 0.6 s: ['05c02ec0a89f', '4ddc189deda2'] diff --git a/evidence/test-persistence.txt b/evidence/test-persistence.txt new file mode 100644 index 00000000..af90fa69 --- /dev/null +++ b/evidence/test-persistence.txt @@ -0,0 +1,19 @@ +# 2026-10-25T11:05:12Z commit a2d867b +$ docker compose ps (before) +mtusi-lab4-api-1 Up 15 minutes (healthy) +mtusi-lab4-api-2 Up 15 minutes (healthy) +mtusi-lab4-lb-1 Up 21 minutes (healthy) +mtusi-lab4-postgres-1 Up 2 minutes (healthy) +mtusi-lab4-s3-1 Up 2 minutes (healthy) +mtusi-lab4-valkey-1 Up 21 minutes (healthy) +$ python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +exit=0 +$ docker compose ps (after: StartedAt of every container) +/mtusi-lab4-api-1 started=2026-10-25T11:05:59.978502661Z restarts=0 +/mtusi-lab4-api-2 started=2026-10-25T11:06:00.330525085Z restarts=0 +/mtusi-lab4-lb-1 started=2026-10-25T11:06:09.717330457Z restarts=0 +/mtusi-lab4-postgres-1 started=2026-10-25T11:05:20.208770445Z restarts=0 +/mtusi-lab4-s3-1 started=2026-10-25T11:05:40.143650484Z restarts=0 +/mtusi-lab4-valkey-1 started=2026-10-25T11:05:20.150545076Z restarts=0 diff --git a/infra/seaweedfs/start.sh b/infra/seaweedfs/start.sh index 80446b55..ad4f09c5 100755 --- a/infra/seaweedfs/start.sh +++ b/infra/seaweedfs/start.sh @@ -30,11 +30,16 @@ cat > /tmp/s3.json < int: log.run(["docker", "compose", "--env-file", ".env", "up", "-d", "--build", "--wait"], timeout=1800) log.run(["docker", "compose", "ps", "-a", "--format", "table {{.Service}}\t{{.Image}}\t{{.Status}}"]) log.run(["docker", "compose", "logs", "--no-log-prefix", "migrate"]) + log.run(["docker", "compose", "logs", "--no-log-prefix", "s3-init"]) # bucket + access-model verdicts log.run([PYTHON, "scripts/lbctl.py", "replicas"]); log.run([PYTHON, "scripts/lbctl.py", "status"]) # venv for validate / own tests if not Path(VENV_PY).exists(): @@ -109,11 +111,11 @@ def main() -> int: log.run([make, "test", f"PYTHON={MAKE_PY}"], shown="make test") # 3. persistence with states before/after - log = Log("test-persistence.txt", "make test-persistence: restart of LB, all API replicas, PostgreSQL, Valkey") + log = Log("test-persistence.txt", "make test-persistence: restart of LB, all API replicas, PostgreSQL, Valkey, S3") log.note("Containers BEFORE:\n" + "\n".join(states())) log.run([make, "test-persistence", f"ACTION_SCRIPT=scripts/restart{HOOK}", f"PYTHON={MAKE_PY}"], shown=f"make test-persistence ACTION_SCRIPT=scripts/restart{HOOK}") - log.note("Containers AFTER (new pid/started for lb, api-*, postgres, valkey; volumes kept):\n" + "\n".join(states())) + log.note("Containers AFTER (new pid/started for lb, api-*, postgres, valkey, s3; volumes kept):\n" + "\n".join(states())) log.run([PYTHON, "scripts/lbctl.py", "wait-up", "2"]) # 4. failover: until BOTH replicas have been the stopped one (each run is a real public test) @@ -147,10 +149,11 @@ def main() -> int: log.run([VENV_PY, "-m", "pytest", "student-tests", "-v", "-p", "no:cacheprovider"], shown="python -m pytest student-tests -v", timeout=3600) - # 6. level 4 experiments and the public load script - log = Log("level4-runs.txt", "Level 4: failover series, rolling update under load, public load.py") - log.run([PYTHON, "bench/failover_series.py", "--output", "evidence/failover"], timeout=1800) - log.run([PYTHON, "bench/rolling_under_load.py", "--output", "evidence/rolling-update"], timeout=1800) + # 6. lab 4 experiments (level 4 memory, track 2 reconciler) and the public load script + log = Log("lab4-runs.txt", "Lab 4: memory under 16 simultaneous uploads, reconciler faults + cost, load.py") + log.run([VENV_PY, "bench/upload_memory.py", "--output", "evidence/memory"], timeout=3600) + log.run([VENV_PY, "bench/reconcile_faults.py", "--output", "evidence/reconcile"], timeout=1800) + log.run([VENV_PY, "bench/reconcile_cost.py", "--output", "evidence/reconcile"], timeout=3600) log.run([PYTHON, "scripts/lbctl.py", "wait-up", "2"]) log.run([PYTHON, "tests/load.py", "--duration", "30", "--concurrency", "4", "--output", "evidence/load.json"]) log.run(["docker", "compose", "ps", "-a", "--format", "table {{.Service}}\t{{.Status}}"]) diff --git a/scripts/demo_attachments.py b/scripts/demo_attachments.py new file mode 100644 index 00000000..2d1902fe --- /dev/null +++ b/scripts/demo_attachments.py @@ -0,0 +1,126 @@ +#!/usr/bin/env python3 +"""Defense scenario, steps 1-2 (README): upload the fixture, send a message with attachment_ids, +download as the second member and compare SHA-256; the outsider gets 404; an unauthenticated +request straight to S3 (from inside the storage network) is refused, the signed one works. + + python scripts/demo_attachments.py [--base-url http://127.0.0.1:8080] + +Prints requests and answers; never prints tokens or keys. Creates synthetic users. +""" +from __future__ import annotations + +import argparse +import base64 +import hashlib +import json +import subprocess +import sys +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +FIXTURE = ROOT / "tests" / "fixtures" / "sample.png" +PASSWORD = "Demo-password-Ω-12345" + + +class Client: + def __init__(self, base: str): + self.base = base.rstrip("/") + + def call(self, method: str, path: str, *, token: str | None = None, body=None, raw: bytes | None = None, + headers: dict | None = None) -> tuple[int, dict, bytes]: + h = dict(headers or {}) + if token: + h["Authorization"] = "Bearer " + token + data = raw + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode() + h["Content-Type"] = "application/json" + req = urllib.request.Request(self.base + path, data=data, method=method, headers=h) + try: + with urllib.request.urlopen(req, timeout=30) as r: + return r.status, dict(r.headers), r.read() + except urllib.error.HTTPError as e: + return e.code, dict(e.headers), e.read() + + +def show(label: str, status: int, headers: dict, payload: bytes, *, binary: bool = False) -> None: + inst = headers.get("X-Instance-Id", "-") + if binary: + text = f"{len(payload)} bytes, Content-Type {headers.get('Content-Type')}" + else: + text = payload.decode("utf-8", "replace")[:300] + print(f" {label:58} -> {status} [X-Instance-Id {inst}] {text}") + + +def user(c: Client, label: str) -> dict: + name = f"{label}_{uuid.uuid4().hex[:8]}" + status, _, body = c.call("POST", "/api/v1/users", body={"username": name, "display_name": label.title(), + "password": PASSWORD}) + assert status == 201, body + basic = base64.b64encode(f"{name}:{PASSWORD}".encode()).decode() + status, _, body = c.call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic}) + session = json.loads(body) + return {"id": session["user"]["id"], "token": session["token"], "name": name} + + +def main() -> int: + p = argparse.ArgumentParser() + p.add_argument("--base-url", default="http://127.0.0.1:8080") + args = p.parse_args() + c = Client(args.base_url) + content = FIXTURE.read_bytes() + print(f"fixture {FIXTURE.name}: {len(content)} bytes, sha256 {hashlib.sha256(content).hexdigest()}") + alice, bob, eve = user(c, "alice"), user(c, "bob"), user(c, "eve") + print(f"users: alice, bob (members), eve (outsider)") + status, _, body = c.call("POST", "/api/v1/chats", token=alice["token"], + body={"title": "Демо lab4", "member_ids": [alice["id"], bob["id"]]}) + chat = json.loads(body) + + print("\n1. upload -> message -> download by the second member") + st, h, b = c.call("POST", f"/api/v1/chats/{chat['id']}/attachments?filename=sample.png", token=alice["token"], + raw=content, headers={"Content-Type": "image/png"}) + show("POST /chats/{id}/attachments (alice, raw PNG)", st, h, b) + att = json.loads(b) + st, h, b = c.call("POST", f"/api/v1/chats/{chat['id']}/messages", token=alice["token"], + body={"text": "", "attachment_ids": [att["id"]]}, headers={"Idempotency-Key": uuid.uuid4().hex}) + show("POST /chats/{id}/messages text='' attachment_ids=[id]", st, h, b) + st, h, b = c.call("GET", f"/api/v1/attachments/{att['id']}", token=bob["token"]) + show("GET /attachments/{id} (bob)", st, h, b) + st, h, got = c.call("GET", f"/api/v1/attachments/{att['id']}/content", token=bob["token"]) + show("GET /attachments/{id}/content (bob)", st, h, got, binary=True) + same = hashlib.sha256(got).hexdigest() == hashlib.sha256(content).hexdigest() == att["sha256"] + print(f" SHA-256 of the download == fixture == metadata: {same}") + + print("\n2. outsider and direct S3 access") + for suffix in ("", "/content"): + st, h, b = c.call("GET", f"/api/v1/attachments/{att['id']}{suffix}", token=eve["token"]) + show(f"GET /attachments/{{id}}{suffix} (eve, not a member)", st, h, b) + key = subprocess.run(["docker", "compose", "exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", + "-At", "-c", f"SELECT object_key FROM attachments WHERE id = '{att['id']}'"], + cwd=ROOT, capture_output=True, text=True, check=True).stdout.strip() + print(f" object key in PostgreSQL: {key} (random; not in any API response: " + f"{key not in json.dumps(att)})") + probe = ( + "import urllib.request as u, urllib.error as e, asyncio\n" + "def st(url):\n" + " try: return u.urlopen(url, timeout=3).status\n" + " except e.HTTPError as x: return x.code\n" + f"print('anonymous GET http://s3:8333/messenger-attachments/{key} ->', st('http://s3:8333/messenger-attachments/{key}'))\n" + "print('anonymous LIST http://s3:8333/messenger-attachments?list-type=2 ->', st('http://s3:8333/messenger-attachments?list-type=2'))\n" + "from messenger.config import Settings\nfrom messenger.storage import Storage\n" + "async def m():\n s = Storage(Settings.from_env()); await s.open()\n" + f" print('signed HEAD with the API key pair ->', (await s.head('{key}')).size, 'bytes'); await s.close()\n" + "asyncio.run(m())\n") + out = subprocess.run(["docker", "compose", "exec", "-T", "api", "python", "-c", probe], cwd=ROOT, + capture_output=True, text=True).stdout + for line in out.splitlines(): + print(" (inside network storage) " + line) + print(" S3 is not published on the host at all: only the LB has ports (127.0.0.1:8080, 8404).") + return 0 if same else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/messenger/app.py b/src/messenger/app.py index 9d04791d..4eecea38 100644 --- a/src/messenger/app.py +++ b/src/messenger/app.py @@ -382,14 +382,14 @@ async def upload_attachment(request: Request) -> JSONResponse: await repo.ensure_member(db, user_id, chat_id) # outsiders: 404 before anything about the body filename = validation.filename_param(validation.query_items(request.scope["query_string"])) declared = attachments.declared_type(request) - attachments.declared_length(request, settings.max_upload_bytes) + length = attachments.declared_length(request, settings.max_upload_bytes) slots: asyncio.Semaphore = request.app.state.upload_slots try: await asyncio.wait_for(slots.acquire(), settings.upload_queue_timeout_seconds) except asyncio.TimeoutError: raise attachments.Busy("Слишком много одновременных загрузок, повторите позже") from None try: - upload = await attachments.read_image(reader, settings, declared, request.app.state.verify_slots) + upload = await attachments.read_image(reader, settings, declared, request.app.state.verify_slots, length) finally: slots.release() except ApiError: diff --git a/src/messenger/attachments.py b/src/messenger/attachments.py index f6a95e57..ec670a60 100644 --- a/src/messenger/attachments.py +++ b/src/messenger/attachments.py @@ -164,7 +164,7 @@ class Busy(Unavailable): @dataclass class Upload: - data: bytes + data: bytearray info: images.ImageInfo sha256: bytes @@ -227,14 +227,19 @@ def declared_length(request: Request, limit: int) -> int | None: return length -async def read_image(reader: BodyReader, settings: Settings, declared: str, verify_slots: asyncio.Semaphore) -> Upload: - """Body -> verified image. Memory: at most MAX_UPLOAD_BYTES per upload (bytearray); the format - and the pixel count are known after the first bytes, so a picture that is too big or not a - PNG/JPEG is rejected without reading/decoding the rest.""" +async def read_image(reader: BodyReader, settings: Settings, declared: str, verify_slots: asyncio.Semaphore, + length: int | None) -> Upload: + """Body -> verified image. Memory: ONE buffer of at most MAX_UPLOAD_BYTES per upload - exactly + Content-Length bytes allocated once when the length is declared (no growth, no final copy); + it is passed as is to the checks and to the S3 PUT. The format and the pixel count are known + after the first bytes, so a picture that is too big or not a PNG/JPEG is rejected without + reading/decoding the rest.""" loop = asyncio.get_running_loop() deadline = loop.time() + settings.upload_read_timeout_seconds limit = settings.max_upload_bytes - buffer = bytearray() + buffer = bytearray(length) if length else bytearray() + view = memoryview(buffer) if length else None + filled = 0 digest = hashlib.sha256() info: images.ImageInfo | None = None while True: @@ -247,27 +252,36 @@ async def read_image(reader: BodyReader, settings: Settings, declared: str, veri raise InvalidRequest("Тело запроса не получено вовремя") from None if chunk is None: break - if len(buffer) + len(chunk) > limit: + if filled + len(chunk) > (length or limit): raise PayloadTooLarge(f"Файл больше {limit} байт") - buffer += chunk + if view is not None: + view[filled:filled + len(chunk)] = chunk + else: + buffer += chunk + filled += len(chunk) digest.update(chunk) - if info is None and buffer: - info = _sniff(buffer, settings, declared) - if not buffer: + if info is None and filled: + info = _sniff(view[:filled] if view is not None else buffer, settings, declared) + if view is not None: + view.release() + if not filled: raise InvalidRequest("Тело запроса пустое: нужны байты изображения") + if length and filled != length: + raise InvalidRequest("Тело запроса короче Content-Length") if info is None: raise UnsupportedMediaType("Файл не является корректным изображением PNG или JPEG") - data = bytes(buffer) - del buffer try: async with verify_slots: - await images.verify(data, info, timeout=settings.image_verify_timeout_seconds, + await images.verify(buffer, info, timeout=settings.image_verify_timeout_seconds, jpeg_max_memory_mb=settings.jpeg_max_memory_mb) except images.ImageError as exc: raise _image_error(exc) from None except asyncio.TimeoutError: raise UnsupportedMediaType("Изображение не удалось проверить за отведённое время") from None - return Upload(data, info, digest.digest()) + except (images.VerifierUnavailable, MemoryError): + log.warning("image_verifier_unavailable", extra={"fields": {"type": info.content_type, "size": filled}}) + raise Busy("Не хватило ресурсов для проверки изображения, повторите позже") from None + return Upload(buffer, info, digest.digest()) def _sniff(buffer: bytearray, settings: Settings, declared: str) -> images.ImageInfo | None: diff --git a/src/messenger/images.py b/src/messenger/images.py index 4e1a6fba..7169c0c2 100644 --- a/src/messenger/images.py +++ b/src/messenger/images.py @@ -45,6 +45,7 @@ JPEG_SOF = {0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0x JPEG_STANDALONE = {0x01, *range(0xD0, 0xD8)} DJPEG = shutil.which("djpeg") or "djpeg" # libjpeg-turbo-progs, installed in the Dockerfile +INPUT_STEP = 1 << 16 # compressed bytes handed to zlib at once INFLATE_STEP = 1 << 20 # bytes of raw PNG data produced per zlib call MAX_DIMENSION = 2**31 - 1 @@ -58,7 +59,11 @@ class ImageError(Exception): self.message = message -def unsupported(message: str = "Файл не является корректным изображением PNG или JPEG") -> ImageError: +class VerifierUnavailable(Exception): + """The checker itself could not run to the end (resources): the API answers 503, retryable.""" + + +def unsupported(message: str ="Файл не является корректным изображением PNG или JPEG") -> ImageError: return ImageError(415, message) @@ -274,16 +279,18 @@ def _inflate(inflater, body: memoryview, checker: _RawChecker) -> None: if len(body): raise unsupported() # data after the end of the zlib stream return - pending: bytes | memoryview = body + # Input is fed in small slices: zlib's `unconsumed_tail` is a COPY of the unread input, so + # feeding the whole 10 MiB IDAT at once would copy the rest of it after every output step. try: - while pending: - piece = inflater.decompress(pending, INFLATE_STEP) - checker.feed(piece) - pending = inflater.unconsumed_tail - if inflater.eof: - if pending or inflater.unused_data: - raise unsupported() - break + for start in range(0, len(body), INPUT_STEP): + pending: bytes | memoryview = body[start:start + INPUT_STEP] + while pending: + if inflater.eof: + raise unsupported() # data after the end of the zlib stream + checker.feed(inflater.decompress(pending, INFLATE_STEP)) + pending = inflater.unconsumed_tail + if inflater.eof and inflater.unused_data: + raise unsupported() except zlib.error: raise unsupported() from None @@ -303,13 +310,17 @@ async def verify_jpeg(data: bytes | bytearray | memoryview, timeout: float, max_ stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.PIPE) stderr = b"" try: - _, stderr = await asyncio.wait_for(process.communicate(bytes(data)), timeout) + _, stderr = await asyncio.wait_for(process.communicate(data), timeout) except (asyncio.TimeoutError, asyncio.CancelledError): process.kill() await process.wait() raise except (BrokenPipeError, ConnectionResetError): await process.wait() # djpeg stopped reading: the file is already known to be broken + if process.returncode is not None and process.returncode < 0: + # Killed by a signal (the cgroup OOM killer under memory pressure): a problem of the + # SERVER, not of the file - never report it as 415. + raise VerifierUnavailable() if process.returncode != 0: if b"Insufficient memory" in (stderr or b""): # A valid but extremely memory-hungry file (progressive, 4:4:4, ~40 Mpx): a limit, not corruption. diff --git a/src/messenger/storage.py b/src/messenger/storage.py index f9d42d1a..67f39d0f 100644 --- a/src/messenger/storage.py +++ b/src/messenger/storage.py @@ -111,7 +111,7 @@ class Storage: # Time budget grows with the size: 10 MiB over a local network takes well under a second. deadline = self.timeout + len(data) / (8 * 1024 * 1024) await self._call("put", self.client.put_object( - Bucket=self.bucket, Key=key, Body=bytes(data), ContentType=content_type, ContentLength=len(data), + Bucket=self.bucket, Key=key, Body=data, ContentType=content_type, ContentLength=len(data), ContentMD5=md5, Metadata=metadata), deadline) async def head(self, key: str) -> ObjectHead: