forked from mtusi2026/mtusi2026lab5
131 lines
4.7 KiB
Python
131 lines
4.7 KiB
Python
import json
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
import time
|
|
import uuid
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(ROOT / 'tests'))
|
|
from client import Client, Failure
|
|
|
|
PROJECT = 'mtusi-lab5'
|
|
|
|
|
|
def sh(*args, check=True):
|
|
r = subprocess.run(list(args), cwd=ROOT, capture_output=True, text=True, encoding='utf-8')
|
|
if check and r.returncode != 0:
|
|
raise RuntimeError('%s failed: %s' % (' '.join(args[:3]), r.stderr.strip()[:300]))
|
|
return r.stdout.strip()
|
|
|
|
|
|
def api_containers(all_states=False):
|
|
out = sh('docker', 'ps', *(['-a'] if all_states else []), '--no-trunc',
|
|
'--filter', 'label=com.docker.compose.project=' + PROJECT,
|
|
'--filter', 'label=com.docker.compose.service=api',
|
|
'--format', '{{json .}}')
|
|
rows = []
|
|
for line in out.splitlines():
|
|
d = json.loads(line)
|
|
rows.append({'id': d['ID'][:12], 'name': d['Names'], 'state': d['State'], 'status': d['Status']})
|
|
return sorted(rows, key=lambda r: r['name'])
|
|
|
|
|
|
def health(cid):
|
|
return sh('docker', 'inspect', '-f', '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}', cid)
|
|
|
|
|
|
def wait_healthy(cid, timeout=60):
|
|
deadline = time.monotonic() + timeout
|
|
while time.monotonic() < deadline:
|
|
if health(cid) == 'healthy':
|
|
return True
|
|
time.sleep(0.25)
|
|
return False
|
|
|
|
|
|
def ps_snapshot():
|
|
return sh('docker', 'compose', 'ps', '-a', '--format', '{{.Name}}\t{{.State}}\t{{.Status}}')
|
|
|
|
|
|
class WriteLoad:
|
|
|
|
def __init__(self, base_url, workers=8, timeout=2.0, pause=0.0):
|
|
self.base = base_url
|
|
self.workers = workers
|
|
self.timeout = timeout
|
|
self.pause = pause
|
|
self.events = []
|
|
self.confirmed = []
|
|
self.retries = 0
|
|
self._lock = threading.Lock()
|
|
self._stop = threading.Event()
|
|
self._threads = []
|
|
c = Client(base_url, timeout=10)
|
|
self.alice, self.bob, _eve, self.chat = c.bootstrap()
|
|
self.reader = c
|
|
|
|
def _worker(self, wid):
|
|
c = Client(self.base, timeout=self.timeout)
|
|
key = text = None
|
|
n = 0
|
|
while not self._stop.is_set():
|
|
if key is None:
|
|
key = uuid.uuid4().hex
|
|
text = 'load-%d-%d-%s' % (wid, n, key[:8])
|
|
start = time.monotonic()
|
|
try:
|
|
r = c.message(self.alice, self.chat, text, key=key)
|
|
with self._lock:
|
|
self.events.append((start, True, r['headers']['X-Instance-Id'], time.monotonic() - start))
|
|
self.confirmed.append(r['json'])
|
|
key = None
|
|
n += 1
|
|
except Failure as exc:
|
|
with self._lock:
|
|
self.events.append((start, False, str(exc)[-60:], time.monotonic() - start))
|
|
self.retries += 1
|
|
time.sleep(0.05)
|
|
if self.pause:
|
|
time.sleep(self.pause)
|
|
|
|
def start(self):
|
|
for i in range(self.workers):
|
|
t = threading.Thread(target=self._worker, args=(i,), daemon=True)
|
|
t.start()
|
|
self._threads.append(t)
|
|
self.t0 = time.monotonic()
|
|
|
|
def stop(self):
|
|
self._stop.set()
|
|
for t in self._threads:
|
|
t.join(timeout=15)
|
|
|
|
def window(self, a, b):
|
|
ev = [e for e in self.events if a <= e[0] < b]
|
|
ok = [e for e in ev if e[1]]
|
|
lat = sorted(e[3] for e in ok)
|
|
pct = lambda p: round(1000 * lat[min(len(lat) - 1, int(p * len(lat)))], 1) if lat else None
|
|
return {'seconds': round(b - a, 2), 'ok': len(ok), 'errors': len(ev) - len(ok),
|
|
'ok_rps': round(len(ok) / (b - a), 1) if b > a else None,
|
|
'p50_ms': pct(.5), 'p95_ms': pct(.95), 'p99_ms': pct(.99)}
|
|
|
|
def verify_history(self):
|
|
items, cursor = [], None
|
|
path = '/api/v1/chats/' + self.chat['id'] + '/messages?limit=100'
|
|
while True:
|
|
page = self.reader.call('GET', path + ('&cursor=' + cursor if cursor else ''),
|
|
actor=self.bob, schema='MessagePage')['json']
|
|
items += page['items']
|
|
cursor = page['next_cursor']
|
|
if not cursor:
|
|
break
|
|
by_id = {m['id']: m for m in items}
|
|
texts = [m['text'] for m in items]
|
|
lost = [m for m in self.confirmed if by_id.get(m['id']) != m]
|
|
return {'stored_messages': len(items), 'confirmed_201': len(self.confirmed),
|
|
'lost_confirmed': len(lost), 'duplicate_ids': len(items) - len(by_id),
|
|
'duplicate_texts': len(texts) - len(set(texts)),
|
|
'unique_confirmed': len({m['id'] for m in self.confirmed})}
|