forked from mtusi2026/mtusi2026lab5
186 lines
5.9 KiB
Python
186 lines
5.9 KiB
Python
import argparse
|
|
import base64
|
|
import io
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import uuid
|
|
from pathlib import Path
|
|
|
|
import httpx
|
|
from PIL import Image
|
|
|
|
BASE = "http://localhost:8080"
|
|
COMPOSE = ["docker", "compose", "--env-file", ".env"]
|
|
EVIDENCE = Path(__file__).resolve().parent.parent / "evidence"
|
|
WORKER_CONTAINER = "mtusi2026lab5-worker-1"
|
|
SIZES = {
|
|
"small": (320, 200),
|
|
"medium": (1280, 800),
|
|
"large": (4000, 3000),
|
|
}
|
|
|
|
|
|
def _png(size):
|
|
buf = io.BytesIO()
|
|
Image.new("RGB", size, (64, 128, 192)).save(buf, format="PNG")
|
|
return buf.getvalue()
|
|
|
|
|
|
def _user(c):
|
|
u = "qb_" + uuid.uuid4().hex[:10]
|
|
p = "Test-password-1234"
|
|
c.post(f"{BASE}/api/v1/users", json={"username": u, "display_name": "Q", "password": p})
|
|
cred = base64.b64encode(f"{u}:{p}".encode()).decode()
|
|
s = c.post(f"{BASE}/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}).json()
|
|
return {"id": s["user"]["id"], "token": s["token"]}
|
|
|
|
|
|
def _auth(a):
|
|
return {"Authorization": "Bearer " + a["token"]}
|
|
|
|
|
|
def _worker_mem():
|
|
out = subprocess.run(
|
|
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", WORKER_CONTAINER],
|
|
capture_output=True, text=True,
|
|
).stdout.strip()
|
|
if not out or "/" not in out:
|
|
return None
|
|
v = out.split("/")[0].strip()
|
|
units = {"B": 1, "KiB": 1024, "Ki": 1024, "MiB": 1024**2, "Mi": 1024**2,
|
|
"GiB": 1024**3, "Gi": 1024**3}
|
|
for u in sorted(units, key=len, reverse=True):
|
|
if v.endswith(u):
|
|
return round(int(float(v[: -len(u)]) * units[u]) / 1024**2, 1)
|
|
return None
|
|
|
|
|
|
def _restart_worker(prefetch):
|
|
env = dict(os.environ)
|
|
env["PREFETCH_COUNT"] = str(prefetch)
|
|
subprocess.run(
|
|
COMPOSE + ["up", "-d", "--force-recreate", "worker"],
|
|
env=env, check=True,
|
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
|
)
|
|
time.sleep(5)
|
|
|
|
|
|
def _start_worker(prefetch):
|
|
env = dict(os.environ)
|
|
env["PREFETCH_COUNT"] = str(prefetch)
|
|
subprocess.run(
|
|
COMPOSE + ["up", "-d", "--force-recreate", "worker"],
|
|
env=env, check=True,
|
|
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
|
)
|
|
|
|
|
|
def _percentiles(values, ps=(0.5, 0.95, 0.99)):
|
|
if not values:
|
|
return {f"p{int(p*100)}": None for p in ps}
|
|
s = sorted(values)
|
|
return {f"p{int(p*100)}": round(s[max(0, int(len(s)*p)-1)], 3) for p in ps}
|
|
|
|
|
|
def run(prefetch, size_name, files, output):
|
|
size = SIZES[size_name]
|
|
data = _png(size)
|
|
with httpx.Client(timeout=30) as c:
|
|
a = _user(c)
|
|
b = _user(c)
|
|
chat = c.post(
|
|
f"{BASE}/api/v1/chats",
|
|
json={"title": f"qb-{prefetch}-{size_name}", "member_ids": [a["id"], b["id"]]},
|
|
headers=_auth(a),
|
|
).json()
|
|
chat_id = chat["id"]
|
|
|
|
_restart_worker(prefetch)
|
|
|
|
uploads = []
|
|
started = time.monotonic()
|
|
with httpx.Client(timeout=30) as c:
|
|
for i in range(files):
|
|
t = time.monotonic()
|
|
r = c.post(
|
|
f"{BASE}/api/v1/chats/{chat_id}/attachments",
|
|
params={"filename": f"f{i}.png"},
|
|
content=data,
|
|
headers={**_auth(a), "Content-Type": "image/png"},
|
|
)
|
|
if r.status_code != 202:
|
|
print(f"upload failed: {r.status_code} {r.text[:100]}", file=sys.stderr)
|
|
continue
|
|
uploads.append({"id": r.json()["id"], "t_upload": t})
|
|
|
|
states = {u["id"]: {"t_upload": u["t_upload"], "t_processing": None, "t_ready": None}
|
|
for u in uploads}
|
|
deadline = time.monotonic() + 600
|
|
pending = set(states)
|
|
with httpx.Client(timeout=10) as c:
|
|
while pending and time.monotonic() < deadline:
|
|
for att_id in list(pending):
|
|
r = c.get(f"{BASE}/api/v1/attachments/{att_id}", headers=_auth(a))
|
|
if r.status_code != 200:
|
|
continue
|
|
st = r.json()["status"]
|
|
now = time.monotonic()
|
|
if st == "processing" and states[att_id]["t_processing"] is None:
|
|
states[att_id]["t_processing"] = now
|
|
if st in ("ready", "failed"):
|
|
if states[att_id]["t_processing"] is None:
|
|
states[att_id]["t_processing"] = now
|
|
states[att_id]["t_ready"] = now
|
|
pending.discard(att_id)
|
|
if pending:
|
|
time.sleep(0.2)
|
|
|
|
finished = time.monotonic()
|
|
rss = _worker_mem()
|
|
|
|
queue_lags = [
|
|
s["t_processing"] - s["t_upload"]
|
|
for s in states.values() if s["t_processing"] is not None
|
|
]
|
|
ready_times = [
|
|
s["t_ready"] - s["t_upload"]
|
|
for s in states.values() if s["t_ready"] is not None
|
|
]
|
|
duration = finished - started
|
|
ok = len(ready_times)
|
|
report = {
|
|
"prefetch": prefetch,
|
|
"size": size_name,
|
|
"files_requested": files,
|
|
"files_ok": ok,
|
|
"files_failed": files - ok,
|
|
"duration_s": round(duration, 3),
|
|
"throughput_files_per_s": round(ok / duration, 3) if duration else None,
|
|
"queue_lag_s": _percentiles(queue_lags),
|
|
"time_to_ready_s": _percentiles(ready_times),
|
|
"worker_rss_mib": rss,
|
|
}
|
|
out = Path(output)
|
|
out.parent.mkdir(parents=True, exist_ok=True)
|
|
out.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")
|
|
print(json.dumps(report, indent=2, ensure_ascii=False))
|
|
_start_worker(prefetch)
|
|
return report
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--prefetch", type=int, required=True)
|
|
parser.add_argument("--size", choices=list(SIZES), required=True)
|
|
parser.add_argument("--files", type=int, default=50)
|
|
parser.add_argument("--output", required=True)
|
|
args = parser.parse_args()
|
|
run(args.prefetch, args.size, args.files, args.output)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() |