forked from mtusi2026/mtusi2026lab2
123 lines
8.5 KiB
Python
123 lines
8.5 KiB
Python
#!/usr/bin/env python3
|
|
"""Integration experiments. No credentials or bearer tokens are written to evidence."""
|
|
import concurrent.futures as cf
|
|
import json, os, pathlib, subprocess, sys, time, uuid, base64
|
|
sys.path.insert(0,str(pathlib.Path(__file__).resolve().parents[1]/'tests'))
|
|
from client import Client, check
|
|
root=pathlib.Path(__file__).resolve().parents[1]
|
|
os.chdir(root)
|
|
evidence=root/'evidence'; evidence.mkdir(exist_ok=True)
|
|
results={}
|
|
def dc(*args,input=None):
|
|
return subprocess.run(['docker','compose',*args],input=input,text=True,capture_output=True,check=True).stdout
|
|
def sql(query,db='messenger'):
|
|
return dc('exec','-T','postgres','psql','-U','messenger','-d',db,'-At','-v','ON_ERROR_STOP=1','-c',query).strip()
|
|
def ready():
|
|
start=time.monotonic()
|
|
while time.monotonic()-start<90:
|
|
try:
|
|
Client(timeout=5).call('GET','/health/ready',schema='Health')
|
|
return round(time.monotonic()-start,3)
|
|
except Exception: time.sleep(.5)
|
|
raise RuntimeError('Readiness timeout')
|
|
def save(): (evidence/'experiments.json').write_text(json.dumps(results,ensure_ascii=False,indent=2))
|
|
c=Client(); a,b,e,chat=c.bootstrap(); path='/api/v1/chats/'+chat['id']
|
|
# Race: one insert wins, unique index rejects the others.
|
|
d={'username':'race_'+uuid.uuid4().hex[:16],'display_name':'Гонка','password':'race-password-12345'}
|
|
def register(_): return Client().call('POST','/api/v1/users',[201,409],body=d)['status']
|
|
with cf.ThreadPoolExecutor(max_workers=8) as executor: statuses=list(executor.map(register,range(8)))
|
|
check(statuses.count(201)==1 and statuses.count(409)==7,'registration race')
|
|
results['registration_race']={'concurrency':8,'statuses':statuses}
|
|
# Trigger a failure AFTER the chat insert; a database trigger is test-only and always removed.
|
|
name='rollback_'+uuid.uuid4().hex[:8]
|
|
sql("CREATE FUNCTION lab_reject_member() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'injected'; END $$; CREATE TRIGGER lab_reject_member BEFORE INSERT ON members FOR EACH ROW EXECUTE FUNCTION lab_reject_member()")
|
|
try:
|
|
c.call('POST','/api/v1/chats',503,actor=a,body={'title':name,'member_ids':[a['id'],b['id']]})
|
|
check(sql("SELECT count(*) FROM chats WHERE title='"+name+"'")=='0','partial chat survived')
|
|
finally: sql('DROP TRIGGER lab_reject_member ON members; DROP FUNCTION lab_reject_member()')
|
|
results['rollback']={'failure':'trigger rejects membership after chat INSERT','remaining_chats':0}
|
|
# Negative API and access cases, resource-bound cursor and immediate visibility.
|
|
for payload in [{'text':'ok','sender_id':e['id']},{'text':34},{'text':' '}]:
|
|
c.call('POST',path+'/messages',400,actor=a,body=payload)
|
|
first=c.message(a,chat,'read-after-write 👋')['json']
|
|
c.message(b,chat,'second')
|
|
page=c.call('GET',path+'/messages?limit=1',actor=b,schema='MessagePage')['json']
|
|
check(page['items'][0]==first,'read after write')
|
|
other=c.call('POST','/api/v1/chats',201,actor=a,body={'title':'other','member_ids':[a['id']]},schema='Chat')['json']
|
|
from urllib.parse import quote
|
|
c.call('GET','/api/v1/chats/'+other['id']+'/messages?cursor='+quote(page['next_cursor']),400,actor=a)
|
|
c.call('GET',path+'/messages?cursor='+quote(base64.urlsafe_b64encode(json.dumps([chat['id'],123,a['id']]).encode()).decode()),400,actor=a)
|
|
results['contract_extra']={'malformed_cursor_rejected':True,'read_after_write':True,'foreign_cursor_rejected':True,'strict_json':True}
|
|
# Redis: warm cache, real hits, outage fallback, restart, cold-cache recovery.
|
|
c.call('GET','/api/v1/users/me',actor=a,schema='User')
|
|
before=dc('exec','-T','redis','redis-cli','INFO','stats')
|
|
c.call('GET','/api/v1/users/me',actor=a,schema='User')
|
|
after=dc('exec','-T','redis','redis-cli','INFO','stats')
|
|
def hits(info): return int(next(x.split(':')[1] for x in info.splitlines() if x.startswith('keyspace_hits:')))
|
|
check(hits(after)>hits(before),'Redis unused')
|
|
start=time.monotonic(); dc('stop','redis')
|
|
c.call('GET','/api/v1/users/me',actor=a,schema='User')
|
|
c.call('GET','/api/v1/users/me',401)
|
|
c.message(a,chat,'redis unavailable')
|
|
results['redis_outage']={'cache_hits_delta':hits(after)-hits(before),'fallback_request_ms':None,'anonymous_status':401}
|
|
t=time.monotonic(); c.call('GET','/api/v1/users/me',actor=a,schema='User'); results['redis_outage']['fallback_request_ms']=round((time.monotonic()-t)*1000,2)
|
|
dc('start','redis'); dc('exec','-T','redis','redis-cli','FLUSHDB')
|
|
c.call('GET','/api/v1/users/me',actor=a,schema='User')
|
|
results['redis_outage']['recovered']=True
|
|
# DB outage is bounded and fails closed; process stays alive.
|
|
dc('stop','postgres'); start=time.monotonic()
|
|
c.call('GET','/health/live',schema='Health')
|
|
c.call('GET','/health/ready',503)
|
|
c.call('GET','/api/v1/users/me',503,actor=a)
|
|
c.call('GET','/api/v1/users/me',401)
|
|
results['postgres_outage']={'ready_status':503,'authenticated_status':503,'anonymous_status':401,'checks_seconds':round(time.monotonic()-start,3)}
|
|
dc('start','postgres'); results['postgres_outage']['recovery_seconds']=ready()
|
|
c.call('GET','/api/v1/users/me',actor=a,schema='User')
|
|
save()
|
|
# Short-lived sessions on a recreated API, then restore ordinary TTL unconditionally.
|
|
try:
|
|
env=dict(os.environ,SESSION_TTL_SECONDS='2')
|
|
subprocess.run(['docker','compose','up','-d','--no-deps','--force-recreate','api'],env=env,check=True,capture_output=True)
|
|
ready(); short=Client().user('expiry'); time.sleep(2.2)
|
|
Client().call('GET','/api/v1/users/me',401,actor=short)
|
|
results['expiry']={'ttl_seconds':2,'wait_seconds':2.2,'status':401}
|
|
finally:
|
|
env=dict(os.environ,SESSION_TTL_SECONDS='3600')
|
|
subprocess.run(['docker','compose','up','-d','--no-deps','--force-recreate','api'],env=env,check=True,capture_output=True)
|
|
ready()
|
|
# Dedicated database to avoid destructive benchmark operations on the app tables.
|
|
if sql("SELECT count(*) FROM pg_database WHERE datname='research'")=='0': sql('CREATE DATABASE research')
|
|
source=(root/'scripts/research.py').read_text()
|
|
research=json.loads(dc('exec','-T','api','python','-',input=source))
|
|
(evidence/'research.json').write_text(json.dumps(research,ensure_ascii=False,indent=2))
|
|
# Restore on another PostgreSQL instance with an independent persistent volume.
|
|
dc('--profile','research','up','-d','--wait','postgres_restore')
|
|
def restored_sql(query):
|
|
return dc('exec','-T','postgres_restore','psql','-U','messenger','-d','research_restored','-At','-v','ON_ERROR_STOP=1','-c',query).strip()
|
|
restored_sql('DROP SCHEMA public CASCADE; CREATE SCHEMA public')
|
|
start=time.monotonic()
|
|
dc('exec','-T','postgres','pg_dump','-U','messenger','-d','research','-Fc','-f','/tmp/research.dump')
|
|
backup_seconds=time.monotonic()-start
|
|
backup_dir=root/'backups'; backup_dir.mkdir(exist_ok=True)
|
|
start=time.monotonic()
|
|
dc('cp','postgres:/tmp/research.dump',str(backup_dir/'research.dump'))
|
|
dc('cp',str(backup_dir/'research.dump'),'postgres_restore:/tmp/research.dump')
|
|
copy_seconds=time.monotonic()-start
|
|
start=time.monotonic(); dc('exec','-T','postgres_restore','pg_restore','-U','messenger','-d','research_restored','--exit-on-error','/tmp/research.dump')
|
|
restore_seconds=time.monotonic()-start
|
|
query="SELECT count(*),md5(string_agg(id::text||':'||chat_id::text||':'||sender_id::text||':'||created_at::text||':'||text,'|' ORDER BY id)) FROM messages"
|
|
original=sql(query,'research'); restored=restored_sql(query); check(original==restored,'restored data differs')
|
|
samples="SELECT id,chat_id,sender_id,created_at,text FROM messages WHERE id IN (SELECT md5(n::text)::uuid FROM unnest(ARRAY[1,50000,100000,110000,120000]) n) ORDER BY id"
|
|
check(sql(samples,'research')==restored_sql(samples),'sample mismatch')
|
|
results['backup_restore']={'backup_seconds':round(backup_seconds,3),'copy_seconds':round(copy_seconds,3),'restore_seconds':round(restore_seconds,3),'source':original,'restored':restored,'samples_equal':True,'target':'postgres_restore / research_restored / restoredata','rows':120000}
|
|
results['restored_table_counts']={}
|
|
for table in ['users','chats','members','messages','sessions']:
|
|
original_count=sql('SELECT count(*) FROM '+table,'research')
|
|
restored_count=restored_sql('SELECT count(*) FROM '+table)
|
|
check(original_count==restored_count,'table count mismatch: '+table)
|
|
results['restored_table_counts'][table]={'source':int(original_count),'restored':int(restored_count)}
|
|
(evidence/'restore-storage.json').write_text(subprocess.check_output(['python3','scripts/container_state.py','postgres','postgres_restore'],text=True))
|
|
results['resources']=dc('stats','--no-stream','--format','json')
|
|
results['versions']=dc('version')
|
|
save(); print('PASS: registration race, rollback, strict contract, Redis/DB failure, expiry, 120000-row plans, backup/restore; evidence saved without tokens.')
|