#!/usr/bin/env python3 """Open-loop lab6 load: fixed arrival rate, messages and attachment uploads. Unlike tests/load.py this schedules arrivals instead of running a closed loop, so a degraded server cannot reduce the offered rate. It is intentionally small and standard-library only; use k6/wrk2 for capacity claims. """ import argparse import base64 import os import json import math import re import sys import threading import time import urllib.request import uuid from pathlib import Path # The lab tools always target loopback; ignore ambient corporate proxies. for _proxy_key in ('HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'http_proxy', 'https_proxy', 'all_proxy'): os.environ.pop(_proxy_key, None) os.environ['NO_PROXY'] = 'localhost,127.0.0.1,::1' os.environ['no_proxy'] = 'localhost,127.0.0.1,::1' urllib.request.getproxies = lambda: {} ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'tests')) def percentile(values, p): if not values: return None values = sorted(values) rank = max(0, min(len(values) - 1, int(math.ceil(p / 100.0 * len(values))) - 1)) return values[rank] def main(): parser = argparse.ArgumentParser(description='Open-loop lab6 load') parser.add_argument('--base-url', default='http://localhost:8080') parser.add_argument('--rate', type=float, default=1.0, help='arrivals per second') parser.add_argument('--duration', type=float, default=60.0, help='seconds') parser.add_argument('--upload-ratio', type=float, default=0.25) parser.add_argument('--deadline', type=float, default=60.0) parser.add_argument('--workers', type=int, default=32) parser.add_argument('--output', default=None) parser.add_argument('--token-refresh-seconds', type=float, default=2400.0) args = parser.parse_args() from client import Client, Failure bootstrap = Client(args.base_url, timeout=args.deadline) alice, _, _, chat = bootstrap.bootstrap() lock = threading.Lock() token_lock = threading.Lock() last_refresh = [time.monotonic()] def refresh_session(): # Sessions live one hour; refresh well before expiry so a 70m warmup # does not turn into 401s halfway through. if time.monotonic() - last_refresh[0] < args.token_refresh_seconds: return with token_lock: if time.monotonic() - last_refresh[0] < args.token_refresh_seconds: return registration = alice['registration'] credential = base64.b64encode( (registration['username'] + ':' + registration['password']).encode()).decode() refresher = Client(args.base_url, timeout=args.deadline) session = refresher.call( 'POST', '/api/v1/auth/sessions', 201, headers={'Authorization': 'Basic ' + credential}, schema='Session')['json'] alice['token'] = session['token'] last_refresh[0] = time.monotonic() latencies, ttr, failures = [], [], [] counters = {'accepted': 0, 'ready': 0, 'failed': 0, 'messages': 0, 'uploads': 0, 'dropped': 0} failures_by_reason = {} sem = threading.Semaphore(args.workers) def failure_reason(detail): match = re.search(r'received (\d{3})', detail) if match: return 'http_' + match.group(1) return detail.split(':', 1)[0].strip() or 'unknown' def record(kind, elapsed, ok, detail=''): with lock: if kind == 'message': counters['messages'] += 1 if ok: latencies.append(elapsed) else: reason = failure_reason(detail) counters['failed'] += 1 failures_by_reason[reason] = failures_by_reason.get(reason, 0) + 1 failures.append(detail) else: if ok: counters['ready'] += 1 ttr.append(elapsed) else: reason = failure_reason(detail) counters['failed'] += 1 failures_by_reason[reason] = failures_by_reason.get(reason, 0) + 1 failures.append(detail) def run_one(kind, index): client = Client(args.base_url, timeout=args.deadline) started = time.monotonic() try: refresh_session() if kind == 'message': client.message(alice, chat, 'lab6 load %d %s' % (index, uuid.uuid4().hex[:8])) record(kind, time.monotonic() - started, True) else: att, _ = client.attachment(alice, chat) with lock: counters['uploads'] += 1 counters['accepted'] += 1 try: client.wait_ready(alice, att, wait_seconds=args.deadline) record(kind, time.monotonic() - started, True) except Exception as exc: with lock: reason = failure_reason(str(exc)) counters['failed'] += 1 failures_by_reason[reason] = failures_by_reason.get(reason, 0) + 1 failures.append('ready: ' + type(exc).__name__ + ': ' + str(exc)[:120]) except Exception as exc: record(kind, time.monotonic() - started, False, type(exc).__name__ + ': ' + str(exc)[:120]) finally: sem.release() total = max(0, int(args.rate * args.duration)) started = time.monotonic() threads = [] for index in range(total): target = started + index / max(args.rate, 0.001) delay = target - time.monotonic() if delay > 0: time.sleep(delay) if not sem.acquire(blocking=False): with lock: counters['dropped'] += 1 continue kind = 'upload' if ((index * 37) % 100) < int(args.upload_ratio * 100) else 'message' thread = threading.Thread(target=run_one, args=(kind, index), daemon=True) threads.append(thread) thread.start() for thread in threads: thread.join() summary = { 'base_url': args.base_url, 'rate': args.rate, 'duration_s': round(time.monotonic() - started, 2), 'scheduled': total, 'counters': counters, 'failures': len(failures), 'failures_by_reason': dict(sorted(failures_by_reason.items())), 'failure_samples': failures[:10], 'latency_ms': { 'p50': round(percentile(latencies, 50) * 1000, 1) if latencies else None, 'p95': round(percentile(latencies, 95) * 1000, 1) if latencies else None, 'p99': round(percentile(latencies, 99) * 1000, 1) if latencies else None, }, 'ttr_ms': { 'p50': round(percentile(ttr, 50) * 1000, 1) if ttr else None, 'p95': round(percentile(ttr, 95) * 1000, 1) if ttr else None, 'p99': round(percentile(ttr, 99) * 1000, 1) if ttr else None, }, } if args.output: Path(args.output).parent.mkdir(parents=True, exist_ok=True) Path(args.output).write_text(json.dumps(summary, indent=2) + '\n') print(json.dumps(summary, indent=2)) return 0 if not failures else 1 if __name__ == '__main__': raise SystemExit(main())