Files
mtusi2026lab2/student-tests/research.ts
T

78 lines
7.7 KiB
TypeScript

import {resolve} from 'node:path';
import {mkdir,mkdtemp,writeFile,chmod} from 'node:fs/promises';
const root=resolve(import.meta.dir,'..');
if(process.argv.includes('--check')){console.log('Research script parsed without accessing the stand');process.exit(0);}
let stage='preflight';
async function command(args:string[],input?:string|Uint8Array){
const p=Bun.spawn(args,{cwd:root,stdin:input===undefined?'ignore':'pipe',stdout:'pipe',stderr:'pipe',signal:AbortSignal.timeout(120000)});
if(input!==undefined){p.stdin.write(input);p.stdin.end();}
const [out,err]=await Promise.all([new Response(p.stdout).text(),new Response(p.stderr).text()]);
if(await p.exited!==0)throw new Error(`${stage}: command rejected (${args[0]})`);
return out;
}
async function guard(){const p=Bun.spawn(['game-running'],{stdout:'ignore',stderr:'pipe'});await new Response(p.stderr).text();if(await p.exited!==1)throw new Error('Research requires a verified inactive game');}
async function sql(query:string,service='postgres',database='messenger'){return await command([resolve(root,'scripts/compose.sh'),'exec','-T',service,'psql','-X','-qAt','-U','messenger','-d',database,'-v','ON_ERROR_STOP=1'],query);}
const nonce=crypto.randomUUID().replaceAll('-','').slice(0,12),user=crypto.randomUUID(),chats=[crypto.randomUUID(),crypto.randomUUID(),crypto.randomUUID()];
const parent=resolve(root,'evidence/research');await mkdir(parent,{recursive:true});
const evidence=await mkdtemp(resolve(parent,'run-'));
await writeFile(resolve(evidence,'run.json'),JSON.stringify({run_id:nonce,started_at:new Date().toISOString(),state:'started'})+'\n',{flag:'wx'});
const local=resolve(root,'.local');
const results:any={dataset:{messages:100000,distribution:[90000,9000,1000]},plans:{},backup:{}};
let apiStopped=false,restoreTouched=false,primary:unknown;const cleanupErrors:string[]=[];
try{
await guard();
if(!(await command([resolve(root,'scripts/compose.sh'),'ps','--status','running','-q','api'])).trim())throw new Error('Expected coursework API is not running');
stage='stop_api';apiStopped=true;await command([resolve(root,'scripts/compose.sh'),'stop','api']);
if((await command([resolve(root,'scripts/compose.sh'),'ps','--status','running','-q','api'])).trim())throw new Error('API did not stop');
stage='seed';
await sql(`BEGIN;
INSERT INTO users(id,username,display_name,password_hash) VALUES('${user}','research_${nonce}','Synthetic research','disabled-no-login');
INSERT INTO chats(id,title) VALUES ${chats.map((id,i)=>`('${id}','Synthetic ${i}')`).join(',')};
INSERT INTO chat_members(chat_id,user_id) VALUES ${chats.map(id=>`('${id}','${user}')`).join(',')};
INSERT INTO messages(id,chat_id,sender_id,text,created_at)
SELECT gen_random_uuid(),CASE WHEN i<=90000 THEN '${chats[0]}'::uuid WHEN i<=99000 THEN '${chats[1]}'::uuid ELSE '${chats[2]}'::uuid END,'${user}','synthetic-'||i,
'2026-01-01T00:00:00Z'::timestamptz+i*interval '1 microsecond' FROM generate_series(1,100000) AS i;
UPDATE users SET message_count=100000 WHERE id='${user}'; COMMIT; ANALYZE messages;`);
const read=`SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id='${chats[0]}' AND (created_at,id)>('2026-01-01T00:00:00.070000Z'::timestamptz,'00000000-0000-0000-0000-000000000000'::uuid) ORDER BY created_at,id LIMIT 51`;
for(const mode of ['chat_only','history']){
await guard();stage='index_'+mode;
if(mode==='chat_only')await sql('DROP INDEX messages_history;CREATE INDEX research_chat_only ON messages(chat_id);ANALYZE messages;');
else await sql('DROP INDEX research_chat_only;CREATE INDEX messages_history ON messages(chat_id,created_at,id);ANALYZE messages;');
stage='read_plan_'+mode;
const raw=await sql('EXPLAIN (ANALYZE,BUFFERS,FORMAT JSON) '+read+';');
await writeFile(resolve(evidence,mode+'-read.json'),raw);results.plans[mode]={read:JSON.parse(raw)[0]};
stage='write_plan_'+mode;
const rawWrite=await sql(`EXPLAIN (ANALYZE,BUFFERS,FORMAT JSON) INSERT INTO messages(id,chat_id,sender_id,text) SELECT gen_random_uuid(),'${chats[0]}','${user}','write-cost-'||i FROM generate_series(1,1000) i;`);
await writeFile(resolve(evidence,mode+'-write.json'),rawWrite);results.plans[mode].write=JSON.parse(rawWrite)[0];
}
stage='fingerprint';
const fingerprint=`SELECT json_build_object('users',(SELECT count(*) FROM users),'chats',(SELECT count(*) FROM chats),'members',(SELECT count(*) FROM chat_members),'messages',(SELECT count(*) FROM messages),'research_messages',(SELECT count(*) FROM messages WHERE sender_id='${user}'),'samples',(SELECT json_agg(t) FROM (SELECT id,text,created_at FROM messages WHERE sender_id='${user}' ORDER BY created_at,id LIMIT 3) t))::text;`;
const before=JSON.parse(await sql(fingerprint));
stage='backup';await guard();const dumpStart=performance.now();
const dump=Bun.spawn([resolve(root,'scripts/compose.sh'),'exec','-T','postgres','pg_dump','-U','messenger','-d','messenger','-Fc','--no-owner','--no-acl'],{cwd:root,stdout:'pipe',stderr:'pipe'});
const dumpFile=resolve(local,'research-backup-'+nonce+'.dump');await Bun.write(dumpFile,new Response(dump.stdout));await new Response(dump.stderr).text();if(await dump.exited!==0)throw new Error('Backup rejected');await chmod(dumpFile,0o600);
results.backup.dump_seconds=(performance.now()-dumpStart)/1000;results.backup.bytes=Bun.file(dumpFile).size;
stage='restore_start';restoreTouched=true;await command([resolve(root,'scripts/compose.sh'),'up','-d','--wait','restore']);
const database='recovery_'+nonce;await sql('CREATE DATABASE '+database,'restore','restore');
stage='restore';const restoreStart=performance.now();
const restore=Bun.spawn([resolve(root,'scripts/compose.sh'),'exec','-T','restore','pg_restore','-U','messenger','-d',database,'--no-owner','--no-acl','--exit-on-error'],{cwd:root,stdin:Bun.file(dumpFile),stdout:'pipe',stderr:'pipe'});
await Promise.all([new Response(restore.stdout).text(),new Response(restore.stderr).text()]);if(await restore.exited!==0)throw new Error('Restore rejected');
results.backup.restore_seconds=(performance.now()-restoreStart)/1000;
const after=JSON.parse(await sql(fingerprint,'restore',database));
if(JSON.stringify(before)!==JSON.stringify(after))throw new Error('Restored row counts or sampled messages differ');
results.backup.verified=before;results.backup.target='separate PostgreSQL container and persistent volume';
await sql('DROP DATABASE '+database,'restore','restore');
await guard();stage='measured';
}catch(error){primary=error;}
finally{
if(apiStopped)try{
await sql('DROP INDEX IF EXISTS research_chat_only;CREATE INDEX IF NOT EXISTS messages_history ON messages(chat_id,created_at,id);');
await sql(`BEGIN;DELETE FROM messages WHERE sender_id='${user}';DELETE FROM chat_members WHERE user_id='${user}';DELETE FROM chats WHERE id=ANY(ARRAY[${chats.map(id=>`'${id}'::uuid`).join(',')}]);DELETE FROM users WHERE id='${user}';COMMIT;`);
}catch{cleanupErrors.push('source_data_or_index');}
if(restoreTouched)try{await sql('DROP DATABASE IF EXISTS recovery_'+nonce,'restore','restore');await command([resolve(root,'scripts/compose.sh'),'stop','restore']);}catch{cleanupErrors.push('restore_database');}
if(apiStopped)try{await command([resolve(root,'scripts/compose.sh'),'start','api']);await command([process.execPath,'--no-env-file','student-tests/wait.ts']);}catch{cleanupErrors.push('api_recovery');}
}
if(primary||cleanupErrors.length){await writeFile(resolve(evidence,'failure.json'),JSON.stringify({run_id:nonce,stage,primary:primary instanceof Error?primary.name:primary?'unknown':null,cleanup_errors:cleanupErrors})+'\n');throw new Error('Research failed; inspect this run failure summary');}
await writeFile(resolve(evidence,'summary.json'),JSON.stringify({run_id:nonce,complete:true,...results},null,2)+'\n',{flag:'wx'});
console.log('PASS lab2 research: '+evidence);