forked from mtusi2026/mtusi2026lab7
262 lines
9.7 KiB
Python
Executable File
262 lines
9.7 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import argparse
|
|
import base64
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
import secrets
|
|
import struct
|
|
import threading
|
|
import time
|
|
import urllib.error
|
|
import urllib.parse
|
|
import urllib.request
|
|
import zlib
|
|
|
|
MAX_RESPONSE_BYTES = 1 << 20
|
|
|
|
|
|
def png_fixture(width=96, height=64):
|
|
rows = []
|
|
for y in range(height):
|
|
pixels = bytearray()
|
|
for x in range(width):
|
|
pixels.extend(((x * 3) % 256, (y * 5) % 256, (x + y) % 256))
|
|
rows.append(b"\x00" + bytes(pixels))
|
|
raw = b"".join(rows)
|
|
|
|
def chunk(name, payload):
|
|
return struct.pack(">I", len(payload)) + name + payload + struct.pack(">I", zlib.crc32(name + payload) & 0xFFFFFFFF)
|
|
|
|
header = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
|
|
return b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", header) + chunk(b"IDAT", zlib.compress(raw, 6)) + chunk(b"IEND", b"")
|
|
|
|
|
|
def request(method, url, body=None, headers=None, timeout=10):
|
|
req = urllib.request.Request(url, data=body, method=method, headers=headers or {})
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=timeout) as response:
|
|
payload = response.read(MAX_RESPONSE_BYTES)
|
|
return response.status, payload
|
|
except urllib.error.HTTPError as error:
|
|
return error.code, error.read(MAX_RESPONSE_BYTES)
|
|
except urllib.error.URLError:
|
|
return 0, b""
|
|
|
|
|
|
def decode_json(payload):
|
|
return json.loads(payload.decode("utf-8"))
|
|
|
|
|
|
def json_request(method, url, value=None, token=None, headers=None):
|
|
request_headers = {"Accept": "application/json"}
|
|
body = None
|
|
if value is not None:
|
|
body = json.dumps(value, separators=(",", ":")).encode("utf-8")
|
|
request_headers["Content-Type"] = "application/json"
|
|
if token:
|
|
request_headers["Authorization"] = "Bearer " + token
|
|
if headers:
|
|
request_headers.update(headers)
|
|
status, payload = request(method, url, body, request_headers)
|
|
return status, decode_json(payload) if payload else {}
|
|
|
|
|
|
def bootstrap(base_url):
|
|
suffix = secrets.token_hex(6)
|
|
password = "Lab6-" + secrets.token_urlsafe(18)
|
|
users = []
|
|
for prefix in ("telemetry_a_", "telemetry_b_"):
|
|
username = prefix + suffix
|
|
status, user = json_request("POST", base_url + "/api/v1/users", {
|
|
"username": username,
|
|
"display_name": "Synthetic telemetry load",
|
|
"password": password,
|
|
})
|
|
if status != 201:
|
|
raise RuntimeError("register user returned HTTP %d" % status)
|
|
users.append((username, user["id"]))
|
|
|
|
credentials = base64.b64encode((users[0][0] + ":" + password).encode("utf-8")).decode("ascii")
|
|
status, payload = request("POST", base_url + "/api/v1/auth/sessions", headers={
|
|
"Authorization": "Basic " + credentials,
|
|
"Accept": "application/json",
|
|
})
|
|
if status != 201:
|
|
raise RuntimeError("create session returned HTTP %d" % status)
|
|
token = decode_json(payload)["token"]
|
|
|
|
status, chat = json_request("POST", base_url + "/api/v1/chats", {
|
|
"title": "Lab 6 synthetic telemetry",
|
|
"member_ids": [users[0][1], users[1][1]],
|
|
}, token)
|
|
if status != 201:
|
|
raise RuntimeError("create chat returned HTTP %d" % status)
|
|
return token, chat["id"]
|
|
|
|
|
|
class Results:
|
|
def __init__(self):
|
|
self.lock = threading.Lock()
|
|
self.latencies = []
|
|
self.statuses = {}
|
|
self.attachment_ids = []
|
|
|
|
def record(self, status, elapsed, attachment_id=None):
|
|
with self.lock:
|
|
self.latencies.append(elapsed)
|
|
key = str(status)
|
|
self.statuses[key] = self.statuses.get(key, 0) + 1
|
|
if attachment_id:
|
|
self.attachment_ids.append(attachment_id)
|
|
|
|
|
|
def percentile(values, quantile):
|
|
if not values:
|
|
return None
|
|
ordered = sorted(values)
|
|
index = max(0, math.ceil(quantile * len(ordered)) - 1)
|
|
return round(ordered[index] * 1000, 3)
|
|
|
|
|
|
def run_request(base_url, token, chat_id, mode, sequence, fixture):
|
|
if mode == "mixed":
|
|
mode = "attachments" if sequence % 3 == 0 else "messages"
|
|
started = time.monotonic()
|
|
if mode == "messages":
|
|
status, _ = json_request("POST", base_url + "/api/v1/chats/" + chat_id + "/messages", {
|
|
"text": "synthetic telemetry event",
|
|
"attachment_ids": [],
|
|
}, token, {"Idempotency-Key": secrets.token_hex(16)})
|
|
return status, time.monotonic() - started, None
|
|
|
|
upload_url = base_url + "/api/v1/chats/" + chat_id + "/attachments?" + urllib.parse.urlencode({
|
|
"filename": "synthetic.png",
|
|
})
|
|
status, payload = request("POST", upload_url, fixture, {
|
|
"Authorization": "Bearer " + token,
|
|
"Content-Type": "image/png",
|
|
"Accept": "application/json",
|
|
})
|
|
attachment_id = None
|
|
if status == 202:
|
|
attachment_id = decode_json(payload).get("id")
|
|
return status, time.monotonic() - started, attachment_id
|
|
|
|
|
|
def wait_for_attachments(base_url, token, attachment_ids, timeout):
|
|
remaining = set(attachment_ids)
|
|
states = {"ready": 0, "failed": 0, "timeout": 0}
|
|
deadline = time.monotonic() + timeout
|
|
while remaining and time.monotonic() < deadline:
|
|
for attachment_id in list(remaining):
|
|
status, metadata = json_request("GET", base_url + "/api/v1/attachments/" + attachment_id, token=token)
|
|
if status != 200:
|
|
continue
|
|
state = metadata.get("status")
|
|
if state in ("ready", "failed"):
|
|
states[state] += 1
|
|
remaining.remove(attachment_id)
|
|
if remaining:
|
|
time.sleep(0.25)
|
|
states["timeout"] = len(remaining)
|
|
return states
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="Bounded synthetic load for Lab 6 telemetry and incidents")
|
|
parser.add_argument("--base-url", default="http://127.0.0.1:8080")
|
|
parser.add_argument("--mode", choices=("messages", "attachments", "mixed"), default="mixed")
|
|
parser.add_argument("--duration", type=float, default=30)
|
|
parser.add_argument("--requests", type=int, default=0, help="Maximum requests; zero means duration only")
|
|
parser.add_argument("--concurrency", type=int, default=4)
|
|
parser.add_argument("--rate", type=float, default=0, help="Approximate aggregate request rate; zero is unthrottled")
|
|
parser.add_argument("--wait-ready", action="store_true")
|
|
parser.add_argument("--ready-timeout", type=float, default=120)
|
|
parser.add_argument("--output")
|
|
parser.add_argument("--started-file", help="Touch after synthetic session and chat are ready")
|
|
args = parser.parse_args()
|
|
|
|
if args.duration <= 0 or args.duration > 1800:
|
|
parser.error("duration must be in (0, 1800]")
|
|
if args.requests < 0:
|
|
parser.error("requests must be non-negative")
|
|
if args.concurrency < 1 or args.concurrency > 64:
|
|
parser.error("concurrency must be in [1, 64]")
|
|
if args.rate < 0 or args.rate > 1000:
|
|
parser.error("rate must be in [0, 1000]")
|
|
|
|
base_url = args.base_url.rstrip("/")
|
|
token, chat_id = bootstrap(base_url)
|
|
if args.started_file:
|
|
started_file = Path(args.started_file)
|
|
started_file.parent.mkdir(parents=True, exist_ok=True)
|
|
started_file.touch()
|
|
fixture = png_fixture()
|
|
results = Results()
|
|
next_sequence = 0
|
|
sequence_lock = threading.Lock()
|
|
deadline = time.monotonic() + args.duration
|
|
|
|
def worker():
|
|
nonlocal next_sequence
|
|
while time.monotonic() < deadline:
|
|
with sequence_lock:
|
|
if args.requests and next_sequence >= args.requests:
|
|
return
|
|
sequence = next_sequence
|
|
next_sequence += 1
|
|
status, elapsed, attachment_id = run_request(base_url, token, chat_id, args.mode, sequence, fixture)
|
|
results.record(status, elapsed, attachment_id)
|
|
if args.rate:
|
|
delay = args.concurrency / args.rate - elapsed
|
|
if delay > 0:
|
|
time.sleep(delay)
|
|
|
|
started = time.monotonic()
|
|
with ThreadPoolExecutor(max_workers=args.concurrency) as pool:
|
|
futures = [pool.submit(worker) for _ in range(args.concurrency)]
|
|
for future in futures:
|
|
future.result()
|
|
elapsed = time.monotonic() - started
|
|
|
|
attachment_states = None
|
|
if args.wait_ready and results.attachment_ids:
|
|
attachment_states = wait_for_attachments(base_url, token, results.attachment_ids, args.ready_timeout)
|
|
|
|
total = len(results.latencies)
|
|
successes = sum(count for status, count in results.statuses.items() if status.startswith("2"))
|
|
report = {
|
|
"schema_version": 1,
|
|
"workload": args.mode,
|
|
"started_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(time.time() - elapsed)),
|
|
"duration_seconds": round(elapsed, 3),
|
|
"concurrency": args.concurrency,
|
|
"requested_rate": args.rate or None,
|
|
"requests": total,
|
|
"successful_requests": successes,
|
|
"request_rate": round(total / elapsed, 3) if elapsed else None,
|
|
"status_counts": dict(sorted(results.statuses.items())),
|
|
"latency_ms": {
|
|
"p50": percentile(results.latencies, 0.50),
|
|
"p95": percentile(results.latencies, 0.95),
|
|
"p99": percentile(results.latencies, 0.99),
|
|
},
|
|
"attachments_accepted": len(results.attachment_ids),
|
|
"attachment_terminal_states": attachment_states,
|
|
}
|
|
encoded = json.dumps(report, ensure_ascii=False, indent=2) + "\n"
|
|
if args.output:
|
|
destination = Path(args.output)
|
|
destination.parent.mkdir(parents=True, exist_ok=True)
|
|
destination.write_text(encoded, encoding="utf-8")
|
|
print(encoded, end="")
|
|
if not total:
|
|
raise SystemExit("no requests were sent")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|