Files
mtusi2026lab3/scripts/lab3lib.py
2026-10-16 01:30:10 +03:00

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-lab3'
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})}