Files

187 lines
7.4 KiB
Python
Executable File

#!/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())