This commit is contained in:
Grbisba
2026-11-07 10:41:21 +03:00
parent 4c066ff191
commit 1e0d18e25b
306 changed files with 14036 additions and 627 deletions
+155
View File
@@ -0,0 +1,155 @@
#!/usr/bin/env python3
"""Explicit lab3 acceptance: includes persistence, process failures and replacements."""
import argparse,datetime,json,os,subprocess,sys,time,uuid
from pathlib import Path
from metrics import ROOT,command,containers
sys.path.insert(0,str(ROOT/'tests'))
from client import Client,Failure,check
from resilience import history
RUN = {}
def save(name,value):
target=ROOT/'evidence'/name
temporary=target.with_suffix(target.suffix+'.tmp')
temporary.write_text(json.dumps(value,ensure_ascii=False,indent=2)+'\n')
temporary.replace(target)
def stage(name):
RUN['stage']=name
RUN['updated_utc']=datetime.datetime.now(datetime.timezone.utc).isoformat()
save('acceptance.json',RUN)
def check_clocks():
rows=[]
for ident,name,service in containers():
if service!='api':continue
before=time.time()
remote=int(command(['docker','exec',ident,'date','+%s']))
after=time.time()
rows.append({'container':name,'host_epoch_midpoint':(before+after)/2,'api_epoch':remote,'offset_seconds':remote-(before+after)/2})
check(len(rows)>=2,'acceptance requires at least two running API replicas')
valid=all(abs(r['offset_seconds'])<=5 for r in rows)
save('clock-check.json',{'checked_utc':datetime.datetime.now(datetime.timezone.utc).isoformat(),'maximum_offset_seconds':5,'status':'PASS' if valid else 'failed','api':rows})
check(valid,'host/API clocks differ by more than 5 seconds; synchronize Docker VM clock before acceptance')
def state():
rows=[]
for ident,name,service in containers():
r=json.loads(command(['docker','inspect',ident]))[0]
item={'id':r['Id'],'name':name,'service':service,'image_id':r['Image'],'started_at':r['State']['StartedAt'],'pid':r['State']['Pid'],'cpus':r['HostConfig']['NanoCpus']/1e9,'memory_bytes':r['HostConfig']['Memory'],'published_ports':r['HostConfig']['PortBindings']}
if service=='api':item['instance_id']=json.loads(command(['docker','exec',ident,'wget','-qO-','http://127.0.0.1:8080/internal/metrics']))['instance_id']
rows.append(item)
return rows
def restore():
subprocess.run(['./scripts/compose.sh','up','-d','--wait','--wait-timeout','90','--no-recreate','api','lb'],cwd=ROOT,check=True,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
time.sleep(4)
def logrun(filename,args):
stage(filename)
print('Running '+filename,flush=True)
with (ROOT/'evidence'/filename).open('w') as f:
f.write('$ '+' '.join(args)+'\n');f.flush()
p=subprocess.run(args,cwd=ROOT,stdout=f,stderr=subprocess.STDOUT,timeout=240)
if p.returncode:raise RuntimeError(filename+' failed; inspect evidence')
def each_failure(base):
results=[]
# Each target is chosen by real container identity, independently of LB round-robin phase.
for name in [r['name'] for r in state() if r['service']=='api']:
restore();before=state();target=next(r for r in before if r['name']==name)
c=Client(base,timeout=2);alice,bob,eve,chat=c.bootstrap();original=c.message(alice,chat,'confirmed-before-stop')['json']
env=dict(os.environ,TARGET_INSTANCE_ID=target['instance_id'])
started=time.monotonic();proc=subprocess.Popen(['./scripts/stop-one.sh'],cwd=ROOT,env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
good=[];read_ok=read_errors=write_errors=0;latencies=[];first=None;instances=set();key=uuid.uuid4().hex;text='inflight-'+key
try:
while time.monotonic()-started<15:
t=time.monotonic()
try:
resp=c.message(alice,chat,text,key=key);good.append(resp['json']);latencies.append(time.monotonic()-t)
if proc.poll()==0:
if first is None:first=time.monotonic()-started
instances.add(resp['headers']['X-Instance-Id'])
key=uuid.uuid4().hex;text='inflight-'+key
except Failure:write_errors+=1
try:c.call('GET','/api/v1/chats/'+chat['id']+'/messages',actor=bob,schema='MessagePage');read_ok+=1
except Failure:read_errors+=1
time.sleep(.03)
check(proc.wait(timeout=10)==0,'target stop failed')
check(first is not None and first<=10,'write recovery exceeded 10 seconds')
check(target['instance_id'] not in instances,'stopped process still responded')
stopped=json.loads(command(['docker','inspect',target['id']]))[0]
check(stopped['State']['Status']=='exited','target container was not left stopped')
messages=history(c,bob,chat);byid={m['id']:m for m in messages}
check(byid.get(original['id'])==original,'pre-failure confirmation lost')
check(all(byid.get(m['id'])==m for m in good),'inflight confirmation lost')
check(len(messages)==len({m['text'] for m in messages}),'retry produced duplicate text')
elapsed=time.monotonic()-started
results.append({'target':target,'before':before,'stopped_status':stopped['State']['Status'],'successful_writes':len(good),'successful_reads':read_ok,'write_errors':write_errors,'read_errors':read_errors,'successful_write_rps':len(good)/elapsed,'first_recovery_seconds':first,'confirmed_messages_verified':len(good)+1,'observed_survivors':sorted(instances)})
save('failover-each.json',results)
finally:
if proc.poll() is None:proc.terminate();proc.wait(timeout=10)
restore()
return results
def accept(base):
logrun('smoke.txt',['make','test',f'BASE_URL={base}'])
logrun('go-tests.txt',['make','test-go',f'BASE_URL={base}'])
logrun('storage-tests.txt',['make','test-storage'])
save('containers-before-persistence.json',state())
logrun('persistence.txt',['make','test-persistence','ACTION_SCRIPT=scripts/restart.sh',f'BASE_URL={base}'])
save('containers-after-persistence.json',state())
logrun('failover-public.txt',['make','test-failover','ACTION_SCRIPT=scripts/stop-one.sh',f'BASE_URL={base}'])
stage("each API failure")
restore();each_failure(base)
# A stable synthetic workload overlaps the complete replacement action.
stage("rolling replacement")
c=Client(base);alice,bob,eve,chat=c.bootstrap();confirmed=c.message(alice,chat,'before-rolling')['json']
before=state();save('containers-before-rolling.json',before)
with (ROOT/'evidence/rolling-actions.txt').open('w') as f:
action=subprocess.Popen(['./scripts/rolling-update.sh'],cwd=ROOT,stdout=f,stderr=subprocess.STDOUT)
sent=[];errors=0;read_ok=read_errors=0;start=time.monotonic();key=uuid.uuid4().hex
while action.poll() is None:
if time.monotonic()-start>180:action.terminate();raise RuntimeError('rolling update exceeded budget')
try:sent.append(c.message(alice,chat,'rolling-'+key,key=key)['json']);key=uuid.uuid4().hex
except Failure:errors+=1
try:c.call('GET','/api/v1/chats/'+chat['id']+'/messages',actor=bob,schema='MessagePage');read_ok+=1
except Failure:read_errors+=1
time.sleep(.03)
check(action.returncode==0,'rolling action failed')
elapsed=time.monotonic()-start;messages=history(c,bob,chat);byid={m['id']:m for m in messages}
check(all(byid.get(m['id'])==m for m in [confirmed]+sent),'rolling lost confirmed messages')
check(len(messages)==len({m['text'] for m in messages}),'rolling retry duplicated message')
after=state();save('containers-after-rolling.json',after)
old={r['id'] for r in before if r['service']=='api'};new={r['id'] for r in after if r['service']=='api'}
check(not old.intersection(new) and len(new)==len(old),'not all API processes were replaced')
save('rolling.json',{'successful_writes':len(sent),'successful_reads':read_ok,'write_errors':errors,'read_errors':read_errors,'elapsed_seconds':elapsed,'successful_write_rps':len(sent)/elapsed,'confirmed_messages_verified':len(sent)+1,'old_api_ids':sorted(old),'new_api_ids':sorted(new)})
logrun('smoke-after-rolling.txt',['make','test',f'BASE_URL={base}'])
def main():
parser=argparse.ArgumentParser()
parser.add_argument('--base-url',default='http://localhost:18080')
args=parser.parse_args()
(ROOT/'evidence').mkdir(exist_ok=True)
RUN.update({'run_id':uuid.uuid4().hex,'started_utc':datetime.datetime.now(datetime.timezone.utc).isoformat(),'status':'running','stage':'clock preflight'})
save('acceptance.json',RUN)
error=None
try:
check_clocks()
accept(args.base_url)
except BaseException as exc:
error=exc
finally:
failed_stage=RUN['stage']
try:
restore()
except Exception as cleanup:
if error is None:error=cleanup;failed_stage='restore replicas'
else:RUN['cleanup_error']=type(cleanup).__name__+': '+str(cleanup)
RUN.update({'status':'failed' if error else 'PASS','stage':failed_stage if error else 'complete','completed_utc':datetime.datetime.now(datetime.timezone.utc).isoformat()})
if error:RUN['error']=type(error).__name__+': '+str(error)
else:RUN['checks']=['clock synchronization','public smoke','Go API tests','storage atomicity/expiry','persistence including stores','public failover','each API failure','rolling replacement under read/write traffic']
save('acceptance.json',RUN)
if error:raise error
print('PASS: lab3 acceptance completed',flush=True)
if __name__=='__main__':main()
+15
View File
@@ -0,0 +1,15 @@
#!/usr/bin/env python3
"""Save repeatable measurements of the legacy token-hash implementation."""
import json,subprocess,time
from pathlib import Path
root=Path(__file__).resolve().parents[1]
def main():
for rate in (5,20,80):
for repeat in range(1,4):
label=f'before-2-r{rate}-n{repeat}'
dest=root/'evidence/research'/f'{label}.json'
if dest.exists():continue
print(label,flush=True)
p=subprocess.run([str(root/'bin/benchmark'),'-rate',str(rate),'-duration','15s','-warmup','3s','-seed','1000','-label',label,'-output',str(dest)],cwd=root,stdout=subprocess.DEVNULL)
if p.returncode:raise SystemExit(p.returncode)
if __name__=='__main__':main()
+21
View File
@@ -0,0 +1,21 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
umask 077
mkdir -p secrets/lab3
if [ ! -f .env.lab3 ]; then
{ printf 'POSTGRES_PASSWORD='; openssl rand -hex 24
printf 'REDIS_PASSWORD='; openssl rand -hex 24
printf 'HOST_PORT=18080\nAPI_REPLICAS=2\n'
} > .env.lab3
fi
if [ ! -f secrets/lab3/private_key.pem ]; then
openssl genrsa -out secrets/lab3/private_key.pem 2048 2>/dev/null
fi
if [ ! -f secrets/lab3/public_key.pem ]; then
openssl rsa -in secrets/lab3/private_key.pem -pubout -out secrets/lab3/public_key.pem 2>/dev/null
fi
# Only synthetic stand keys, readable by the non-root application inside containers.
chmod 755 secrets secrets/lab3
chmod 444 secrets/lab3/*.pem
printf '%s\n' 'Local lab3 settings and synthetic keys ready; existing files preserved.'
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
exec docker compose --env-file .env.lab3 "$@"
+40
View File
@@ -0,0 +1,40 @@
#!/usr/bin/env python3
"""Collect allowlisted internal metrics without credentials or session tokens."""
import csv,io,json,subprocess,time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
ROOT=Path(__file__).resolve().parents[1]
def command(args):
p=subprocess.run(args,cwd=ROOT,text=True,capture_output=True,timeout=10)
if p.returncode:raise RuntimeError(p.stderr.strip()[:160])
return p.stdout.strip()
def containers():
ids=command(['./scripts/compose.sh','ps','-q']).split()
rows=json.loads(command(['docker','inspect',*ids]))
return [(r['Id'],r['Name'].lstrip('/'),r['Config']['Labels']['com.docker.compose.service']) for r in rows]
def sample_container(row):
ident,name,service=row
out={'name':name,'service':service}
try:
raw=command(['docker','exec',ident,'sh','-c','cat /sys/fs/cgroup/cpu.stat; printf "memory_bytes "; cat /sys/fs/cgroup/memory.current'])
out['cgroup']={k:int(v) for k,v in (line.split() for line in raw.splitlines())}
if service=='api':out['pool']=json.loads(command(['docker','exec',ident,'wget','-qO-','http://127.0.0.1:8080/internal/metrics']))
if service=='lb':
raw=command(['docker','exec',ident,'wget','-qO-','http://127.0.0.1:8404/stats;csv'])
out['backends']=[{k:r.get(k) for k in ('svname','status','qcur','qmax','scur','stot','econ','eresp','rtime','ctime')} for r in csv.DictReader(io.StringIO(raw)) if r.get('# pxname')=='api']
if service=='postgres':
sql="SELECT json_build_object('commits',xact_commit,'rollbacks',xact_rollback,'blocks_read',blks_read,'blocks_hit',blks_hit,'deadlocks',deadlocks,'connections',numbackends,'size_bytes',pg_database_size(datname),'waits',(SELECT coalesce(json_agg(w),'[]') FROM (SELECT state,wait_event_type,count(*) FROM pg_stat_activity WHERE application_name='mtusi-api' GROUP BY 1,2) w)) FROM pg_stat_database WHERE datname='messenger'"
out['database']=json.loads(command(['docker','exec',ident,'psql','-U','messenger','-d','messenger','-Atc',sql]))
except Exception as e:out['error']=str(e)
return out
def snapshot(rows=None):
rows=containers() if rows is None else rows
with ThreadPoolExecutor(max_workers=8) as pool:return {'unix_time':time.time(),'containers':list(pool.map(sample_container,rows))}
if __name__=='__main__':
import argparse
p=argparse.ArgumentParser();p.add_argument('--duration',type=float,default=20);p.add_argument('--output',required=True);a=p.parse_args()
rows=containers();dest=Path(a.output);dest.parent.mkdir(parents=True,exist_ok=True)
with dest.open('w') as f:
end=time.monotonic()+a.duration
while time.monotonic()<end:
f.write(json.dumps(snapshot(rows))+'\n');f.flush();time.sleep(3)
+10
View File
@@ -0,0 +1,10 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
workdir=$(mktemp -d)
trap 'rm -rf "$workdir"' EXIT
cp -R service Dockerfile .dockerignore "$workdir/"
patch_path="$PWD/evidence/research/token-optimization.patch"
git -C "$workdir" apply --reverse "$patch_path"
docker build -t mtusi-messenger:lab3-before "$workdir"
printf '%s\n' 'Baseline image rebuilt. Select it explicitly with API_IMAGE=mtusi-messenger:lab3-before.'
+65
View File
@@ -0,0 +1,65 @@
#!/usr/bin/env python3
"""Full lab3 scaling matrix; a new chat and bounded generator for every run."""
import argparse,datetime,json,os,random,subprocess,threading,time
from pathlib import Path
from metrics import ROOT,containers,snapshot
def run(args,env=None):
p=subprocess.run(args,cwd=ROOT,env=env,text=True,capture_output=True,timeout=180)
if p.returncode:raise RuntimeError(' '.join(args[:3])+': '+p.stderr[-500:])
return p.stdout.strip()
def configure(replicas,cpus,memory):
env=dict(os.environ,API_IMAGE='mtusi-messenger:lab3',API_REPLICAS=str(replicas),API_CPUS=str(cpus),API_MEMORY=str(memory)+'m',POSTGRES_MAX_CONNECTIONS=str(16//replicas))
run(['./scripts/compose.sh','up','-d','--no-deps','--wait','--wait-timeout','90','--scale',f'api={replicas}','api'],env)
# Explicitly wait for Docker DNS refresh and LB health checks after an address change.
time.sleep(4)
return env
def measure(base,label,rate,duration,warmup,seed):
dest=ROOT/'evidence/research'/f'{label}.json'
if dest.exists():return
# Never begin setup while backends are still recovering from the previous overload.
import urllib.request
deadline=time.monotonic()+45
consecutive=0
while consecutive<3:
try:
with urllib.request.urlopen(base+'/health/ready',timeout=2) as r:consecutive=consecutive+1 if r.status==200 else 0
except Exception:consecutive=0
if time.monotonic()>deadline:raise RuntimeError('LB did not recover after overload')
time.sleep(.5)
rows=containers();stop=threading.Event();metrics=dest.with_suffix('.metrics.jsonl')
def collect():
with metrics.open('w') as f:
while not stop.is_set():
f.write(json.dumps(snapshot(rows))+'\n');f.flush();stop.wait(3)
thread=threading.Thread(target=collect);thread.start()
print(label,flush=True)
try:
p=subprocess.run([str(ROOT/'bin/benchmark'),'-base-url',base,'-rate',str(rate),'-duration',duration,'-warmup',warmup,'-seed',str(seed),'-label',label,'-output',str(dest)],cwd=ROOT,stdout=subprocess.DEVNULL,timeout=180)
if p.returncode:raise RuntimeError(f'benchmark failed: {label}')
finally:stop.set();thread.join()
def main():
p=argparse.ArgumentParser();p.add_argument('--base-url',default='http://localhost:18080');p.add_argument('--comparison-only',action='store_true');a=p.parse_args()
folder=ROOT/'evidence/research';folder.mkdir(exist_ok=True)
meta={'started_utc':datetime.datetime.now(datetime.timezone.utc).isoformat(),'commit':run(['git','rev-parse','HEAD']),'docker':run(['docker','info','--format','{{.NCPU}} CPUs / {{.MemTotal}} bytes']),'matrix':{'replicas':[1,2,4],'rates':[100,300,900,2700,8100],'repeats':3,'warmup_seconds':5,'duration_seconds':30,'seed_messages':1000,'total_pool_connections':16},'note':'Running lab2 is kept intact and idle. Metric sampling is included in every run. API, LB and DB share one Docker Desktop VM.'}
(folder/'method.json').write_text(json.dumps(meta,indent=2)+'\n')
try:
configure(2,1,512)
for rate in (5,20,80):
for repeat in range(1,4):measure(a.base_url,f'after-2-r{rate}-n{repeat}',rate,'15s','3s',1000)
if a.comparison_only:return
# Baseline comparisons use the exact preserved generator binary.
# Rebuild the corrected due-time scheduler for the scaling matrix.
run(['make','build'])
for series in ('fixed','growing'):
for n in (1,2,4):
cpus,memory=(2/n,1024//n) if series=='fixed' else (1,512)
configure(n,cpus,memory)
cases=[(rate,rep) for rate in (100,300,900,2700,8100) for rep in (1,2,3)]
random.Random(20261106).shuffle(cases)
for rate,rep in cases:measure(a.base_url,f'{series}-{n}-r{rate}-n{rep}',rate,'30s','5s',1000)
finally:configure(2,1,512)
print('Research matrix complete; restored 2 API replicas.',flush=True)
if __name__=='__main__':main()
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
./scripts/compose.sh stop api lb
./scripts/compose.sh restart postgres redis
./scripts/compose.sh up -d --wait --wait-timeout 90 api lb
+45
View File
@@ -0,0 +1,45 @@
#!/usr/bin/env python3
"""Drain and replace API processes individually, retaining other container IDs."""
import json,os,subprocess,time
from pathlib import Path
ROOT=Path(__file__).resolve().parents[1]
def run(args,input=None):
p=subprocess.run(args,cwd=ROOT,input=input,text=True,capture_output=True,timeout=100)
if p.returncode:raise RuntimeError(p.stderr.strip()[:300])
return p.stdout.strip()
def runtime(lb,cmd):return run(['docker','exec','-i',lb,'nc','-w','1','127.0.0.1','9999'],cmd+'\n')
def ids():return run(['./scripts/compose.sh','ps','-q','api']).split()
def states(lb):
lines=runtime(lb,'show servers state').splitlines();head=lines[1].lstrip('# ').split()
return [dict(zip(head,l.split())) for l in lines[2:] if l.strip()]
def main():
initial=ids()
if len(initial)<2:raise SystemExit('rolling update requires at least two running API replicas')
lb=run(['./scripts/compose.sh','ps','-q','lb'])
for old in initial:
info=json.loads(run(['docker','inspect',old]))[0]
ip=next(iter(info['NetworkSettings']['Networks'].values()))['IPAddress']
backend=next(s['srv_name'] for s in states(lb) if s['srv_addr']==ip and s['be_name']=='api')
runtime(lb,f'set server api/{backend} state drain')
try:
deadline=time.monotonic()+10
while True:
# Existing transactions get a chance to finish before SIGTERM.
import csv,io
raw=run(['docker','exec',lb,'wget','-qO-','http://127.0.0.1:8404/stats;csv'])
row=next(r for r in csv.DictReader(io.StringIO(raw)) if r['# pxname']=='api' and r['svname']==backend)
if int(row['scur'])==0:break
if time.monotonic()>deadline:raise RuntimeError('backend did not drain')
time.sleep(.1)
before=set(ids());run(['docker','stop','--time','8',old]);run(['docker','rm',old])
run(['./scripts/compose.sh','up','-d','--no-deps','--no-recreate','--scale',f'api={len(initial)}','api'])
after=set(ids())
if not (before-{old}).issubset(after):raise RuntimeError('another replica was replaced unexpectedly')
new=(after-before).pop();deadline=time.monotonic()+60
while run(['docker','inspect','--format','{{.State.Health.Status}}',new])!='healthy':
if time.monotonic()>deadline:raise RuntimeError('replacement failed readiness')
time.sleep(.5)
print(json.dumps({'old_container':old,'new_container':new,'name':info['Name'],'drained_backend':backend}),flush=True)
finally:runtime(lb,f'set server api/{backend} state ready')
time.sleep(3) # allow DNS refresh and a successful active readiness check
if __name__=='__main__':main()
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
exec python3 scripts/rolling-update.py
+42
View File
@@ -0,0 +1,42 @@
#!/usr/bin/env python3
"""Controlled LB-resource probe with a larger client in-flight bound."""
import argparse,json,os,subprocess,threading,time,hashlib
from pathlib import Path
from metrics import ROOT,containers,snapshot
from research import configure,run
def main():
p=argparse.ArgumentParser();p.add_argument('--base-url',default='http://localhost:18080');a=p.parse_args()
run(['make','build'])
env=configure(2,1,512)
try:
for lb_cpu in (.5,1):
run(['docker','update','--cpus',str(lb_cpu),run(['./scripts/compose.sh','ps','-q','lb'])])
time.sleep(3)
for repeat in (1,2,3):
label=f'lbprobe-cpu{lb_cpu}-n{repeat}';dest=ROOT/'evidence/research'/f'{label}.json'
if dest.exists():continue
rows=containers();stop=threading.Event()
proc=subprocess.Popen([str(ROOT/'bin/benchmark'),'-base-url',a.base_url,'-rate','8100','-duration','30s','-warmup','5s','-seed','1000','-max-in-flight','1024','-label',label,'-output',str(dest)],cwd=ROOT,stdout=subprocess.DEVNULL)
print(label,flush=True)
applied=json.loads(run(['docker','inspect',run(['./scripts/compose.sh','ps','-q','lb'])]))[0]
dest.with_suffix('.limits.json').write_text(json.dumps({'lb_nano_cpus':applied['HostConfig']['NanoCpus'],'max_in_flight':1024,'api_replicas':2,'api_cpu_total':2,'pool_total':16,'generator_sha256':hashlib.sha256((ROOT/'bin/benchmark').read_bytes()).hexdigest()},indent=2)+'\n')
def collect():
with dest.with_suffix('.metrics.jsonl').open('w') as f:
while not stop.is_set():
r=snapshot(rows)
host=subprocess.run(['ps','-p',str(proc.pid),'-o','%cpu=,rss='],capture_output=True,text=True)
try:cpu,rss=host.stdout.split();r['generator_host']={'cpu_percent':float(cpu),'rss_kib':int(rss)}
except ValueError:pass
f.write(json.dumps(r)+'\n');f.flush();stop.wait(3)
thread=threading.Thread(target=collect);thread.start()
try:
code=proc.wait(timeout=180)
if code and not dest.exists():raise RuntimeError(label+' failed')
finally:stop.set();thread.join()
time.sleep(3)
finally:
run(['docker','update','--cpus','0.5',run(['./scripts/compose.sh','ps','-q','lb'])])
configure(2,1,512)
print('LB probe complete; restored default resource limits.',flush=True)
if __name__=='__main__':main()
+17
View File
@@ -0,0 +1,17 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?missing target alias}"
for id in $(./scripts/compose.sh ps -q api); do
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$id")
case "$TARGET_INSTANCE_ID" in
"$hostname"-*)
current=$(docker exec "$id" wget -T 2 -qO- http://127.0.0.1:8080/internal/metrics | python3 -c 'import json,sys; print(json.load(sys.stdin)["instance_id"])')
[ "$current" = "$TARGET_INSTANCE_ID" ] || { printf '%s\n' 'Target process was already replaced' >&2; exit 1; }
docker stop --time 8 "$id" >/dev/null
exit 0 ;;
esac
done
printf '%s\n' 'Target does not match a running lab3 API container' >&2
exit 1
+86
View File
@@ -0,0 +1,86 @@
#!/usr/bin/env python3
"""Reduce raw runs and cgroup samples; generate standard scientific plots."""
import csv,json,statistics,math
from pathlib import Path
ROOT=Path(__file__).resolve().parents[1];FOLDER=ROOT/'evidence/research'
def metrics(path,result):
if not path.exists():return {}
rows=[json.loads(s) for s in path.read_text().splitlines() if s.strip()]
start=result.get('measurement_started_unix',rows[0]['unix_time'] if rows else 0)
end=start+result['elapsed_including_drain_seconds']
# Include only intervals with both endpoints inside the measured phase.
previous={};cpu={};throttled={};mem={};wait=[];backlog=[];dbwaits=set();generator_cpu=[];generator_rss=[];total_memory_peak={}
for row in rows:
t=row['unix_time'];inside=start<=t<=end;row_memory={}
if inside and row.get('generator_host'):
generator_cpu.append(row['generator_host']['cpu_percent']/100);generator_rss.append(row['generator_host']['rss_kib'])
for c in row['containers']:
name=c['name'];service=c['service'];g=c.get('cgroup',{});prev=previous.get(name)
if 'usage_usec' not in g:continue
if inside and prev and prev[0]>=start and t>prev[0]:
dt=t-prev[0];cpu.setdefault(service,[]).append((g.get('usage_usec',0)-prev[1].get('usage_usec',0))/1e6/dt)
periods=g.get('nr_periods',0)-prev[1].get('nr_periods',0)
if periods>0:throttled.setdefault(service,[]).append((g.get('nr_throttled',0)-prev[1].get('nr_throttled',0))/periods)
pool=c.get('pool');oldpool=prev[2]
if pool and oldpool:
count=pool['acquire_count']-oldpool['acquire_count']
if count>0:wait.append((pool['acquire_duration_ns']-oldpool['acquire_duration_ns'])/count/1e6)
if inside:
mem[service]=max(mem.get(service,0),g.get('memory_bytes',0))
row_memory[service]=row_memory.get(service,0)+g.get('memory_bytes',0)
for b in c.get('backends',[]):
if b['svname']=='BACKEND':backlog.append(int(b['qcur'] or 0))
for w in c.get('database',{}).get('waits',[]):
if w['state']=='active' and w['wait_event_type']:dbwaits.add(w['wait_event_type'])
previous[name]=(t,g,c.get('pool'))
for service,value in row_memory.items():total_memory_peak[service]=max(total_memory_peak.get(service,0),value)
return {'cpu_cores_mean_per_container':{k:statistics.mean(v) for k,v in cpu.items()},'throttled_period_ratio_mean':{k:statistics.mean(v) for k,v in throttled.items()},'memory_peak_bytes_per_container':mem,'service_total_memory_peak_bytes':total_memory_peak,'pool_acquire_ms_mean':statistics.mean(wait) if wait else None,'lb_queue_peak':max(backlog,default=0),'database_active_wait_types':sorted(dbwaits),'samples':len(rows),'generator_cpu_cores_mean':statistics.mean(generator_cpu) if generator_cpu else None,'generator_rss_peak_kib':max(generator_rss,default=0)}
def main():
allrows=[]
for p in sorted(FOLDER.glob('*.json')):
r=json.loads(p.read_text())
if 'target_rps' not in r:continue
label=r['label']
if not any(label.startswith(x) for x in ('fixed-','growing-','before-','after-','lbprobe-')):continue
r['metrics']=metrics(p.with_suffix('.metrics.jsonl'),r)
allrows.append(r)
(FOLDER/'runs.json').write_text(json.dumps(allrows,indent=2)+'\n')
groups={}
for r in allrows:
group=r['label'].rsplit('-n',1)[0];groups.setdefault(group,[]).append(r)
summary=[]
for group,rows in sorted(groups.items()):
summary.append({'case':group,'runs':len(rows),'target_rps':rows[0]['target_rps'],'median_successful_rps':statistics.median(r['successful_rps'] for r in rows),'min_successful_rps':min(r['successful_rps'] for r in rows),'max_successful_rps':max(r['successful_rps'] for r in rows),'median_error_ratio':statistics.median(r['error_ratio_including_drops'] for r in rows),**{f'median_{q}_ms':statistics.median(r['successful_latency_ms'].get(q,float('nan')) for r in rows) for q in ('p50','p95','p99')}})
(FOLDER/'summary.json').write_text(json.dumps(summary,indent=2)+'\n')
with (FOLDER/'summary.csv').open('w') as f:
if summary:w=csv.DictWriter(f,fieldnames=summary[0],lineterminator="\n");w.writeheader();w.writerows(summary)
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
plt.rcParams.update({'font.size':10,'axes.grid':True,'grid.alpha':.25})
fig,axes=plt.subplots(2,2,figsize=(11,7),constrained_layout=True)
for col,series in enumerate(('fixed','growing')):
for n in (1,2,4):
rs=sorted((r for r in summary if r['case'].startswith(f'{series}-{n}-')),key=lambda r:r['target_rps'])
if not rs:continue
x=[r['target_rps'] for r in rs]
line,=axes[0,col].plot(x,[r['median_successful_rps'] for r in rs],'o-',label=f'{n} API')
axes[0,col].fill_between(x,[r['min_successful_rps'] for r in rs],[r['max_successful_rps'] for r in rs],color=line.get_color(),alpha=.12)
axes[1,col].plot(x,[100*r['median_error_ratio'] for r in rs],'o-',label=f'{n} API')
axes[0,col].set_title('Fixed total: 2 CPU / 1 GiB' if series=='fixed' else 'Growing: 1 CPU / 512 MiB per API')
for ax in axes[:,col]:ax.set_xscale('log');ax.set_xlabel('Scheduled requests / second');ax.legend()
axes[0,col].set_ylabel('Successful requests / second');axes[1,col].set_ylabel('Errors + generator drops (%)')
fig.suptitle('Medians of 3 runs; shaded throughput bands show min-max')
fig.savefig(FOLDER/'scaling.png',dpi=180);plt.close(fig)
fig,axes=plt.subplots(1,2,figsize=(10,4),constrained_layout=True)
for version in ('before','after'):
rs=sorted((r for r in summary if r['case'].startswith(version+'-2-')),key=lambda r:r['target_rps'])
if rs:
axes[0].plot([r['target_rps'] for r in rs],[r['median_successful_rps'] for r in rs],'o-',label=version)
axes[1].plot([r['target_rps'] for r in rs],[100*r['median_error_ratio'] for r in rs],'o-',label=version)
for ax in axes:ax.set_xlabel('Scheduled requests / second');ax.legend()
axes[0].set_ylabel('Successful requests / second');axes[1].set_ylabel('Errors + drops (%)')
fig.suptitle('Token fingerprint optimization: same 2 API, CPU, RAM and workload')
fig.savefig(FOLDER/'optimization.png',dpi=180);plt.close(fig)
print(f'Summarized {len(allrows)} runs in {len(summary)} cases')
if __name__=='__main__':main()
+11
View File
@@ -0,0 +1,11 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
mkdir -p bin
(cd service && GOOS=linux GOARCH=$(docker info --format '{{.Architecture}}' | sed 's/aarch64/arm64/;s/x86_64/amd64/') CGO_ENABLED=0 go test -c -o ../bin/storage.test ./internal/adapter/repository/storage)
database="lab3_atomic_$(date +%s)_$$"
./scripts/compose.sh exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 -c "CREATE DATABASE $database" >/dev/null
trap './scripts/compose.sh exec -T postgres psql -U messenger -d messenger -c "DROP DATABASE IF EXISTS $database WITH (FORCE)" >/dev/null' EXIT
id=$(./scripts/compose.sh ps -q api | head -n 1)
docker cp bin/storage.test "$id:/tmp/storage.test" >/dev/null
docker exec -e "TEST_DATABASE_NAME=$database" "$id" /tmp/storage.test -test.v
+144
View File
@@ -0,0 +1,144 @@
#!/usr/bin/env python3
"""Build the report from measured artifacts; never invent missing results."""
import json,subprocess,statistics,datetime
from pathlib import Path
ROOT=Path(__file__).resolve().parents[1]
def read(name,default=None):
p=ROOT/'evidence'/name
return json.loads(p.read_text()) if p.exists() else default
def _conclusions(summary,runs):
lookup={r['case']:r for r in summary};out=[]
before,after=lookup.get('before-2-r80'),lookup.get('after-2-r80')
if before and after:
out.append(f"При 80 запланированных запросах/с медиана успешных подтверждений выросла с {before['median_successful_rps']:.2f} до {after['median_successful_rps']:.2f} RPS ({after['median_successful_rps']/before['median_successful_rps']:.1f} раза), доля ошибок + drops снизилась с {100*before['median_error_ratio']:.2f}% до {100*after['median_error_ratio']:.2f}%. Это измеренный результат совместной замены bcrypt-отпечатка и устранения повторной проверки JWT; вклад каждого изменения отдельно не изолирован.")
for series in ('fixed','growing'):
high=[lookup.get(f'{series}-{n}-r8100') for n in (1,2,4)]
if all(high):out.append(f"При 8100 запросах/с серия {series} дала медианы {high[0]['median_successful_rps']:.0f}/{high[1]['median_successful_rps']:.0f}/{high[2]['median_successful_rps']:.0f} successful RPS для 1/2/4 API. Диапазоны повторов приведены в CSV; рост числа процессов сам по себе не доказывает линейного выигрыша.")
low,high=lookup.get('lbprobe-cpu0.5'),lookup.get('lbprobe-cpu1')
if low and high:
delta=(high['median_successful_rps']/low['median_successful_rps']-1)*100
out.append(f"При лимите генератора 1024 увеличение CPU LB с 0.5 до 1 изменило медиану throughput на {delta:+.1f}%: {low['median_successful_rps']:.0f} → {high['median_successful_rps']:.0f} RPS. Остальные ресурсы не менялись. Диапазоны повторов перекрываются: устойчивый прирост от увеличения CPU LB не подтверждён. Следовательно, наблюдаемое throttling LB само по себе не доказывает, что именно он является единственным узким местом.")
selected=[r for r in runs if r['label'].startswith('growing-4-r8100-') and r.get('metrics',{}).get('cpu_cores_mean_per_container')]
if selected:
lb=statistics.median(r['metrics']['cpu_cores_mean_per_container'].get('lb',0) for r in selected)
throttle=statistics.median(r['metrics']['throttled_period_ratio_mean'].get('lb',0) for r in selected)*100
acquire=statistics.median(r['metrics'].get('pool_acquire_ms_mean') or 0 for r in selected)
out.append(f"В growing-4 при 8100 запросах/с LB в среднем занимал {lb:.2f} ядра из выделенных 0.5, медианная доля ограниченных cgroup-периодов LB — {throttle:.1f}%; средний Acquire пула — {acquire:.3f} мс. Увеличение CPU API не увеличивает CPU LB или общий пул 16 соединений. Это признаки давления на ресурсы и очереди, но не доказательство единственной причины плато. В контроле с двумя API их CPU близок к выделенному 1 ядру на процесс; увеличение CPU LB увеличило ожидание pool примерно с 18 до 57 мс без выигрыша throughput. Данные согласуются с переносом давления к насыщенным API и общему пулу; точный максимум PostgreSQL не установлен.")
if any(r['label'].startswith('fixed-') for r in runs):
out.append('При высокой интенсивности основной матрицы заполнялся лимит 256 in-flight и часть операций не отправлялась. Поэтому точный максимум PostgreSQL по этим данным не установлен: зафиксировано насыщение данного стенда и ограниченного генератора. Дополнительный эксперимент с лимитом 1024 и CPU LB проверяет это ограничение отдельно. По одним p95 успешных запросов или числу реплик делать вывод о максимальной мощности БД нельзя.')
if not out:out.append('Для выводов ещё недостаточно завершённых измерений.')
return out
def main():
acceptance=read('acceptance.json');failures=read('failover-each.json',[]);rolling=read('rolling.json',{});summary=read('research/summary.json',[]);runs=read('research/runs.json',[]);method=read('research/method.json',{})
lines=['# Отчёт — лабораторная 3: балансировка и отказ API-реплики','',
'- Автор и группа: заполняет автор перед сдачей.',
'- Целевая оценка: **5, трек 1 — цена масштабирования**.',
'- Исходная ревизия: `'+subprocess.check_output(['git','rev-parse','HEAD'],cwd=ROOT,text=True).strip()+'`; реализация находится в текущем рабочем дереве, отдельный commit/PR ещё не создан.',
'- Дата измерений: '+method.get('started_utc','ещё не зафиксирована')+'.',
'- Разработка, диагностика и подготовка отчёта выполнены с помощью OpenAI Codex. Генератор нагрузки и сценарии студента входят в репозиторий.','',
'## Запуск из чистого clone','',
'Нужны Docker Engine с Compose v2+ (проверено на Docker Desktop), Go 1.27+, Python 3.9+, OpenSSL, Git и Bash. Сборка контейнера использует Go 1.27.2; версии и digest базовых образов закреплены. Для локального Go-модуля используется Go 1.27. Стенд занимает порт `127.0.0.1:18080`, отдельную сеть и volumes проекта `mtusi2026lab3`. Работающая lab2 не изменяется.','',
'```sh','make up','make build vet check','python3 -m venv .venv','.venv/bin/python -m pip install -r requirements-analysis.txt','make validate PYTHON=.venv/bin/python','make test test-go test-storage','make evidence','make research','make saturation','.venv/bin/python scripts/summarize-research.py','python3 scripts/write-report.py','```','',
'`make up` создаёт `.env.lab3` со случайными синтетическими credentials и `secrets/lab3/` с ключами подписи. Повторный bootstrap сохраняет существующие файлы. Не копируйте эти файлы в Git. Существующая `.env` не используется. При первом запуске загружаются образы и Go-зависимости. Миграции выполняет одноразовый service `migrate`; API ждут его успешного завершения. Готовность ожидается через Compose healthchecks. Обычный `make test` не останавливает контейнеры; `make evidence` — явный сценарий с перезапусками и отказами.','',
'```sh','# Восстановить остановленные API','make restore','# Явно проверить перезапуск всех хранилищ и сохранность','make test-persistence ACTION_SCRIPT=scripts/restart.sh','# Остановить выбранную тестом API-реплику; затем восстановить','make test-failover ACTION_SCRIPT=scripts/stop-one.sh','make restore','# Поочерёдная замена уже собранным образом lab3','make rolling-update','# Безопасно остановить и удалить контейнеры, сохранив данные','make down','# Только для намеренного удаления всех учебных данных lab3:','./scripts/compose.sh down -v','```','',
'Последняя команда разрушительна и не используется ни одним сценарием доказательства. Пример отдельного замера: `make benchmark RATE=300 DURATION=30s BENCH_ARGS="-output evidence/manual-load.json"`. Для нагрузки/повторов используйте синтетические данные.','',
'## Архитектура и изменения в service/','',
'```mermaid','flowchart LR',' C[Клиенты] --> LB[HAProxy :18080]',' LB --> A[API 1]',' LB --> B[API 2 и до 4]',' A --> DB[(Общий PostgreSQL)]',' B --> DB',' A --> R[(Общий Redis: кэш)]',' B --> R',' M[Одноразовые миграции] --> DB','```','',
'PostgreSQL хранит пользователей, хеши паролей, чаты, участников, сообщения, серверные сессии и результаты идемпотентности. Redis содержит только восстанавливаемый кэш неизменяемых чатов и участников; отказ Redis не отзывает сессии и не меняет историю. История сообщений читается из PostgreSQL, поэтому подтверждённая запись видна другим API. Локальный singleflight подавляет повторные чтения и не является источником данных корректности.','',
'Из предыдущей реализации сохранены Basic-вход, серверная Bearer-сессия, отзыв и expiry, Argon2id паролей, SQL-хранилища и keyset-пагинация `(created_at,id)`. В lab3 добавлены идентификатор процесса, общая идемпотентность, отдельные миграции, LB, ограничения ресурсов и сценарии отказов. Старые Go-тесты lab1 переведены на реальное API lab3. Публичные `tests/`, контракт и рубрика сохранены. Вложения lab4 не реализуются: текущий OpenAPI lab3 принимает текстовые сообщения.','',
'Пагинация не фиксирует snapshot между HTTP-запросами. Вставка, которая поздно закоммитилась либо получила время меньше уже выданного cursor, может не попасть в продолжение текущего обхода; новый обход с начала увидит её. Часы API должны быть синхронизированы; порядок `(created_at,id)` не обещает порядок COMMIT. На неизменной истории повторов и пропусков нет.','',
'### Идемпотентность и транзакции','',
'Обязательный `Idempotency-Key` проверяется по ASCII `[A-Za-z0-9._:-]{1,128}`; несколько значений, пустой или неверный ключ дают 400. Scope — пользователь + POST + чат + ключ. SHA-256 вычисляется по декодированному значению `text`, поэтому JSON whitespace/экранирование не меняют смысл. Таблица `message_idempotency` имеет уникальный составной ключ и ссылку на созданное сообщение.','',
'После проверки серверной сессии и членства транзакция получает PostgreSQL advisory lock по scope. При действующей записи совпадающее тело возвращает исходное Message и 201, отличающееся — 409. Иначе в этой же транзакции создаются сообщение и запись результата с expiry через 24 часа. COMMIT подтверждает оба изменения; ошибка/откат сохраняет ни одного. Коллизия 64-битного lock hash может только лишний раз сериализовать разные scope: сами записи различаются полным уникальным ключом. Отмена ожидания/транзиентный 5xx не фиксируются как результат; неопределённый POST безопасно повторяется с прежним ключом.','',
'Истёкшая запись заменяется при повторном использовании ключа под той же блокировкой. Автоматическое удаление давно неиспользуемых ключей не настроено: таблица растёт с числом уникальных отправок. На учебной серии это измеряемое ограничение; для долгоживущего сервиса нужен отдельный ограниченный cleanup. Сообщения после expiry ключа сохраняются.','',
'### Сессии и подтверждённая оптимизация','',
'Диагностика выявила, что прежняя функция `EncryptSecretUsingSum256` дополнительно вызывала bcrypt, и каждая проверка случайного токена выполняла bcrypt.Compare. Это потребляло CPU независимо от коротких SQL-запросов. Новые отпечатки — `sha256:<hex>`, сравнение — `subtle.ConstantTimeCompare`. Это применяется только к сессионным токенам с 256-битным случайным nonce; пароли по-прежнему используют Argon2id. Legacy bcrypt-отпечатки принимаются, поэтому обновление не обрывает прежние действующие сессии; их проверки остаются дорогими до истечения/повторного входа.','',
'Middleware на каждом запросе проверяет подпись, expiry и текущую запись сессии в БД, затем передаёт проверенные данные через типизированный context. Обработчики не повторяют проверку JWT. Между запросами положительная аутентификация не кэшируется; отзыв продолжает действовать через любую реплику.','',
'### Готовность, лимиты и обновление','',
'Подробная таблица ролей, сетей, ресурсов и таймаутов — [infra/README.md](infra/README.md). HAProxy использует round robin без sticky sessions, Docker DNS и HTTP readiness (`inter=1s`, `fall=2`, `rise=1`, timeout=500ms). Расчётный бюджет обнаружения отказа — до 3 с без дополнительных задержек планирования; фактические результаты ниже. `/health/live` проверяет процесс, `/health/ready` — состояние сервера и PostgreSQL ping с бюджетом 200 мс. Redis — необязательная зависимость. Перегрузка общего пула может снимать readiness и усиливать ошибки: это отражается в экспериментах, а не скрывается.','',
'Бюджеты: запрос/SQL — 2 с, connect LB — 500 мс, client/server LB и read/write API — 5 с, shutdown — 8 с, Docker stop grace — 10 с. SIGTERM снимает readiness, прекращает приём новых соединений и ждёт активные запросы. Поочерёдная замена сначала переводит backend в drain, ждёт завершения запросов, заменяет только выбранный контейнер, проверяет readiness и возвращает ready. Скрипт проверяет, что остальные контейнеры не были заменены.','',
'Миграция 006 только добавляет таблицу, поэтому совместима с работающей версией. Однако старая lab2-версия не выполняет контракт идемпотентности: смешивать её с lab3 при первоначальном переходе нельзя. Проверенное обновление заменяет процессы уже совместимой lab3. Токены переживают рестарт, если сохранены PostgreSQL volume и ключи подписи.','',
'## Доказательства критериев','',
'Итоговая приёмка: **'+(acceptance or {}).get('status','не выполнена')+'**, время завершения: '+(acceptance or {}).get('completed_utc','нет')+'. Перед каждым запуском status меняется на running; ошибка записывает failed и этап, поэтому прошлый PASS не маскирует новый сбой. Предварительно проверяется расхождение часов хоста/API ≤5 с; TTL и публичные assertions не ослабляются.','',
'| Критерий | Команда / сценарий | Наблюдение | Доказательство |','| --- | --- | --- | --- |',
'| Контракт и схемы | `make check validate` | Структура и OpenAPI валидны | [валидация](evidence/openapi-validation.txt) |',
'| Бизнес-контракт lab3 | `make test` | Публичный smoke PASS | [smoke](evidence/smoke.txt) |',
'| Собственные проверки | `make test-go` | Реальное API, ошибки, доступ, пагинация, конкурентные сообщения/ключи; race detector | [Go-тесты](evidence/go-tests.txt) |',
'| Атомарность и expiry | `make test-storage` | Изолированная БД: rollback, отказ после INSERT, повтор после ошибки и expiry | [SQL-тесты](evidence/storage-tests.txt) |',
'| ≥2 реальных API и общая сессия | Конкурентный тест + состояния контейнеров | Один ключ через разные процессы создаёт одно Message | [Go-тесты](evidence/go-tests.txt), [контейнеры](evidence/containers-before-persistence.json) |',
'| Persistence хранилищ и прежней сессии | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; времена запуска API, PostgreSQL и Redis изменились | [проверка](evidence/persistence.txt), [до](evidence/containers-before-persistence.json), [после](evidence/containers-after-persistence.json) |',
'| Публичный failover | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | ≥2 реплики до отказа; чтение подтверждений и retry без дубля | [failover](evidence/failover-public.txt) |',
'| Отказ каждой реплики | `make evidence` | Обе API действительно останавливались по отдельности | [результаты](evidence/failover-each.json) |',
'| CPU/RAM, единая точка входа | Compose + docker inspect | Лимиты заданы всем сервисам, API не публикуют порты | [контейнеры](evidence/containers-before-persistence.json), [Compose](compose.yaml) |',
'| Одноразовые миграции | Service migrate, API без startup migrations | Завершённый процесс миграции, версия 6 | [миграции](evidence/migrations.json) |',
'| Поочерёдная замена под нагрузкой | `make rolling-update` внутри `make evidence` | Реальные ID всех API заменены, подтверждения сохранены | [действия](evidence/rolling-actions.txt), [итог](evidence/rolling.json) |',
'| Трек 1 | `make research`, агрегирование и графики | Результаты и ограничения ниже | [методика](evidence/research/method.json), [CSV](evidence/research/summary.csv) |','',
'### Отказы и обновление','',
'| Воздействие | Восстановление записи, с | Ошибки записи / чтения | Проверено подтверждений |','| --- | ---: | ---: | ---: |']
for r in failures:lines.append(f"| Остановка {r['target']['name']} | {r['first_recovery_seconds']:.3f} | {r['write_errors']} / {r['read_errors']} | {r['confirmed_messages_verified']} |")
if rolling:lines.append(f"| Замена всех API за {rolling['elapsed_seconds']:.2f} с | непрерывное обслуживание | {rolling['write_errors']} / {rolling['read_errors']} | {rolling['confirmed_messages_verified']} |")
lines+=['','Время восстановления отсчитывается от запуска hook до первой подтверждённой записи после его успешного завершения; это не точное время внутреннего обнаружения отказа LB. Нагрузка отказов — последовательные чтения/записи с короткой паузой; RPS в артефактах относится к этому сценарию и не является пределом пропускной способности. Остановленный процесс проверяется через Docker inspect и остаётся остановленным до явного восстановления.','',
'## Исследование: цена масштабирования','',
'**Гипотеза:** при фиксированных суммарных CPU/RAM увеличение числа API не гарантирует роста throughput; при росте ресурсов API выигрыш ограничивают общие LB, PostgreSQL и пул. Замена дорогой проверки отпечатка случайного токена должна устранить раннее насыщение CPU.','',
'Аппаратная среда Docker: '+method.get('docker','измерения ещё не завершены')+'. Сервисы находятся в одной Linux/arm64 VM Docker Desktop; работающая lab2 сохранена и не нагружается. Генератор работает на хосте, metrics collector — отдельный процесс Python. Все лимиты относятся к контейнерам, а не к выделенным физическим ядрам.','',
'Сравниваются 1/2/4 API: серия fixed имеет суммарно 2 CPU / 1024 MiB; growing — 1 CPU / 512 MiB на каждый API. PostgreSQL — 2 CPU / 1 GiB, HAProxy — 0.5 CPU / 128 MiB, Redis — 0.25 CPU / 128 MiB во всех конфигурациях. Общий pool limit API =16, на реплику 16/8/4.','',
'Профиль — 90% GET первой страницы истории (limit=50), 10% POST новых сообщений; перед каждым прогоном новый чат с 1000 сообщениями. Сессия создаётся до нагрузки, без повторного входа в измеряемой фазе. Warmup 5 с, измерение 30 с, 3 повтора; интенсивности 100/300/900/2700/8100 запросов/с перемешаны детерминированно внутри конфигурации. Генератор открытого цикла ограничен 256 одновременными запросами и отдельно считает отказ запуска при заполнении лимита. Каждый POST имеет новый ключ; прикладных повторов нет. Timeout клиента — 2 с. В первоначальной матрице использован стандартный Go Transport: при разрыве reused-соединения он мог прозрачно повторить запрос с Idempotency-Key. Поэтому её RPS означает финальные HTTP-подтверждения логических операций, а не точное число сетевых попыток или COMMIT. В итоговом коде GetBody для POST отключён; отдельный тест воспроизводит потерю ответа и доказывает отсутствие повтора. Дополнительный эксперимент с CPU LB использует уже исправленный клиент. Это ограничение исходной матрицы явно сохраняется, её цифры не выданы за новую серию.','',
'Каждый прогон сохраняет successful RPS, HTTP/network errors, generator drops, p50/p95/p99 успешных запросов и времена измеряемого окна. RPS делится на фактическое время вместе с завершением запросов. Процентили включают задержку планировщика и не включают ошибки; их нельзя читать отдельно от доли ошибок. Метрики cgroup, пула, активных ожиданий БД и очередей LB собираются примерно каждые 3 с через docker exec. Агрегаты CPU используют только интервалы внутри измеряемой фазы, исключая подготовку и warmup.','',
'В отдельном сравнении до/после — те же две API, суммарно 2 CPU / 1 GiB, pool=16, 5/20/80 запросов/с, warmup 3 с, измерение 15 с, три повтора. До и после использовался один сохранённый бинарник генератора. Его пакетный планировщик добавлял постоянную задержку низким интенсивностям (около 190 мс при 5 RPS); абсолютные latency этого сравнения не считаются чистой HTTP-задержкой. Для итоговой матрицы планировщик исправлен: отправляются только уже наступившие запросы. Эти два набора latency напрямую между собой не сравниваются.','',
'### Результаты до/после','',
'| Вариант / целевой RPS | Повторы | Медиана successful RPS | Медиана ошибок + drops | p95 успешных, мс |','| --- | ---: | ---: | ---: | ---: |']
for r in summary:
if r['case'].startswith(('before-','after-')):lines.append(f"| {r['case']} | {r['runs']} | {r['median_successful_rps']:.2f} | {100*r['median_error_ratio']:.2f}% | {r['median_p95_ms']:.2f} |")
lines+=['','![Оптимизация отпечатка токена](evidence/research/optimization.png)','',
'### Матрица масштабирования','',
'| Конфигурация / целевой RPS | Повторы | Медиана successful RPS | Медиана ошибок + drops | p95 успешных, мс |','| --- | ---: | ---: | ---: | ---: |']
for r in summary:
if r['case'].startswith(('fixed-','growing-')):lines.append(f"| {r['case']} | {r['runs']} | {r['median_successful_rps']:.1f} | {100*r['median_error_ratio']:.2f}% | {r['median_p95_ms']:.2f} |")
lines+=['','![Масштабирование и ошибки](evidence/research/scaling.png)','',
'Полные минимумы/максимумы повторов, p50/p95/p99 и исходные счётчики — в [summary.csv](evidence/research/summary.csv) и [runs.json](evidence/research/runs.json).','',
'### Наблюдаемые ресурсы при 8100 запросах/с','',
'CPU ниже измерен в ядрах; API — сумма средних по контейнерам. Throttling — доля cgroup-периодов с ограничением, не доля потерянного CPU-времени. Ожидание pool — среднее время Acquire, включая быстрые получения; это не SQL latency.','',
'| Конфигурация | CPU API / LB / БД | Throttling API / LB | RAM всех API, MiB | Acquire pool, мс |',
'| --- | ---: | ---: | ---: | ---: |']
for series in ('fixed','growing'):
for n in (1,2,4):
selected=[r for r in runs if r['label'].startswith(f'{series}-{n}-r8100-') and r.get('metrics',{}).get('cpu_cores_mean_per_container')]
if not selected:continue
median=lambda f:statistics.median(f(r['metrics']) for r in selected)
api=median(lambda m:m['cpu_cores_mean_per_container'].get('api',0))*n
lb=median(lambda m:m['cpu_cores_mean_per_container'].get('lb',0));db=median(lambda m:m['cpu_cores_mean_per_container'].get('postgres',0))
at=median(lambda m:m['throttled_period_ratio_mean'].get('api',0))*100;lt=median(lambda m:m['throttled_period_ratio_mean'].get('lb',0))*100
acquire=median(lambda m:m.get('pool_acquire_ms_mean') or 0)
ram=median(lambda m:m.get('service_total_memory_peak_bytes',{}).get('api',0))/1024**2
lines.append(f'| {series}-{n} | {api:.2f} / {lb:.2f} / {db:.2f} | {at:.1f}% / {lt:.1f}% | {ram:.1f} | {acquire:.3f} |')
lines+=['',
'### Контроль ограничения генератора и LB','',
'Дополнительный контролируемый эксперимент: две API, суммарно 2 CPU / 1 GiB, pool=16, 8100 запросов/с; предел генератора увеличен с 256 до 1024. Сравниваются LB с 0.5 и 1 CPU при неизменных остальных ресурсах. На каждый вариант три повтора, warmup 5 с, измерение 30 с. Сохраняются фактически применённые лимиты Docker и CPU/RSS генератора на хосте. Этот эксперимент отделён от основной матрицы.','',
'| CPU балансировщика | Повторы | Медиана successful RPS | Ошибки + drops | p95 успешных, мс |',
'| --- | ---: | ---: | ---: | ---: |']
for r in summary:
if r['case'].startswith('lbprobe-'):lines.append(f"| {r['case']} | {r['runs']} | {r['median_successful_rps']:.1f} | {100*r['median_error_ratio']:.2f}% | {r['median_p95_ms']:.2f} |")
lines+=['',
'### Выводы по измерениям','',
*_conclusions(summary,runs),'',
'### Повторение исходной версии','',
'Обратимый patch `evidence/research/token-optimization.patch` содержит изменения отпечатков и повторной проверки JWT. `scripts/reproduce-baseline.sh` копирует исходники во временный каталог, обращает patch и собирает `mtusi-messenger:lab3-before`, не меняя рабочее дерево. Для запуска исходного варианта явно задайте `API_IMAGE=mtusi-messenger:lab3-before ./scripts/compose.sh up -d --force-recreate --no-deps --wait api`; создайте новые сессии на этом варианте. После измерений верните `API_IMAGE=mtusi-messenger:lab3`. Не используйте сохранённые новые SHA-256-сессии против старой версии. При повторении текущий генератор уже имеет исправленный планировщик: повторяйте обе версии одним бинарником и сравнивайте только новую пару запусков.','',
'## Ограничения','',
'- Защищён отказ одного API-процесса при живых остальных зависимостях. Нет HA PostgreSQL, LB, Redis или всего узла; потеря volumes/ключей не покрывается.',
'- Race detector покрывает Go-тестовый процесс и in-process unit tests. Контейнерный API собран без race instrumentation; black-box конкурентные проверки доказывают наблюдаемое поведение и SQL-инварианты, а не отсутствие всех возможных гонок памяти.',
'- Исследование локальное: общая VM, host-генератор, накладные расходы collectors и ограниченная длительность. Нет универсального production SLA или универсального проходного RPS.',
'- Данные между прогонами сохраняются; чат и начальная история каждого прогона новые, но суммарная БД растёт. Перемешивание интенсивностей не устраняет полностью влияние порядка конфигураций и кешей.',
'- Высокая доля dropped/ошибок ограничивает возможность назвать точную пропускную способность БД. Насыщение обосновывается совокупностью CPU, ожиданий пула, очередей LB и ошибок, с указанием возможного ограничения генератора.',
'- Rolling-сценарий подтверждает замену процессов совместимой lab3. Произвольная несовместимая смена схемы и одновременный lab2/lab3 deployment не проверяются.',
'- Автор/группа и публикация commit/PR требуют данных автора. Никакие PASS и значения измерений не подставляются вместо отсутствующих результатов.','',
'## Первичные источники','',
'- [HAProxy: DNS resolution](https://www.haproxy.com/documentation/haproxy-configuration-tutorials/proxying-essentials/dns-resolution/).',
'- [Docker Compose services](https://docs.docker.com/reference/compose-file/services/).',
'- [PostgreSQL: advisory locks](https://www.postgresql.org/docs/17/explicit-locking.html#ADVISORY-LOCKS).',
'- [Go: ConstantTimeCompare](https://go.dev/src/crypto/subtle/constant_time.go).',
'- [OWASP: Session Management Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Session_Management_Cheat_Sheet.html).',
'- Нормативные требования репозитория: `README.md`, `COURSE.md`, `contracts/README.md`, `contracts/openapi.json`.','']
(ROOT/'REPORT.md').write_text('\n'.join(lines))
if __name__=='__main__':main()