lab4: память загрузок и S3 под лимитом, документация защиты
- тело загрузки: один буфер ровно 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 <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5.5
parent
a2d867bec6
commit
4ea6924db1
+1
-1
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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())
|
||||
+36
-7
@@ -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))
|
||||
|
||||
+6
-1
@@ -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
|
||||
|
||||
@@ -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/<key> (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.
|
||||
+6
-2
@@ -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 |
|
||||
|
||||
@@ -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 до и после.
|
||||
+50
-66
@@ -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` (данные удаляются).
|
||||
|
||||
@@ -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']
|
||||
@@ -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
|
||||
@@ -30,11 +30,16 @@ cat > /tmp/s3.json <<EOF
|
||||
]
|
||||
}
|
||||
EOF
|
||||
# Memory: by default SeaweedFS buffers every in-flight upload without a limit and the Go runtime
|
||||
# keeps freed heap; measured ~1 GB under 16 parallel 9.4 MiB PUTs (evidence/memory). The upload
|
||||
# limits make excess PUTs wait inside SeaweedFS instead of growing the heap, and GOMEMLIMIT (set
|
||||
# in compose.yaml below the container limit) makes the Go GC return memory before the cgroup OOM.
|
||||
exec weed server \
|
||||
-dir=/data \
|
||||
-ip=127.0.0.1 -ip.bind=127.0.0.1 \
|
||||
-master.telemetry=false \
|
||||
-master.volumeSizeLimitMB=1024 -volume.max=0 \
|
||||
-filer -filer.disableDirListing \
|
||||
-s3 -s3.ip.bind=0.0.0.0 -s3.port=8333 -s3.config=/tmp/s3.json \
|
||||
-filer -filer.disableDirListing -filer.concurrentUploadLimitMB=128 \
|
||||
-volume.concurrentUploadLimitMB=128 \
|
||||
-s3 -s3.ip.bind=0.0.0.0 -s3.port=8333 -s3.config=/tmp/s3.json -s3.concurrentUploadLimitMB=128 \
|
||||
-s3.iam=false -s3.autoCreateBucket=false -s3.port.iceberg=0 -s3.port.lance=0
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Run every check of REPORT.md on the current checkout and save the real output in evidence/.
|
||||
|
||||
python scripts/collect_evidence.py # ~25 min; the stand must NOT be running yet
|
||||
python scripts/collect_evidence.py # ~60 min; the stand must NOT be running yet
|
||||
|
||||
Intended for a CLEAN CLONE (fresh volumes): it creates secrets and .env, builds and starts the
|
||||
stand, then runs make check/validate/test/test-persistence/test-failover, the own tests, the
|
||||
level 4 experiments, and records container states before/after every hook. Prints no secrets
|
||||
lab 4 experiments (memory under concurrent uploads, reconciler faults and cost), and records
|
||||
container states before/after every hook. Prints no secrets
|
||||
(hook output is shown by the public tests as suppressed; our scripts print names and states only).
|
||||
On Windows the hooks are the scripts/*.cmd wrappers (Git Bash) and make needs Git's usr/bin.
|
||||
"""
|
||||
@@ -95,6 +96,7 @@ def main() -> 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}}"])
|
||||
|
||||
@@ -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())
|
||||
@@ -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:
|
||||
|
||||
@@ -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:
|
||||
|
||||
+22
-11
@@ -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.
|
||||
|
||||
@@ -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:
|
||||
|
||||
Reference in New Issue
Block a user