Реализация на 5

This commit is contained in:
Grbisba
2026-11-13 11:05:05 +03:00
parent ec540a1a72
commit d862103650
148 changed files with 11225 additions and 55 deletions
+306
View File
@@ -0,0 +1,306 @@
#!/usr/bin/env python3
"""Repeatable lab4 acceptance on an isolated synthetic Compose project.
No tokens, request headers, passwords, or filled-in configuration are persisted.
"""
import concurrent.futures as futures
import datetime
import hashlib
import http.client
import json
import os
from pathlib import Path
import platform
import select
import struct
import subprocess
import sys
import threading
import time
import uuid
import zlib
ROOT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(ROOT/'tests'))
from client import Client, check
OUT=ROOT/'evidence'
ENV=dict(os.environ,COMPOSE_PROJECT_NAME='mtusi2026lab4-evidence',HOST_PORT='18082',UPLOAD_TIMEOUT='5s',RECONCILE_GRACE_PERIOD='15s')
COMPOSE=['./scripts/compose.sh']
BASE='http://localhost:18082'
RUN_ID=uuid.uuid4().hex
def save(name,value):
temporary=OUT/(name+'.json.tmp')
temporary.write_text(json.dumps(value,indent=2)+'\n')
temporary.replace(OUT/(name+'.json'))
def stage(name):
save('acceptance',{'passed':False,'run_id':RUN_ID,'stage':name})
print(name,flush=True)
def command(args, name=None, expected=0, **kw):
p=subprocess.run(args,cwd=ROOT,env=ENV,text=True,capture_output=True,timeout=kw.pop('timeout',240),**kw)
if name:
(OUT/(name+'.txt')).write_text('$ '+' '.join(args)+'\n'+p.stdout+p.stderr)
check(p.returncode==expected,'command failed: '+' '.join(args)+' (see evidence/'+str(name)+'.txt)')
return p.stdout
def compose(*args,**kw): return command(COMPOSE+list(args),**kw)
def operator(*args,grace=None):
options=['-e','RECONCILE_GRACE_PERIOD='+grace] if grace else []
output=compose('run','--rm','-T',*options,'operator','storage',*args)
return json.loads(output)
def sql(query): return compose('exec','-T','postgres','psql','-U','messenger','-d','messenger','-Atc',query).strip()
def snapshot():
ids=compose('ps','-q','api','postgres','redis','s3','lb').split()
results=[]
for cid in ids:
info=json.loads(command(['docker','inspect','--format','{{json .State}}',cid]))
name=command(['docker','inspect','--format','{{.Name}}',cid]).strip().lstrip('/')
results.append({'name':name,'id':cid,'started_at':info['StartedAt'],'running':info['Running'],'health':info.get('Health',{}).get('Status')})
return results
def ready(c):
deadline=time.monotonic()+90
while time.monotonic()<deadline:
try: c.call('GET','/health/ready',schema='Health'); return
except Exception: time.sleep(.5)
raise AssertionError('API did not recover')
def padded_png(data,size):
padding=b'\0'*(size-len(data)-12)
chunk=b'paDd'+padding
return data[:-12]+struct.pack('>I',len(padding))+chunk+struct.pack('>I',zlib.crc32(chunk))+data[-12:]
def upload(c,actor,chat,data):
return c.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=sample.png',actor=actor,raw=data,expected=(201,429),headers={'Content-Type':'image/png'},schema='Attachment')
def direct_api(container,path,actor=None,body=b'',content_type='image/png'):
# Feed credentials via stdin, never argv or evidence. Only controlled results
# are returned to the report, not the raw HTTP request.
method='POST' if body else 'GET'
headers=[f'{method} {path} HTTP/1.1','Host: api','Connection: close']
if actor: headers.append('Authorization: Bearer '+actor['token'])
if body: headers.extend(['Content-Type: '+content_type,'Content-Length: '+str(len(body))])
raw=('\r\n'.join(headers)+'\r\n\r\n').encode()+body
p=subprocess.Popen(['docker','exec','-i',container,'nc','-w','10','127.0.0.1','8080'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
try:
# BusyBox nc closes the socket on stdin EOF. Keep stdin open until the
# response starts so the probe itself does not cancel the server context.
p.stdin.write(raw);p.stdin.flush()
readable,_,_=select.select([p.stdout],[],[],15)
check(bool(readable),'internal API probe timed out')
line=p.stdout.readline()
return int(line.split(b' ',2)[1])
finally:
p.stdin.close()
try: p.wait(timeout=3)
except subprocess.TimeoutExpired: p.kill();p.wait()
def failures(c,actor,chat,data):
findings={}
att=upload(c,actor,chat,data)['json']
c.message(actor,chat,'',attachments=[att['id']])
key=sql("SELECT object_key FROM attachments WHERE id='"+att['id']+"'")
raw=compose('exec','-T','api','/usr/local/bin/messenger','storage','private-check','--key',key)
findings['private_bucket']=json.loads(raw)
save('failures',findings)
before=snapshot()
command([sys.executable,'tests/resilience.py','--mode','persistence','--action-script','scripts/restart.sh','--base-url',BASE],name='persistence')
after=snapshot()
after_by_name={x['name']:x for x in after}
check(all(old['name'] in after_by_name and after_by_name[old['name']]['running'] and
(after_by_name[old['name']]['id']!=old['id'] or after_by_name[old['name']]['started_at']!=old['started_at'])
for old in before),'restart hook did not restart or replace every store/API/LB')
findings['restart']={'before':before,'after':after}
save('failures',findings)
findings['failover']=[]
for target in compose('ps','-q','api').split():
hostname=command(['docker','inspect','--format','{{.Config.Hostname}}',target]).strip()
for _ in range(20):
response=upload(c,actor,chat,data)
if response['headers']['X-Instance-Id'].startswith(hostname+'-'):break
else: raise AssertionError('cannot route upload to intended replica')
attachment=response['json'];alias=response['headers']['X-Instance-Id']
stop_env=dict(ENV,TARGET_INSTANCE_ID=alias)
p=subprocess.run(['./scripts/stop-one.sh'],cwd=ROOT,env=stop_env,capture_output=True,timeout=15)
check(p.returncode==0,'targeted stop failed')
deadline=time.monotonic()+10
while True:
try:
downloaded=c.call('GET','/api/v1/attachments/'+attachment['id']+'/content',actor=actor)
check(downloaded['bytes']==data,'failover changed original')
check(downloaded['headers']['X-Instance-Id']!=alias,'stopped uploader served download')
break
except Exception:
check(time.monotonic()<deadline,'download did not recover');time.sleep(.3)
check(command(['docker','inspect','--format','{{.State.Running}}',target]).strip()=='false','target not stopped')
findings['failover'].append({'stopped_container':target,'upload_instance':alias,'download_instance':downloaded['headers']['X-Instance-Id'],'sha256':hashlib.sha256(data).hexdigest()})
save('failures',findings)
compose('up','-d','--no-deps','--wait','api');ready(c)
command([sys.executable,'tests/resilience.py','--mode','failover','--action-script','scripts/stop-one.sh','--base-url',BASE],name='failover')
compose('up','-d','--no-deps','--wait','api');ready(c)
api=compose('ps','-q','api').split()[0]
try:
compose('stop','s3')
check(direct_api(api,'/health/live')==200,'S3 outage killed liveness')
check(direct_api(api,'/health/ready')==503,'S3 outage did not fail readiness')
status=direct_api(api,'/api/v1/chats/'+chat['id']+'/attachments?filename=sample.png',actor,data)
check(status==503,'S3 failure upload must return 503')
blocked=compose('run','--rm','-T','operator','storage','reconcile','--apply',expected=1,name='reconcile-s3-down')
scan=json.loads(blocked)
check(scan['deleted']==0 and scan['marked_missing']==0,'S3 outage caused reconciliation writes')
findings['s3_outage']={'live':200,'ready':503,'upload':status,'reconciler':scan}
save('failures',findings)
finally:
compose('up','-d','--no-deps','--wait','s3')
compose('run','--rm','-T','s3-init')
ready(c)
# A client disconnect before all bytes are received cannot create a ready row.
count_before=sql('SELECT count(*) FROM attachments')
conn=http.client.HTTPConnection('localhost',18082,timeout=10)
conn.putrequest('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=sample.png')
conn.putheader('Authorization','Bearer '+actor['token']);conn.putheader('Content-Type','image/png');conn.putheader('Content-Length',len(data)*2);conn.endheaders();conn.send(data[:100]);conn.close();time.sleep(.5)
check(sql('SELECT count(*) FROM attachments')==count_before,'interrupted body created metadata')
findings['interrupted_upload']={'metadata_unchanged':True}
save('failures',findings)
# Real database-side timeout after S3 PUT, without production fault switches.
lock=subprocess.Popen(COMPOSE+['exec','-T','postgres','psql','-U','messenger','-d','messenger','-Atc',"BEGIN; LOCK TABLE attachments IN ACCESS EXCLUSIVE MODE; SELECT pg_sleep(4); COMMIT;"],cwd=ROOT,env=ENV,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
try:
deadline=time.monotonic()+3
while sql("SELECT EXISTS(SELECT 1 FROM pg_locks WHERE relation='attachments'::regclass AND mode='AccessExclusiveLock' AND granted)")!='t':
check(lock.poll() is None and time.monotonic()<deadline,'lock session failed')
time.sleep(.05)
failed=c.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=sample.png',503,actor=actor,raw=data,headers={'Content-Type':'image/png'})
check(failed['status']==503,'database timeout not reported')
finally:
lock.communicate(timeout=10)
check(sql('SELECT count(*) FROM attachments')==count_before,'failed metadata write committed')
findings['s3_put_db_timeout']={'upload_status':503,'metadata_unchanged':True}
save('failures',findings)
findings['dry_run_after_failed_commit']=operator('reconcile')
check(findings['dry_run_after_failed_commit']['orphans']>=1,'failed DB write did not leave detectable orphan')
# Missing objects retain IDs/references and can only be restored from originals.
operator('remove-object','--id',att['id'])
dry=operator('reconcile');check(dry['missing']>=1,'missing object not detected')
apply=operator('reconcile','--apply');check(apply['missing']>=1,'missing object not marked')
c.call('GET','/api/v1/attachments/'+att['id'],503,actor=actor)
bad=compose('run','--rm','-T','operator','storage','restore','--id',att['id'],'--source','/fixtures/README.md',expected=1)
operator('restore','--id',att['id'],'--source','/fixtures/sample.png')
operator('restore','--id',att['id'],'--source','/fixtures/sample.png')
downloaded=c.call('GET','/api/v1/attachments/'+att['id']+'/content',actor=actor)
check(downloaded['bytes']==data,'restored bytes changed')
history=c.call('GET','/api/v1/chats/'+chat['id']+'/messages',actor=actor,schema='MessagePage')['json']
check(any(att['id'] in m['attachment_ids'] for m in history['items']),'restoration lost message reference')
findings['missing_repair']={'dry_run':dry,'apply':apply,'wrong_original_rejected':True,'restored_sha256':hashlib.sha256(data).hexdigest(),'reference_preserved':True,'repeat_safe':True}
save('failures',findings)
count_before=sql('SELECT count(*) FROM attachments')
try:
compose('stop','postgres')
raw=compose('run','--rm','-T','operator','storage','reconcile','--apply',expected=1,name='reconcile-db-down')
scan=json.loads(raw)
check(scan['deleted']==0 and scan['marked_missing']==0,'DB outage caused reconciliation writes')
findings['database_outage']={'reconciler':scan}
finally:
compose('up','-d','--no-deps','--wait','postgres');ready(c)
check(sql('SELECT count(*) FROM attachments')==count_before,'DB restart lost attachment metadata')
save('failures',findings)
return findings
def measurements(c,actor,chat,data):
records=[]
for size in [len(data),5*1024*1024]:
body=data if size==len(data) else padded_png(data,size)
for trial in range(1,4):
compose('up','-d','--no-deps','--force-recreate','--wait','api');ready(c)
upload(c,actor,chat,data) # One documented warm-up upload.
ids=compose('ps','-q','api').split()
cpu=subprocess.Popen(['docker','stats','--no-stream','--format','{{json .}}',*ids],stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
barrier=threading.Barrier(10)
def work(_): barrier.wait();return upload(Client(BASE,timeout=30),actor,chat,body)
start=time.monotonic()
with futures.ThreadPoolExecutor(max_workers=10) as pool: results=list(pool.map(work,range(10)))
duration=time.monotonic()-start
successful=[x['elapsed'] for x in results if x['status']==201]
rss=[]
for cid in ids:
values=command(['docker','exec',cid,'sh','-c','cat /sys/fs/cgroup/memory.current /sys/fs/cgroup/memory.peak']).split()
rss.append({'container':cid,'memory_current_bytes':int(values[0]),'memory_peak_bytes':int(values[1])})
stats,_=cpu.communicate(timeout=15)
cpu_samples=[{'container':v.get('Name'),'cpu_percent':v.get('CPUPerc')} for v in [json.loads(line) for line in stats.splitlines()]]
def quantile(p): return sorted(successful)[min(len(successful)-1,int((len(successful)-1)*p))] if successful else None
records.append({'bytes':len(body),'trial':trial,'clients':10,'warmup_uploads':1,'duration_seconds':duration,'successful':len(successful),'errors':10-len(successful),'error_rate':(10-len(successful))/10,'successful_rps':len(successful)/duration,'p50':quantile(.5),'p95':quantile(.95),'p99':quantile(.99),'status_counts':{str(code):sum(x['status']==code for x in results) for code in [201,429]},'memory':rss,'cpu':cpu_samples})
save('uploads',records)
return records
def research(c,actor,chat,data):
results=[]
# Demonstrate freshness independently of the duration of mass seeding/scanning.
fresh_key=operator('seed')['keys'][0]
invalid_key='originals/not-a-server-uuid-'+uuid.uuid4().hex
outside_key='unmanaged/'+uuid.uuid4().hex
operator('seed','--key',invalid_key)
operator('seed','--key',outside_key)
fresh=operator('reconcile','--apply',grace='1h')
check(operator('object-check','--key',fresh_key)['exists'],'fresh object deleted')
# Upload and reconciliation execute concurrently; every acknowledged upload
# must remain downloadable. The separate PostgreSQL test checks lock contention.
with futures.ThreadPoolExecutor(max_workers=2) as workers:
scan=workers.submit(operator,'reconcile','--apply')
concurrent_upload=upload(c,actor,chat,data)
scan_result=scan.result()
check(concurrent_upload['status']==201,'concurrent upload failed')
att=concurrent_upload['json']
check(c.call('GET','/api/v1/attachments/'+att['id']+'/content',actor=actor)['bytes']==data,'concurrent reconciliation damaged upload')
safety={'fresh_apply':fresh,'fresh_key_preserved':True,'concurrent_scan':scan_result,'concurrent_upload_sha256':hashlib.sha256(data).hexdigest()}
save('reconciliation-safety',safety)
for count in [100,1000]:
operator('seed','--count',str(count))
# All objects exist before the grace wait starts. Duration of seeding is
# intentionally excluded from the scan timing, but dataset size is recorded.
time.sleep(16)
scans=[operator('reconcile') for _ in range(3)]
applied=operator('reconcile','--apply')
repeated=operator('reconcile','--apply')
check(applied['deleted']>=count,'old orphans not cleaned')
check(repeated['deleted']==0 and repeated['missing']==0,'repeat was not safe or valid original deleted')
check(operator('object-check','--key',invalid_key)['exists'],'invalid managed key deleted')
check(operator('object-check','--key',outside_key)['exists'],'object outside prefix deleted')
results.append({'seeded':count,'dry_runs':scans,'apply':applied,'repeat_apply':repeated,'invalid_key_preserved':True,'outside_prefix_preserved':True})
save('reconciliation',results)
return results
def main():
OUT.mkdir(exist_ok=True)
stage("bootstrap")
command(['./scripts/bootstrap.sh'],name='bootstrap')
before_keys=hashlib.sha256((ROOT/'secrets/lab4/s3.json').read_bytes()).hexdigest()
command(['./scripts/bootstrap.sh'],name='bootstrap-repeat')
check(before_keys==hashlib.sha256((ROOT/'secrets/lab4/s3.json').read_bytes()).hexdigest(),'bootstrap rotated credentials')
compose('config','--quiet',name='compose-config')
compose('up','-d','--build','--wait','--wait-timeout','120',name='stand-up',timeout=600)
meta={'run_id':RUN_ID,'date_utc':datetime.datetime.now(datetime.timezone.utc).isoformat(),'git_head':command(['git','rev-parse','HEAD']).strip(),'working_tree_dirty':bool(command(['git','status','--porcelain']).strip()),'host':platform.platform(),'docker':json.loads(command(['docker','info','--format','{{json .}}'])),'project':ENV['COMPOSE_PROJECT_NAME'],'limits':{'api_replicas':2,'api_cpu_each':1,'api_ram_each':536870912,'upload_timeout':'5s','grace':'15s','upload_slots_each':4,'decode_slots_each':1}}
# Keep a small allow-list; docker info can contain unrelated host settings.
meta['docker']={k:meta['docker'][k] for k in ['ServerVersion','Architecture','NCPU','MemTotal']}
(OUT/'environment.json').write_text(json.dumps(meta,indent=2)+'\n')
compose('run','--rm','-T','s3-init',name='bucket-bootstrap-repeat')
c=Client(BASE,timeout=20);ready(c)
command(['make','check','build','vet'],name='build-checks')
validator=str(ROOT/'.venv/bin/python') if (ROOT/'.venv/bin/python').exists() else sys.executable
command(['make','validate','PYTHON='+validator],name='validate')
command(['make','test-go','BASE_URL='+BASE],name='go-tests')
command(['make','test-storage'],name='storage-tests')
command(['make','test','BASE_URL='+BASE],name='smoke')
actor,bob,eve,chat=c.bootstrap();data=(ROOT/'tests/fixtures/sample.png').read_bytes()
stage('faults')
findings=failures(c,actor,chat,data)
(OUT/'failures.json').write_text(json.dumps(findings,indent=2)+'\n')
stage('uploads')
(OUT/'uploads.json').write_text(json.dumps(measurements(c,actor,chat,data),indent=2)+'\n')
stage('reconciliation')
(OUT/'reconciliation.json').write_text(json.dumps(research(c,actor,chat,data),indent=2)+'\n')
result={'run_id':RUN_ID,'passed':True,'checks':['contract','go_race','transaction_rollback','smoke','private_bucket','persistence','both_uploaders_failover','public_failover','s3_down','interrupted_body','s3_put_db_timeout','missing_restore','10_client_memory','reconciler_grace','reconciler_repeat'],'remaining_metadata':int(sql('SELECT count(*) FROM attachments')),'timestamp_utc':datetime.datetime.now(datetime.timezone.utc).isoformat()}
compose('down',name='stand-down')
save('acceptance',result) # Preserve all experiment volumes.
print('PASS: lab4 acceptance; summaries in evidence/. Isolated stand stopped; volumes preserved.',flush=True)
if __name__=='__main__': main()
+25
View File
@@ -0,0 +1,25 @@
#!/usr/bin/env python3
"""Generate local synthetic storage credentials without rotating existing keys."""
import json
import os
from pathlib import Path
import secrets
root=Path(__file__).resolve().parents[1]/'secrets'/'lab4'
root.mkdir(parents=True,exist_ok=True)
for name in ('s3_admin_access','s3_admin_secret','s3_api_access','s3_api_secret'):
p=root/name
if not p.exists():
p.write_text(secrets.token_hex(24)+'\n')
p.chmod(0o444) # Non-root containers must read these local synthetic secrets.
bucket=os.environ.get('S3_BUCKET','messenger-attachments')
identities=[]
for role,actions in [('admin',['Admin','Read','Write','List','Tagging']),('api',['Read:'+bucket,'Write:'+bucket,'List:'+bucket])]:
identities.append({'name':role,'credentials':[{'accessKey':(root/('s3_'+role+'_access')).read_text().strip(),'secretKey':(root/('s3_'+role+'_secret')).read_text().strip()}],'actions':actions})
p=root/'s3.json'
content=json.dumps({'identities':identities})+'\n'
if not p.exists() or p.read_text()!=content:
if p.exists(): p.chmod(0o600)
p.write_text(content)
p.chmod(0o444)
print('Local storage credentials ready; existing keys preserved.')
+23
View File
@@ -0,0 +1,23 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
umask 077
mkdir -p secrets/lab4
if [ ! -f .env.lab4 ]; then
{ printf 'POSTGRES_PASSWORD='; openssl rand -hex 24
printf 'REDIS_PASSWORD='; openssl rand -hex 24
printf 'HOST_PORT=18081\nAPI_REPLICAS=2\n'
} > .env.lab4
fi
if [ ! -f secrets/lab4/private_key.pem ]; then
openssl genrsa -out secrets/lab4/private_key.pem 2048 2>/dev/null
fi
if [ ! -f secrets/lab4/public_key.pem ]; then
openssl rsa -in secrets/lab4/private_key.pem -pubout -out secrets/lab4/public_key.pem 2>/dev/null
fi
# Only synthetic stand keys, readable by the non-root application inside containers.
chmod 755 secrets secrets/lab4
chmod 444 secrets/lab4/*.pem
printf '%s\n' 'Local lab4 settings and synthetic keys ready; existing files preserved.'
python3 scripts/bootstrap-storage.py
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
exec docker compose --env-file .env.lab4 "$@"
+17
View File
@@ -0,0 +1,17 @@
#!/usr/bin/env python3
"""Convert a temporary generation view to the oapi-codegen 3.0 subset.
Runtime handlers enforce anyOf and required fields; normative contract is untouched.
"""
import json
from pathlib import Path
s=json.loads(Path('contracts/openapi.json').read_text())
for schema in s['components']['schemas'].values():
schema.pop('anyOf',None)
for prop in schema.get('properties',{}).values():
if prop.get('type')==['string','null']:
prop.update(type='string',nullable=True)
# Preserve pointers so handlers can distinguish missing fields from empty values.
for name,field in [('CreateUser','password'),('CreateMessage','text')]:
s['components']['schemas'][name]['properties'][field]['x-go-type-skip-optional-pointer']=False
s['components']['schemas'][name]['required'].remove(field)
print(json.dumps(s))
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
./scripts/compose.sh stop api lb
./scripts/compose.sh restart postgres redis s3
./scripts/compose.sh run --rm -T s3-init
./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
+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 lab4 API container' >&2
exit 1
+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="lab4_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
+191
View File
@@ -0,0 +1,191 @@
#!/usr/bin/env python3
"""Build the lab4 report only from a successfully completed acceptance run."""
import json
from pathlib import Path
import statistics
ROOT=Path(__file__).resolve().parents[1]
E=ROOT/'evidence'
def read(name):return json.loads((E/(name+'.json')).read_text())
a=read('acceptance');env=read('environment')
if not a.get('passed') or a.get('run_id')!=env.get('run_id'):
raise SystemExit('A completed matching acceptance run is required before writing REPORT.md')
f=read('failures');uploads=read('uploads');scans=read('reconciliation');safety=read('reconciliation-safety')
limit=env['limits'];hw=env['docker']
rows=[]
for x in uploads:
peak=max(v['memory_peak_bytes'] for v in x['memory'])/1048576
cpu=', '.join(v['cpu_percent'] for v in x['cpu'])
fmt=lambda value: '-' if value is None else f'{value*1000:.1f}'
rows.append(f"| {x['bytes']} | {x['trial']} | {x['duration_seconds']:.3f} | {x['successful']}/10 | {x['successful_rps']:.1f} | {x['error_rate']:.0%} | {fmt(x['p50'])}/{fmt(x['p95'])}/{fmt(x['p99'])} | {peak:.1f} | {cpu} |")
scan_rows=[]
for x in scans:
sample=x['dry_runs'][0]
duration=statistics.median(v['duration_ms'] for v in x['dry_runs'])
scan_rows.append(f"| {x['seeded']} | {sample['objects']} / {sample['metadata']} | {duration:.0f} | {sample['s3_requests']} | {sample['db_checks']} | {sample['lock_attempts']} | {x['apply']['deleted']} | {x['repeat_apply']['deleted']} |")
max_peak=max(v['memory_peak_bytes'] for x in uploads for v in x['memory'])/1048576
failover_rows=[]
for i,x in enumerate(f['failover'],1):
failover_rows.append(f"| Uploader {i} | Остановлен именно процесс `{x['upload_instance']}` | Скачал `{x['download_instance']}`; SHA-256 совпал |")
report=f'''# Отчёт — лабораторная 4: S3 и согласованность двух хранилищ
- Автор, группа: Поликарпов Даниил Александрович, БПИ2303.
- Целевая оценка: **5, трек 2 — согласованность PostgreSQL/S3**.
- Измерения: {env['date_utc']}; окончание проверки: {a['timestamp_utc']}.
- HEAD репозитория на момент проверки: `{env['git_head']}`; рабочее дерево содержит незакоммиченную реализацию. Это HEAD основы, а не опубликованный commit решения. Commit/PR ещё не созданы.
- Идентификатор полного прогона: `{a['run_id']}`; итог — [acceptance.json](evidence/acceptance.json).
- Реализация, диагностика и подготовка отчёта выполнены с помощью OpenAI Codex. Исходники проверок и методики включены в репозиторий.
## Запуск из чистого clone
Нужны Docker Engine и Compose v2+, Go 1.27+, Python 3.9+, Bash, OpenSSL и Git. Проверено: {env['host']}, Docker {hw['ServerVersion']}, {hw['Architecture']}, {hw['NCPU']} vCPU и {hw['MemTotal']/1073741824:.2f} GiB памяти Docker VM. Нужны свободные loopback-порты 18081 и 18082. Соседние репозитории не требуются.
```sh
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements-dev.txt
make up
make check validate PYTHON=.venv/bin/python
make build vet test test-go test-storage
make test-persistence ACTION_SCRIPT=./scripts/restart.sh
make test-failover ACTION_SCRIPT=./scripts/stop-one.sh
make restore
make reconcile
# Полный изолированный прогон, включая отказы и исследование:
make evidence PYTHON=.venv/bin/python
python3 scripts/write-report.py
# Безопасная остановка основного стенда, данные сохраняются:
make down
```
`make up` идемпотентно создаёт `.env.lab4`, JWT-ключи и отдельные S3 admin/API-ключи в `secrets/lab4`; существующие пароли и ключи не заменяются. Файлы игнорируются Git и исключены из Docker build context. API монтирует только JWT и собственные S3-ключи, admin-ключи в API не попадают. Единственная публикация основного стенда — `127.0.0.1:18081` через HAProxy.
Для **намеренного удаления только учебных данных основного стенда** оператор может выполнить `./scripts/compose.sh down -v`. При обычном restart/failover эта команда не применяется. Экспериментальный проект — `mtusi2026lab4-evidence`; его volumes также сохраняются после проверки. Повторная приёмка добавляет синтетические данные к существующим, что отражено в фактических размерах наборов.
## Архитектура и конфигурация
Клиент → HAProxy → API × 2 → PostgreSQL + приватный SeaweedFS. Redis хранит кэш неизменного состава чата; серверные сессии остаются в PostgreSQL. Перенесены регистрация/сессии, чаты, keyset-пагинация, общая БД и идемпотентность lab3. Добавлены Attachment, связи с сообщениями, HTTP endpoints, S3, reconciler и операторское восстановление.
| Роль | Образ / версия | Готовность и сохранность | Доступ |
| --- | --- | --- | --- |
| API × 2 / migrator | Сборка исходников: Go 1.27.2-alpine3.23 → Alpine 3.23.6 | `/health/live`; `/health/ready` проверяет PostgreSQL и S3 | API-порты не опубликованы; migrator — отдельный одноразовый процесс |
| PostgreSQL | 17.11-alpine3.23 | `pg_isready`; `postgres_data` | Только сеть Compose |
| Redis | 8.2.11-alpine3.22 | AUTH PING; AOF в `redis_data` | Только сеть Compose |
| HAProxy | 3.2-alpine | Проверяет readiness каждой API-реплики | Только loopback 18081 |
| SeaweedFS | 4.52 | `s3_data` содержит master/volume/filer; bootstrap проверяет bucket и PUT/DELETE | Только internal-сеть storage, без публикации gateway/master/filer |
Все digest закреплены в `compose.yaml` и Dockerfile. SeaweedFS: `sha256:57877e32bb90073b37dc109b438ba66e84fd5ed9ced5f5c04f56444ef243ce59`. `s3-init` использует admin identity и создаёт приватный bucket. В его JSON нет anonymous identity. API identity ограничена Read/Write/List конкретного bucket и не имеет Admin; создание другого bucket отвергается. Образы и точные зависимости Go зафиксированы manifest/lock-файлами проекта.
`.env.example` описывает параметры Compose: HOST_PORT/API_REPLICAS, пароли PostgreSQL/Redis, лимиты API и пула, SESSION_TTL_SECONDS, S3_BUCKET, MAX_UPLOAD_BYTES/MAX_IMAGE_PIXELS, UPLOAD_TIMEOUT и RECONCILE_GRACE_PERIOD. Их изменения задаются в `.env.lab4` или окружении оператора. S3_ENDPOINT, S3_REGION и пути credentials зафиксированы в `compose.yaml`; одноимённые переменные в `.env.lab4` их не переопределяют. В примере они приведены как комментарии для справки.
Для нестандартного bucket нужно также экспортировать `S3_BUCKET` перед `make up`: генератор S3-политики читает окружение процесса, а не `.env.lab4`. Для сдачи и приёмки используется стандартный `messenger-attachments`. Основной и экспериментальный проекты используют общие локальные файлы credentials; менять bucket/политику при работающем основном стенде не следует.
По умолчанию: API — 1 CPU/512 MiB каждая, четыре upload slots, один decoder, `GOMEMLIMIT=384MiB`; PostgreSQL — 2 CPU/1 GiB, Redis — 0.25 CPU/128 MiB, S3 — 1 CPU/512 MiB, LB — 0.5 CPU/128 MiB. Это лимиты контейнеров, а не гарантия высокой доступности единственного Docker-host.
## Синхронная загрузка и транзакционные границы
1. Проверить сессию и членство в чате; неизвестный и чужой ресурс одинаково дают 404. Проверить отображаемое filename, MIME и Content-Length.
2. Прочитать не более 10 MiB через MaxBytesReader во временный файл, одновременно вычисляя SHA-256. Проверить формат и размеры через DecodeConfig, затем полностью декодировать PNG/JPEG под отдельным semaphore. Лимит 40 млн пикселей проверяется до полной распаковки.
3. Сервер генерирует уникальный ключ `originals/<UUID>` и получает advisory session lock этого ключа. Filename не участвует ни в локальном пути, ни в S3 key.
4. Сохранить оригинал в S3, затем атомарно вставить метаданные в PostgreSQL. Только после подтверждённого сохранения вернуть 201, `status=ready`, `variants=[]`, `error_code=null`.
5. Удалить временный файл. После ответа скачивание зависит от S3 и БД, а не от файловой системы загрузившей реплики. Скачивание проходит через авторизованный API без redirect; Content-Length позволяет клиенту обнаружить обрыв передачи.
Атомарной транзакции PostgreSQL+S3 нет. При неопределённом результате COMMIT API возвращает ошибку, **не выполняя слепой S3 DELETE**: COMMIT мог пройти. Reconciler позже проверяет наличие метаданных. Обрыв тела до завершения чтения не создаёт готовый Attachment. Повтор самостоятельного upload может создать ещё один объект; прозрачных повторов публичного POST нет.
Сообщение, все связи вложений и результат идемпотентности записываются одной PostgreSQL-транзакцией. Правило «текст или вложение», UTF-8/4000 символов, максимум 10 уникальных ID и доступность вложений проверяет Go-сервис; функции и триггера `message_content` в миграциях нет. FK сохраняют ссылочную целостность. При проверке вложений используются row locks до COMMIT.
Версия хеша хранится в `hash_version`: legacy v1 учитывает текст, v2 — канонический текст и упорядоченный список ID. Отсутствующий список и `[]` равнозначны. Старые текстовые ключи продолжают воспроизводиться; изменение текста или вложений при том же ключе даёт 409. Порядок вложений сохраняется.
## Reconciler и восстановление
```sh
make reconcile # По умолчанию dry-run
make reconcile-apply # Применить безопасные изменения
./scripts/compose.sh run --rm -T operator storage restore \\
--id <attachment-uuid> --source /fixtures/sample.png
```
Сверка читает S3 страницами по 100 объектов и БД keyset-страницами по 100 метаданных. Обрабатываются только серверные ключи `originals/<UUID>`. Для каждого ключа используется та же advisory lock, что при upload/restore; под ней проверяются метаданные и актуальный HEAD объекта. Если метаданные существуют, объект защищён, даже если он ещё не прикреплён к сообщению. Отсутствующие метаданные плюс возраст старше grace позволяют удалить orphan.
В обычном стенде upload timeout — 120 секунд, grace — один час; конфигурация требует grace больше удвоенного timeout. Это запас для отменённого запроса/потерянной DB-сессии. Предполагаются синхронизированные часы локального стенда. При неопределённом получении или освобождении lock соединение закрывается, а не возвращается в pool с потенциально удерживаемой блокировкой.
Missing — метаданные без оригинала. Dry-run только сообщает проблему; apply выставляет внутренний `integrity_missing`, сохраняя metadata, ID и ссылки сообщений. Клиент с доступом получает 503; публичный enum статуса lab4 не меняется. Восстановление требует предоставленного оригинала с совпадающими размером, MIME и SHA-256. После PUT выполняется контрольное чтение; только затем снимается признак повреждения. Неверный оригинал отвергается, повторный restore безопасен.
При ошибке любой зависимости проход завершается ненулевым кодом, сохраняя частичные счётчики. Уже выполненные безопасные действия не откатываются: общего COMMIT между хранилищами нет. Повторный запуск продолжает исправление. Для регулярной очистки оператору нужно запускать `make reconcile-apply`, например каждые 10 минут через свой планировщик; автоматическое cron-расписание не устанавливается.
## Доказательства критериев
| Критерий | Команда / наблюдение | Доказательство |
| --- | --- | --- |
| Структура и полный OpenAPI | `make check build vet`, `make validate` — PASS | [build-checks](evidence/build-checks.txt), [validate](evidence/validate.txt) |
| Возможности lab3 и идемпотентность | Go race suite: история/пагинация, 32 конкурентных повтора через 2 реплики | [go-tests](evidence/go-tests.txt) |
| Обязательный API lab4 | Публичный smoke: файл, attachment-only message, checksum, ACL — PASS | [smoke](evidence/smoke.txt) |
| PNG/JPEG, bytes/pixels, filename | Exact 10 MiB — 201; превышение bytes, chunked и pixels — 413; MIME/corruption — 415; filename — 400 | [go-tests](evidence/go-tests.txt) |
| Чужой файл и чат | Metadata/content и cross-chat attachment — 404; duplicate/null ID list — 400 | [go-tests](evidence/go-tests.txt) |
| Только Go-проверка содержимого | Пустое сообщение отклоняется; attachment-only сохраняется; триггер отсутствует | [storage-tests](evidence/storage-tests.txt) |
| Атомарность сообщений | Ошибка FK/записи ключа откатывает сообщение, связи и результат; legacy replay сохранён | [storage-tests](evidence/storage-tests.txt) |
| Приватность и ограниченные ключи | Unsigned GET известного объекта — {f['private_bucket']['anonymous_status']}; API CreateBucket запрещён | [failures](evidence/failures.json) |
| Persistence | Прежний token и исходный файл пережили restart; до/после видны реальные процессы всех stores | [persistence](evidence/persistence.txt), [snapshots](evidence/failures.json) |
| Остановка загрузившей реплики | Поочерёдно остановлены обе; файл скачан другой репликой с тем же SHA-256 | [failures](evidence/failures.json) |
| Публичный failover | Запись во время отказа, повторы без дубля, прежняя сессия — PASS | [failover](evidence/failover.txt) |
| Недоступность S3 | Liveness 200, readiness/upload 503; reconciler не удаляет/не помечает | [failures](evidence/failures.json), [S3 down](evidence/reconcile-s3-down.txt) |
| Отказ PostgreSQL | Сверка прекращается без изменений; после восстановления метаданные сохранены | [failures](evidence/failures.json), [DB down](evidence/reconcile-db-down.txt) |
| Прерывание и PUT → ошибка БД | Незавершённый body не создаёт строку; timeout после PUT даёт диагностируемый orphan | [failures](evidence/failures.json) |
| Missing и восстановление | Обнаружен; неверный оригинал отвергнут; верный восстановлен дважды без потери ссылки | [failures](evidence/failures.json) |
| Память при 10 клиентах | Два размера, три повтора; ограничение admission учитывается в ошибках | [uploads](evidence/uploads.json) |
| Безопасная сверка | Fresh и использованные объекты сохранены, старые orphan удалены, повтор ничего не удаляет | [safety](evidence/reconciliation-safety.json), [scans](evidence/reconciliation.json) |
| Bootstrap | Повтор сохраняет ключи; существующий bucket допускает bootstrap и проверку записи | [bootstrap-repeat](evidence/bootstrap-repeat.txt), [bucket repeat](evidence/bucket-bootstrap-repeat.txt) |
Полная команда воспроизведения — `make evidence`. PASS означает завершение перечисленных локальных сценариев, а не автоматическое выставление оценки. Секреты, tokens и raw HTTP-запросы в evidence не сохраняются.
## Эксперименты
Гипотеза: при неизменяемых серверных ключах, общей блокировке и grace можно повторяемо удалить orphan, сохранив свежие и используемые вложения; missing обнаруживаются, а внешний оригинал позволяет восстановить данные без смены ссылок.
Изолированный проект использует те же образы и контейнерные ресурсы, но `UPLOAD_TIMEOUT=5s`, `RECONCILE_GRACE_PERIOD=15s`, чтобы ждать grace без часовой паузы. Обычные defaults остаются 120s/1h. Защита свежего объекта отдельно проверяется с grace 1h, независимо от длительности массового заполнения. Наборы содержат также ранее загруженные файлы — фактические размеры указаны ниже.
### Upload: bytes и память
Перед каждым из трёх повторов для каждого размера API-контейнеры создаются заново, выполняется одна прогревочная загрузка исходного малого файла, затем barrier запускает 10 клиентов одновременно. Отдельного длительного прогрева нет. Оригинал — RGB PNG 320×200, {uploads[0]['bytes']} байт; вариант 5 MiB содержит валидный ancillary PNG chunk и имеет те же декодированные размеры. Это сравнение стоимости передачи bytes, а не исследование больших изображений.
| Bytes | Повтор | Длительность, s | Успехи | Успешные RPS | Ошибки | p50/p95/p99, ms | Max peak одной API, MiB | CPU samples API |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
{chr(10).join(rows)}
Максимальный наблюдавшийся пик одной API: **{max_peak:.1f} MiB** при лимите 512 MiB. Сняты `memory.current` и kernel `memory.peak` cgroup v2: peak относится ко всей жизни заново созданного контейнера, включая startup и прогрев, а не только к интервалу burst. CPU — короткий `docker stats --no-stream` sample; он не даёт надёжной оценки steady-state CPU для столь короткого burst. В errors отдельно учитываются 429, повторов скрыто нет. Percentiles относятся только к успешным запросам; 10 наблюдений недостаточно для устойчивой оценки хвоста. RPS включает клиентскую подготовку, не доказывает максимальную пропускную способность сервера.
### Стоимость сверки
После заполнения выдерживается 16 секунд, выполняются три dry-run, apply и повторный apply. В таблице — медиана времени dry-run; счётчики вызовов приведены для первого прохода.
| Добавлено orphan | Объекты / metadata | Dry-run median, ms | Вызовы S3 | Проверки/страницы БД | Попытки session lock | Удалено apply | Удалено повторно |
| --- | --- | --- | --- | --- | --- | --- | --- |
{chr(10).join(scan_rows)}
`db_checks` считает проверки наличия, страницы метаданных и изменения; это не все сетевые round trips PostgreSQL. Каждая успешная session lock добавляет SQL получения и освобождения; отдельно показан `lock_attempts`. S3-счётчик включает HEAD bucket, List pages, Head objects и Delete. Стоимость растёт с фактическим числом объектов и метаданных; общий snapshot двух хранилищ не создаётся. Вставка UUID позади keyset cursor может попасть в следующий периодический проход.
Безопасность проверена предметными наблюдениями: свежий orphan остался, referenced originals не удалялись, invalid key и объект вне prefix остались, после очистки второй apply удалил ноль объектов и missing не появилось. Во время отдельного прохода выполнялся upload; его подтверждённый оригинал скачан с тем же checksum. Это конкурентный прогон, а детерминированное ожидание и отмена advisory lock отдельно проверены на реальном PostgreSQL в storage suite.
| Воздействие | Наблюдение | Доказательство |
| --- | --- | --- |
{chr(10).join(failover_rows)}
| Restart PostgreSQL/Redis/S3/API/LB | Прежние данные, session и bytes сохранены; процессы перезапущены или заменены | persistence + snapshots |
| S3 остановлен | 200 live, 503 ready/upload; после bootstrap путь записи восстановлен | failures |
| PostgreSQL остановлен | Reconciler завершился без удаления, после запуска данные сохранены | failures |
| Тело upload оборвано | Строка Attachment не появилась | failures |
| PUT успешен, INSERT заблокирован | Upload 503, метаданные не появились, orphan найден и очищен после grace | failures + reconciliation |
| Оригинал удалён из S3 | Missing отмечен, затем исходник восстановлен с тем же ID/checksum и ссылкой | failures |
В этих сценариях потери подтверждённых данных после restart/failover не обнаружены. Время восстановления отдельно не измерялось: проверки подтверждают восстановление в пределах своих таймаутов, но не дают оценки RTO.
## Ограничения и источники
Один Docker-host, PostgreSQL, Redis, S3 и LB остаются одиночными точками отказа. Сессии хранятся в БД, Redis — необязательный cache; отказ S3 выводит API из readiness. Ошибки, сформированные самим LB при отсутствии здоровых backend, могут не иметь JSON/identity headers приложения. HTTP допустим только для локального стенда с синтетическими данными; TLS — задание lab7.
Reconciler не делает резервное копирование, не восстанавливает bytes из SHA-256 и не проверяет checksum каждого существующего объекта при обычном HEAD-обходе. Если оригинала/backup нет, missing остаётся невосстановимым. Временный локальный файл используется до сохранения, но не является долговременным источником оригинала. `GOMEMLIMIT` — мягкий бюджет Go, а не жёсткая гарантия RSS; предел процесса задаёт cgroup, полная распаковка всё ещё ограничена количеством пикселей и одним decoder.
Периодическую сверку запускает оператор. Потеря БД сессии/сетевые разделения покрываются блокировками, ограничением времени запроса и grace в рамках заявленного локального стенда; глобальной транзакции или защиты от произвольных внешних writers с admin-ключами нет. Нагрузочные результаты привязаны к этому hardware, размерам изображений и короткому burst-профилю.
Первичные материалы: [SeaweedFS 4.52](https://github.com/seaweedfs/seaweedfs/releases/tag/4.52), [S3 credentials/configuration](https://github.com/seaweedfs/seaweedfs/wiki/S3-Configuration), [AWS SDK for Go v2 endpoints](https://docs.aws.amazon.com/sdk-for-go/v2/developer-guide/configure-endpoints.html), [S3 upload semantics](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html). Использованы стандартные Go image/png/jpeg, AWS SDK v2, pgx, chi и oapi-codegen; версии — в go.mod/go.sum и generated header. Обязательный контракт и fixture предоставлены материалами курса.
'''
(ROOT/'REPORT.md').write_text(report)
print('REPORT.md generated from successful acceptance evidence.')