Files
2026-11-06 17:30:30 +03:00

185 lines
7.2 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'))
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())