Files
MikrotikManager/backend/scripts/legacy-probe-handoff-inspect-owned.mjs
T

178 lines
16 KiB
JavaScript

import assert from 'node:assert/strict'
import {randomUUID,sign,X509Certificate} from 'node:crypto'
import {mkdir,open,readFile,realpath,unlink,writeFile} from 'node:fs/promises'
import {dirname,join,sep} from 'node:path'
export async function verifyOwnedHandoffInspector({live,directory,options,leafBytes,originalPin,archive,fullArchive,signedApproval,privateKey,intentOnly=false}){
assert.equal(process.env.MMAPP_OWN_PROBE_LEGACY_0037,'true')
const [{acquireDatabaseSchemaControl},{observation},{MIGRATION_MANIFEST,migrationManifestDigest},
{captureMigrationSchema},{ownedLegacyProbe0037Body},{sourceBindingBytes,sourceBindingCanonical,sourceBindingSha256,readDatabaseSourceBindingRegistry},
{LEGACY_PROBE_HANDOFF_DOMAIN},{createBootstrapMaterial},{LEGACY_PROBE_RELATIONS,LEGACY_PROBE_CUSTODY_RELATIONS},{DATABASE_RESTORE_QUARANTINE_DDL,beginDatabaseRestoreQuarantine}]=await Promise.all([
import('../src/db/database-schema-control.ts'),import('../src/db/controlled-migration-history.ts'),import('../src/db/migration-manifest.ts'),
import('../src/db/migration-schema-inventory.ts'),import('../src/db/proposals/server-probe-legacy-0037-owned.ts'),import('../src/db/database-source-binding.ts'),
import('../src/services/server-probe-legacy-handoff-inspection.ts'),import('./database-writer-bootstrap-operator.mjs'),
import('../src/services/server-probe-legacy-source-inventory.ts'),import('../src/db/database-restore-quarantine.ts'),
])
const store=async(path,data)=>{await writeFile(path,data,{flag:'wx',mode:0o600});return path}
const {body:migrationBody,pin}=await ownedLegacyProbe0037Body(),manifestSha256=migrationManifestDigest()
const truncate=`TRUNCATE TABLE ${LEGACY_PROBE_RELATIONS.map(name=>`ONLY public.${name}`).join(', ')} CONTINUE IDENTITY RESTRICT`
const base=await live.connect()
let before,after
const schema=async sql=>{
await sql.query("SET LOCAL search_path=pg_catalog; SET LOCAL TimeZone='UTC'; SET LOCAL DateStyle='ISO, YMD'")
return (await captureMigrationSchema(sql,{scope:{applicationNamespaces:['public'],excludedControlNamespaces:['mmapp_control']},deadlineAt:Date.now()+30000})).sha256
}
try {
await base.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY');before=await schema(base);await base.query('ROLLBACK')
await base.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE')
await base.query(truncate);await base.query(migrationBody);await base.query('SET TRANSACTION READ ONLY');after=await schema(base)
} finally { try { await base.query('ROLLBACK') } finally { base.release() } }
assert.notEqual(before,after)
await live.query(DATABASE_RESTORE_QUARANTINE_DDL)
const control=await acquireDatabaseSchemaControl(live)
try {
// The guarded fixture already installed exactly these 36 files on the owned DB.
for(const migration of MIGRATION_MANIFEST.slice(0,36)){
const id=randomUUID(), begun=await control.transition({type:'begin',id,kind:'migration',manifestSha256,artifactSha256:migration.sha256})
await control.transition({type:'terminal',id,outcome:'observed-success',observationSha256:await observation(begun.state.intent,migration)})
}
} finally { await control.close() }
const baseline=(await live.query('SELECT state FROM mmapp_control.database_schema_state WHERE id=1')).rows[0].state
const registry=await readDatabaseSourceBindingRegistry(originalPin),record=registry.body.source,host='localhost'
const tls={serverName:host,caSha256:sourceBindingSha256(leafBytes),spkiSha256:sourceBindingSha256(new X509Certificate(leafBytes).publicKey.export({type:'spki',format:'der'}))}
const names={publisher:options.user,runtime:'owned_handoff_runtime',operator:'owned_handoff_operator',control:'owned_handoff_control',capture:'owned_handoff_capture'}
await live.query(Object.values(names).filter(name=>name!==options.user).map(name=>`CREATE ROLE ${name} NOLOGIN`).join(';'))
const {rows:roles}=await live.query('SELECT rolname AS name,oid::text AS "signedOid" FROM pg_catalog.pg_roles WHERE rolname=ANY($1)',[Object.values(names)])
const request={format:'application-writer-bootstrap-request-v1',installationId:originalPin.installationId,sourceHeadSha256:originalPin.currentHeadSha256,tls,
roles:Object.fromEntries(Object.entries(names).map(([scope,name])=>[scope,roles.find(role=>role.name===name)])),
source:{systemIdentifier:record.systemIdentifier,databaseOid:String(record.databaseOid),databaseName:record.databaseName,serverVersionNum:record.serverVersionNum,inRecovery:false}}
const boot=sourceBindingBytes(createBootstrapMaterial(request,sourceBindingSha256(sourceBindingBytes(request))).bootstrap)
const transport=sourceBindingBytes({host,port:options.port,user:options.user,password:options.password,database:options.database})
const activationDirectory=join(directory,'owned-handoff-active');await mkdir(activationDirectory,{mode:0o700})
const activation=sourceBindingBytes({format:'database-source-activation-v1',activationDirectory,installationId:originalPin.installationId,
sourceIdentityId:registry.body.sourceIdentityId,status:'active',publicKeySpkiSha256:originalPin.publicKeySpkiSha256,
generations:[{generation:registry.body.generation,headSha256:registry.headSha256,bindingSha256:registry.head.bindingSha256,tlsSpkiSha256:tls.spkiSha256}]})
await store(join(activationDirectory,'source-activation.json'),activation)
const argv=['legacy-handoff-inspect','--bootstrap',await store(join(directory,'owned-handoff-bootstrap.json'),boot),'--bootstrap-sha256',sourceBindingSha256(boot),
'--transport',await store(join(directory,'owned-handoff-transport.json'),transport),'--transport-sha256',sourceBindingSha256(transport),
'--ca',await store(join(directory,'owned-handoff-ca.pem'),leafBytes),'--source-registry',originalPin.registryDirectory,'--source-spki-sha256',originalPin.publicKeySpkiSha256,
'--activation-directory',activationDirectory,'--activation-sha256',sourceBindingSha256(activation)]
let modeledFiles
if(process.platform==='win32'){
const {mock}=await import('node:test'),url=new URL('./writer-profile/operator-files.mjs',import.meta.url),files=await import(url.href)
const protectedDirectory=async path=>{assert(path===directory||path.startsWith(directory+sep));assert.equal(await realpath(path),path)}
modeledFiles=mock.module(url,{namedExports:{...files,protectedDirectory,async writeFile(path,blob,options){
await protectedDirectory(dirname(path));const file=await open(path,options.flag,options.mode)
try{await file.writeFile(blob);await file.sync()}finally{await file.close()}
},async readProtected(path,limit,hash){
await protectedDirectory(dirname(path));const bytes=await readFile(path);assert(bytes.length>0&&bytes.length<=limit);if(hash!==undefined)assert.equal(sourceBindingSha256(bytes),hash);return bytes
},async withJournalLease(path,work){
await protectedDirectory(path);const lock=join(path,'publisher-lease.lock'),file=await open(lock,'wx',0o600)
try{return await work()}finally{await file.close();await unlink(lock)}
}}})
}
try{
const {main}=await import('./database-writer-profile-operator.mts')
const {publishLegacyHandoffIntent}=await import('./writer-profile/publisher.mjs')
if(intentOnly){
const cases=['no-drain','control-refusal','acknowledged','lost-ack']
for(const testCase of cases){
const operationId=randomUUID(),archiveDirectory=join(directory,operationId);await mkdir(archiveDirectory,{mode:0o700})
for(const [name,blob] of [['legacy-probe.dump',archive],['legacy-probe-approval.json',signedApproval],['legacy-probe-cold.dump',fullArchive]])await store(join(archiveDirectory,name),blob)
const application=await live.connect()
if(testCase==='control-refusal')await live.query(`CREATE FUNCTION mmapp_control.owned_refuse_quarantine() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'owned control refusal'; END $$;
CREATE TRIGGER owned_refuse_quarantine BEFORE UPDATE ON mmapp_control.database_restore_quarantine FOR EACH ROW EXECUTE FUNCTION mmapp_control.owned_refuse_quarantine()`)
let control,commits=0
try{
if(testCase!=='no-drain')for(const key of [8723130,8723102,8723110])await application.query('SELECT pg_advisory_lock($1::bigint)',[key])
await application.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE')
if(testCase!=='no-drain')await application.query(`LOCK TABLE ${[...LEGACY_PROBE_CUSTODY_RELATIONS,'mcp_settings'].map(name=>`public.${name}`).join(', ')} IN ACCESS EXCLUSIVE MODE NOWAIT`)
const {rows:[{xid}]}=await application.query('SELECT pg_current_xact_id()::text AS xid')
const intent={format:'legacy-probe-0037-handoff-intent-v1',operationId,applicationXid:xid,approvalSha256:sourceBindingSha256(signedApproval),
coldArchiveSha256:sourceBindingSha256(fullArchive),preSchemaSha256:before,postSchemaSha256:after,manifestSha256,migrationSha256:pin.sha256}
const signedIntent=sourceBindingBytes({body:intent,signature:sign(null,Buffer.from(LEGACY_PROBE_HANDOFF_DOMAIN+sourceBindingCanonical(intent)),privateKey).toString('base64url')})
control=await acquireDatabaseSchemaControl({async connect(){
const client=await live.connect()
return {release:bad=>client.release(bad),async query(text,values){
const result=await client.query(text,values)
if(text==='COMMIT'&&++commits===2&&testCase==='lost-ack')throw Error('owned control COMMIT ACK lost')
return result
}}
}})
const publish=()=>publishLegacyHandoffIntent({application,control,sourcePin:originalPin,tlsPin:tls,archiveDirectory,signedIntent,deadlineAt:Date.now()+30000})
const intentFile=join(archiveDirectory,'legacy-probe-handoff-intent.json'), unknownFile=join(archiveDirectory,'legacy-probe-handoff-control-unknown.json')
if(testCase==='acknowledged'){
const receipt=await publish();assert.equal(receipt.intentRecorded,true);assert.equal(receipt.readyAuthorized,false)
}else if(testCase==='no-drain'){
await assert.rejects(publish(),/exclusive drain no longer held/)
await assert.rejects(readFile(intentFile),{code:'ENOENT'})
}else await assert.rejects(publish(),{outcomeUnknown:testCase==='lost-ack'})
if(testCase!=='no-drain')assert.equal(sourceBindingSha256(await readFile(intentFile)),sourceBindingSha256(signedIntent))
if(testCase==='lost-ack'){
const observation=JSON.parse(await readFile(unknownFile,'utf8'))
assert.equal(observation.operationId,operationId);assert.equal(observation.automaticReplay,false)
await assert.rejects(publish(),{code:'EEXIST'})
assert.equal(commits,2)
}else await assert.rejects(readFile(unknownFile),{code:'ENOENT'})
const recorded=testCase==='acknowledged'||testCase==='lost-ack'
const {rows:[facts]}=await live.query(`SELECT q.operation_id,s.state->'intent'->>'id' AS pending,
(SELECT count(*)::int FROM mmapp_control.database_schema_intents) AS history
FROM mmapp_control.database_restore_quarantine q CROSS JOIN mmapp_control.database_schema_state s WHERE q.id=1 AND s.id=1`)
assert.deepEqual(facts,{operation_id:recorded?operationId:null,pending:recorded?operationId:null,history:recorded?37:36})
await application.query('ROLLBACK')
await application.query('SELECT pg_advisory_unlock_all()')
if(recorded){
const result=await main([...argv,'--archive-directory',archiveDirectory,'--handoff-intent-sha256',sourceBindingSha256(signedIntent)])
assert.equal(result.outcome,'rolled-back');assert.equal(result.operationId,operationId);assert.equal(result.quarantineActive,true)
}
if(recorded&&testCase!=='lost-ack'){
await live.query('DELETE FROM mmapp_control.database_schema_intents WHERE id=$1',[operationId])
await live.query('UPDATE mmapp_control.database_schema_state SET state=$1::jsonb WHERE id=1',[JSON.stringify(baseline)])
await live.query('UPDATE mmapp_control.database_restore_quarantine SET operation_id=NULL WHERE id=1')
}
}finally{
try{await control?.close()}finally{application.release(true)}
if(testCase==='control-refusal')await live.query('DROP TRIGGER owned_refuse_quarantine ON mmapp_control.database_restore_quarantine; DROP FUNCTION mmapp_control.owned_refuse_quarantine()')
}
}
return {legacyHandoffIntentPublished:true,controlRefusalAtomic:true,controlAckLossRecordedUnknown:true,applicationCommit:false,readyAuthorized:false}
}
for(const commits of [false,true]){
const operationId=randomUUID(),archiveDirectory=join(directory,operationId);await mkdir(archiveDirectory,{mode:0o700})
for(const [name,blob] of [['legacy-probe.dump',archive],['legacy-probe-approval.json',signedApproval],['legacy-probe-cold.dump',fullArchive]])await store(join(archiveDirectory,name),blob)
const application=await live.connect()
try{
await application.query('BEGIN');const {rows:[{xid}]}=await application.query('SELECT pg_current_xact_id()::text AS xid')
const body={format:'legacy-probe-0037-handoff-intent-v1',operationId,applicationXid:xid,approvalSha256:sourceBindingSha256(signedApproval),
coldArchiveSha256:sourceBindingSha256(fullArchive),preSchemaSha256:before,postSchemaSha256:after,manifestSha256,migrationSha256:pin.sha256}
const intent=sourceBindingBytes({body,signature:sign(null,Buffer.from(LEGACY_PROBE_HANDOFF_DOMAIN+sourceBindingCanonical(body)),privateKey).toString('base64url')})
const file=await open(join(archiveDirectory,'legacy-probe-handoff-intent.json'),'wx',0o600)
try { await file.writeFile(intent);await file.sync() } finally { await file.close() }
const input=[...argv,'--archive-directory',archiveDirectory,'--handoff-intent-sha256',sourceBindingSha256(intent)]
const controller=await acquireDatabaseSchemaControl(live)
try{await controller.transition({type:'begin',id:operationId,kind:'migration',manifestSha256,artifactSha256:sourceBindingSha256(intent)})}finally{await controller.close()}
await beginDatabaseRestoreQuarantine(live,operationId)
const inspect=async expected=>{
const result=await main(input)
assert.deepEqual({outcome:result.outcome,operationId:result.operationId,quarantine:result.quarantineActive,ready:result.readyAuthorized},
{outcome:expected,operationId,quarantine:true,ready:false})
const {rows:[gates]}=await live.query(`SELECT q.operation_id,s.state->'intent'->>'id' AS pending
FROM mmapp_control.database_restore_quarantine q CROSS JOIN mmapp_control.database_schema_state s WHERE q.id=1 AND s.id=1`)
assert.deepEqual(gates,{operation_id:operationId,pending:operationId})
}
await inspect('unknown')
if(commits){await application.query(truncate);await application.query(migrationBody)}
await application.query(commits?'COMMIT':'ROLLBACK')
await inspect(commits?'committed':'rolled-back')
if(!commits){
// Own harness resets its control-only fixture for the independent COMMIT case.
await live.query('DELETE FROM mmapp_control.database_schema_intents WHERE id=$1',[operationId])
await live.query('UPDATE mmapp_control.database_schema_state SET state=$1::jsonb WHERE id=1',[JSON.stringify(baseline)])
await live.query('UPDATE mmapp_control.database_restore_quarantine SET operation_id=NULL WHERE id=1')
}
}finally{try{await application.query('ROLLBACK')}finally{application.release()}}
}
} finally { modeledFiles?.restore() }
return {legacyHandoffInspection:true,unknownObserved:true,rollbackObserved:true,commitObserved:true,quarantineCleared:false,readyAuthorized:false}
}