#!/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')) from lab7_http import BASE_URL, CA_FILE # noqa: E402 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=BASE_URL) parser.add_argument('--ca-file', default=CA_FILE) 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, args.ca_file or CA_FILE, 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, args.ca_file or CA_FILE, 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, args.ca_file or CA_FILE, 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())