forked from mtusi2026/mtusi2026lab5
200 lines
9.4 KiB
Python
200 lines
9.4 KiB
Python
"""Replay concrete reviewer cases through real HTTP and controlled dependency freezes."""
|
|
import io
|
|
import json
|
|
import struct
|
|
import subprocess
|
|
import time
|
|
import zlib
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from pathlib import Path
|
|
|
|
from client import Client, arguments, check, run
|
|
|
|
ROOT=Path(__file__).resolve().parents[1]
|
|
|
|
|
|
def compose(*args):
|
|
return subprocess.check_output(['docker','compose',*args],cwd=ROOT,text=True,stderr=subprocess.DEVNULL).strip()
|
|
|
|
|
|
def png(width,height):
|
|
# Complete PNG, including all scanlines and CRCs, without allocating a bitmap.
|
|
def chunk(kind,data):
|
|
return struct.pack('>I',len(data))+kind+data+struct.pack('>I',zlib.crc32(kind+data))
|
|
compressor=zlib.compressobj()
|
|
packed=io.BytesIO()
|
|
row=b'\0'*(width+1)
|
|
for _ in range(height): packed.write(compressor.compress(row))
|
|
packed.write(compressor.flush())
|
|
return (b'\x89PNG\r\n\x1a\n'+chunk(b'IHDR',struct.pack('>IIBBBBB',width,height,8,0,0,0,0))
|
|
+chunk(b'IDAT',packed.getvalue())+chunk(b'IEND',b''))
|
|
|
|
|
|
DIRECT='''import json,sys,time,urllib.request,urllib.error
|
|
p=json.load(sys.stdin);h={}
|
|
if p.get('token'):h['Authorization']='Bearer '+p['token']
|
|
r=urllib.request.Request('http://127.0.0.1:8080'+p['path'],headers=h)
|
|
t=time.monotonic()
|
|
try:r=urllib.request.urlopen(r,timeout=10)
|
|
except urllib.error.HTTPError as e:r=e
|
|
with r:
|
|
data=json.load(r)
|
|
if r.code>=400:
|
|
assert data['error']['request_id']==r.headers['X-Request-Id']
|
|
assert data['error']['code']=='unavailable'
|
|
print(json.dumps({'status':r.code,'seconds':round(time.monotonic()-t,4),
|
|
'request_id_present':bool(r.headers.get('X-Request-Id')),'instance_id_present':bool(r.headers.get('X-Instance-Id'))}))
|
|
'''
|
|
LOCKER='''import asyncio,sys,asyncpg
|
|
from src.core.settings import settings
|
|
async def f():
|
|
c=await asyncpg.connect(settings.database_url.get_secret_value())
|
|
await c.execute('BEGIN; LOCK TABLE messages IN ACCESS EXCLUSIVE MODE')
|
|
print('LOCKED',flush=True)
|
|
await asyncio.to_thread(sys.stdin.readline)
|
|
await c.execute('ROLLBACK');await c.close()
|
|
asyncio.run(f())
|
|
'''
|
|
PENDING='''import asyncio,asyncpg
|
|
from src.core.settings import settings
|
|
async def f():
|
|
c=await asyncpg.connect(settings.database_url.get_secret_value())
|
|
print(await c.fetchval("SELECT count(*) FROM pg_stat_activity WHERE wait_event_type='Lock' AND query LIKE '%FROM messages%'"))
|
|
await c.close()
|
|
asyncio.run(f())
|
|
'''
|
|
|
|
|
|
def main():
|
|
args=arguments('API reviewer regression scenarios')
|
|
c=Client(args.base_url,args.ca_file,timeout=15)
|
|
alice,bob,_,chat=c.bootstrap()
|
|
history='/api/v1/chats/'+chat['id']+'/messages'
|
|
c.message(alice,chat,'Контроль до отказов')
|
|
results=[]
|
|
for name in ('review123\n','review123\r','review123\x00','review123\t'):
|
|
c.call('POST','/api/v1/users',400,body={'username':name,'display_name':'Review','password':'valid-password-123'})
|
|
results.append({'case':'username_control_characters','result':'PASS','status':400})
|
|
data=(ROOT/'tests/fixtures/sample.png').read_bytes()
|
|
upload='/api/v1/chats/'+chat['id']+'/attachments'
|
|
for label,filename,payload,mime,status in [
|
|
('truncated_png','sample.png',data[:-12],'image/png',415),
|
|
('header_only_png','sample.png',data[:33],'image/png',415),
|
|
('mismatched_mime','sample.png',data,'image/jpeg',415),
|
|
('DEL_filename','a%7F.png',data,'image/png',400),
|
|
('missing_filename',None,data,'image/png',400),
|
|
]:
|
|
c.call('POST',upload+('' if filename is None else '?filename='+filename),status,
|
|
actor=alice,raw=payload,headers={'Content-Type':mime})
|
|
results.append({'case':label,'result':'PASS','status':status})
|
|
for width,height,status in ((8000,5000,202),(8000,5001,413),(20000,10000,413)):
|
|
payload=png(width,height)
|
|
reply=c.call('POST',upload+'?filename=dimensions.png',status,actor=alice,raw=payload,
|
|
headers={'Content-Type':'image/png'},schema='Attachment' if status==202 else None)
|
|
if status==202:
|
|
c.wait_ready(alice, reply['json'])
|
|
check(c.call('GET','/api/v1/attachments/'+reply['json']['id']+'/content',actor=bob)['bytes']==payload,
|
|
'40 MP original changed')
|
|
results.append({'case':'pixels','dimensions':[width,height],'result':'PASS','status':status})
|
|
api=compose('ps','-q','api').split()[0]
|
|
# Actual application credentials must not permit creating unrelated buckets.
|
|
code='''from src.core.storage import get_storage
|
|
from minio.error import S3Error
|
|
import uuid
|
|
s=get_storage();b='forbidden-'+uuid.uuid4().hex
|
|
try:s.make_bucket(b)
|
|
except S3Error as e:assert e.code=='AccessDenied';print('PASS')
|
|
else:s.remove_bucket(b);raise AssertionError('API can create foreign buckets')
|
|
'''
|
|
check(subprocess.check_output(['docker','exec',api,'python','-c',code],text=True).strip()=='PASS',
|
|
'API has excessive S3 rights')
|
|
results.append({'case':'API_cannot_create_foreign_bucket','result':'PASS'})
|
|
def direct(path,token=None):
|
|
reply=subprocess.run(['docker','exec','-i',api,'python','-c',DIRECT],
|
|
input=json.dumps({'path':path,'token':token}),text=True,capture_output=True,timeout=13,check=True)
|
|
return json.loads(reply.stdout)
|
|
transfer_code="""import asyncio,http.client,json,sys,time
|
|
from sqlalchemy import func,select
|
|
from sqlalchemy.ext.asyncio import async_sessionmaker
|
|
from src.core.db.session import create_engine
|
|
from src.core.db.models import Attachment,UploadIntent
|
|
p=json.load(sys.stdin)
|
|
async def counts():
|
|
e=create_engine();f=async_sessionmaker(e)
|
|
try:
|
|
async with f() as s:
|
|
return [await s.scalar(select(func.count()).select_from(m)) for m in (Attachment,UploadIntent)]
|
|
finally:await e.dispose()
|
|
before=asyncio.run(counts())
|
|
c=http.client.HTTPConnection('127.0.0.1',8080,timeout=8)
|
|
c.putrequest('POST',p['path'])
|
|
c.putheader('Authorization','Bearer '+p['token'])
|
|
c.putheader('Content-Type','image/png');c.putheader('Content-Length','1000');c.endheaders()
|
|
c.send(b'\\x89PNG\\r\\n\\x1a\\nshort');c.close();time.sleep(.3)
|
|
assert before==asyncio.run(counts()),'interrupted client created durable state'
|
|
c=http.client.HTTPConnection('127.0.0.1',8080,timeout=8)
|
|
c.request('POST',p['path'],body=(b'x'*65536 for _ in range(161)),
|
|
headers={'Authorization':'Bearer '+p['token'],'Content-Type':'image/png'},encode_chunked=True)
|
|
r=c.getresponse();body=json.loads(r.read())
|
|
assert r.status==413 and body['error']['code']=='payload_too_large'
|
|
assert body['error']['request_id']==r.getheader('X-Request-Id')
|
|
c.close();assert before==asyncio.run(counts()),'oversized chunked body created durable state'
|
|
print('PASS')
|
|
"""
|
|
transfer=subprocess.run(['docker','exec','-i',api,'python','-c',transfer_code],
|
|
input=json.dumps({'path':upload+'?filename=interrupted.png','token':alice['token']}),
|
|
text=True,capture_output=True,timeout=20,check=True)
|
|
check(transfer.stdout.strip()=='PASS','transfer limits failed')
|
|
results.append({'case':'client_abort_and_oversized_chunked_body','result':'PASS',
|
|
'oversized_status':413,'durable_state_unchanged':True})
|
|
direct(history,alice['token'])
|
|
# Start an actual history SELECT, hold it on a table lock, then freeze PG.
|
|
locker=subprocess.Popen(['docker','exec','-i',api,'python','-u','-c',LOCKER],
|
|
stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
|
|
check(locker.stdout.readline().strip()=='LOCKED','test table lock was not acquired')
|
|
paused=False
|
|
pool=ThreadPoolExecutor(max_workers=2)
|
|
query=pool.submit(direct,history,alice['token'])
|
|
try:
|
|
deadline=time.monotonic()+2
|
|
while True:
|
|
pending=int(subprocess.check_output(['docker','exec',api,'python','-c',PENDING],text=True))
|
|
if pending:break
|
|
check(time.monotonic()<deadline,'history did not enter SQL before the freeze')
|
|
time.sleep(.02)
|
|
compose('pause','postgres');paused=True
|
|
ready=pool.submit(direct,'/health/ready')
|
|
history_result=query.result(timeout=8)
|
|
readiness_result=ready.result(timeout=8)
|
|
for result in (history_result,readiness_result):
|
|
check(result['status']==503 and result['seconds']<7,'frozen PostgreSQL exceeded HTTP budget')
|
|
check(result['request_id_present'] and result['instance_id_present'],'missing response headers')
|
|
results.append({'case':'PostgreSQL_frozen_after_SQL_started','result':'PASS',
|
|
'history':history_result,'readiness':readiness_result})
|
|
finally:
|
|
if paused:compose('unpause','postgres')
|
|
try:locker.stdin.write('release\n');locker.stdin.flush()
|
|
except BrokenPipeError:pass
|
|
locker.wait(timeout=8)
|
|
pool.shutdown(wait=True)
|
|
deadline=time.monotonic()+12
|
|
while True:
|
|
try:
|
|
response=direct(history,alice['token'])
|
|
check(response['status']==200,'history did not recover')
|
|
check(direct('/health/ready')['status']==200,'readiness did not recover')
|
|
# Wait for HAProxy's rise checks as well as direct API recovery.
|
|
c.call('GET', '/health/live', schema='Health')
|
|
c.call('GET', '/health/ready', schema='Health')
|
|
c.call('GET', history, actor=alice, schema='MessagePage')
|
|
break
|
|
except Exception:
|
|
if time.monotonic()>deadline:raise
|
|
time.sleep(.2)
|
|
results.append({'case':'PostgreSQL_resume_without_API_restart','result':'PASS'})
|
|
print(json.dumps({'result':'PASS','checks':results},ensure_ascii=False,indent=2))
|
|
|
|
|
|
if __name__=='__main__':
|
|
run(main)
|