282 lines
26 KiB
TypeScript
282 lines
26 KiB
TypeScript
import { MIGRATION_MANIFEST } from "../db/migration-manifest.js"
|
|
import type { BandwidthExternalNodeRegistryReceipt } from "./bandwidth-external-node-registry.js"
|
|
import type { BandwidthResolvedPeerFence } from "./bandwidth-peer-fence.js"
|
|
import assert from "node:assert/strict"
|
|
import { randomUUID } from "node:crypto"
|
|
import { createOwnedExternalRegistryHarness } from "./bandwidth-external-node-registry.sql-helper.js"
|
|
import { assertOwnedBandwidthSql, createOwnedBandwidthHarness, fixtureBinding } from "./bandwidth-admission-process.sql-helper.js"
|
|
|
|
assertOwnedBandwidthSql();assert.equal(process.env.MMAPP_OWN_BANDWIDTH_EXTERNAL_REGISTRY,"true")
|
|
const f=await createOwnedExternalRegistryHarness(),cases:string[]=[]
|
|
const {BandwidthExternalNodeRegistryUnknown,createBandwidthExternalNodeRegistry}=await import("./bandwidth-external-node-registry.js")
|
|
const {createBandwidthNodeRegistry}=await import("./bandwidth-node-registry.js")
|
|
const {observeBandwidthExternalNodeRegistryCatalog}=await import("./bandwidth-external-node-registry-catalog.js")
|
|
const {observeBandwidthNodeRegistryCatalog,observeBandwidthPeerRegistryCatalog}=await import("./bandwidth-node-registry-catalog.js")
|
|
const {assertBandwidthExternalNodeRegistryRuntimeRole}=await import("./bandwidth-external-node-registry-role.js")
|
|
const {assertBandwidthNodeRegistryRuntimeRole}=await import("./bandwidth-node-registry-role.js")
|
|
const coreTables=["bandwidth_attempts","bandwidth_node_occupancy","bandwidth_attempt_events"]
|
|
const extensionTables=["bandwidth_external_node_aliases","bandwidth_external_node_events"]
|
|
const allTables=[...coreTables,"bandwidth_source_identity","bandwidth_node_authority","bandwidth_nodes","bandwidth_node_aliases","bandwidth_node_events",...extensionTables]
|
|
const roleExpected={databaseName:f.databaseName,runtimeRole:f.externalRole,ownerRole:f.ownerRole}
|
|
const live=()=>{}
|
|
const host=f.externalHost().host
|
|
let acceptExecution!:()=>Promise<{checks:string[];posts:number;productionContextProvider:boolean;productionMappingAttestor:boolean}>
|
|
let acceptOperator!:()=>Promise<string[]>
|
|
let acceptWriter!:()=>Promise<string[]>
|
|
let acceptPeers!:(id:string,receipt:BandwidthExternalNodeRegistryReceipt,reject:boolean,changePin?:boolean)=>Promise<void>
|
|
try{
|
|
await assertBandwidthExternalNodeRegistryRuntimeRole(f.external,roleExpected,live)
|
|
await assertBandwidthNodeRegistryRuntimeRole(f.managed,{...roleExpected,runtimeRole:f.managedRole},live)
|
|
for(const runtime of [f.managed,f.external]){
|
|
await assert.rejects(runtime.query("UPDATE mmapp_control.bandwidth_nodes SET claim_proof=claim_proof"))
|
|
await assert.rejects(runtime.query("SELECT * FROM mmapp_control.bandwidth_node_occupancy"))
|
|
await assert.rejects(runtime.query("DELETE FROM mmapp_control.bandwidth_nodes"))
|
|
}
|
|
await assert.rejects(f.external.query("SELECT * FROM mmapp_control.bandwidth_node_aliases"))
|
|
await assert.rejects(f.managed.query("SELECT * FROM mmapp_control.bandwidth_external_node_aliases"))
|
|
cases.push("explicit non-superuser owner plus separate managed/external LOGIN roles: exact table ACLs, no core occupancy or foreign alias access")
|
|
const claims={"system-id":"OWNED-SHARED-SYSTEM","software-id":"OWNED-SHARED-SOFTWARE"}
|
|
const managedId=await f.managedEndpoint(claims),externalId=f.externalEndpoint(claims)
|
|
const managedObservation=await f.managedObservation(managedId),externalObservation=await f.externalObservation(externalId)
|
|
const [managed,external]=await Promise.all([f.managedHost.register(managedObservation,f.scope()),host.register(externalObservation,f.scope())])
|
|
assert.equal(managed.canonicalNodeId,external.canonicalNodeId);assert.notEqual(managed.incarnation,external.incarnation)
|
|
assert.equal(Number((await f.owner.query("SELECT count(*) AS n FROM mmapp_control.bandwidth_nodes")).rows[0].n),1)
|
|
assert.equal((await host.resolve(await f.externalObservation(externalId),f.scope())).canonicalNodeId,managed.canonicalNodeId)
|
|
assert.equal((await host.register(await f.externalObservation(externalId),f.scope())).outcome,"existing")
|
|
cases.push("genuine localhost v1/v2 license GETs; independent PG sessions concurrently share original typed claim/node MAC issuer and advisory lock, yielding exactly one canonical node")
|
|
{
|
|
const missing=f.externalEndpoint({"system-id":"OWNED-MISSING"}),before=await f.digest(allTables)
|
|
await assert.rejects(host.resolve(await f.externalObservation(missing),f.scope()))
|
|
await assert.rejects(host.register(JSON.parse(JSON.stringify(await f.externalObservation(missing))),f.scope()))
|
|
assert.equal(await f.digest(allTables),before)
|
|
const distinct=f.externalEndpoint({"software-id":"OWNED-SHARED-SYSTEM"})
|
|
assert.notEqual((await host.register(await f.externalObservation(distinct),f.scope())).canonicalNodeId,managed.canonicalNodeId)
|
|
cases.push("resolve absent and serialized private observation never auto-enroll; typed software-only identity does not collapse with system/full vector")
|
|
}
|
|
{
|
|
const signed=await f.createSignedSource()
|
|
acceptExecution=async()=>{const {acceptBandwidthPeerExecutionHost}=await import("./bandwidth-peer-execution-host.sql-helper.js");return acceptBandwidthPeerExecutionHost(f,signed)}
|
|
acceptOperator=async()=>{const {acceptOwnedOperatorRegistry}=await import("./bandwidth-operator-registry.sql-helper.js");return acceptOwnedOperatorRegistry(f,signed)}
|
|
acceptWriter=async()=>{const {acceptOwnedOperatorWriterComposition}=await import("./bandwidth-operator-writer-composition.sql-helper.js");return acceptOwnedOperatorWriterComposition(f,signed)}
|
|
await assert.rejects(signed.v1.open(f.scope()))
|
|
await assert.rejects(signed.badPin.open(f.scope()))
|
|
const originalExpiresAt=Date.now()+60000
|
|
const signedAuthority=async()=>({...f.root,authorityProof:f.mac("signed-original-operator",claims),authorityGeneration:"owned-original-signed-operation",expiresAt:originalExpiresAt})
|
|
const signedExternalId=f.externalEndpoint(claims),externalToken=await f.externalObservation(signedExternalId)
|
|
const beforeExternal=await signed.externalInspect(externalToken,f.scope())
|
|
const externalWindow={deadlineAt:Math.min(Date.now()+10000,beforeExternal.expiresAt,originalExpiresAt)}
|
|
const externalGuard=async()=>{const current=await signed.externalInspect(externalToken,externalWindow);assert.deepEqual(current,beforeExternal);assert(Date.now()<originalExpiresAt)}
|
|
const extSession=await signed.node.open(externalWindow,externalGuard)
|
|
let signedExternal
|
|
try{
|
|
const signedHost=createBandwidthExternalNodeRegistry({now:Date.now,connect:async()=>extSession.connection,inspect:signed.externalInspect,authorize:signedAuthority,keyedProof:extSession.keyedProof,keyedProofs:extSession.keyedProofs})
|
|
signedExternal=await signedHost.register(externalToken,externalWindow)
|
|
}finally{extSession.close()}
|
|
assert.equal(signedExternal.canonicalNodeId,managed.canonicalNodeId)
|
|
const secondManagedId=await f.managedEndpoint(claims),managedToken=await f.managedObservation(secondManagedId)
|
|
const beforeManaged=await signed.managedInspect(managedToken,f.scope()),managedWindow={deadlineAt:Math.min(Date.now()+10000,beforeManaged.expiresAt,originalExpiresAt)}
|
|
const managedGuard=async()=>{assert.deepEqual(await signed.managedInspect(managedToken,managedWindow),beforeManaged);assert(Date.now()<originalExpiresAt)}
|
|
const managedSession=await signed.node.open(managedWindow,managedGuard)
|
|
let signedManaged
|
|
try{
|
|
const signedHost=createBandwidthNodeRegistry({now:Date.now,connect:async()=>managedSession.connection,inspect:signed.managedInspect,authorize:signedAuthority,keyedProof:managedSession.keyedProof,keyedProofs:managedSession.keyedProofs})
|
|
signedManaged=await signedHost.register(managedToken,managedWindow)
|
|
}finally{managedSession.close()}
|
|
assert.equal(signedManaged.canonicalNodeId,managed.canonicalNodeId)
|
|
const window=f.scope(4500),session=await signed.node.open(window)
|
|
let binding
|
|
try{
|
|
binding=await session.binding();assert.equal(binding.controlGeneration,signed.controlGeneration)
|
|
const aliasMaterial={...f.root,enrollmentId:signedExternal.enrollmentId,incarnation:signedExternal.incarnation,nodeId:signedExternal.canonicalNodeId,status:"active"}
|
|
assert.equal(await session.keyedProof("external-alias",aliasMaterial),f.mac("external-alias",aliasMaterial))
|
|
await assert.rejects(session.keyedProof("external-alias",{...f.root,serverId:managedId,incarnation:managed.incarnation,nodeId:managed.canonicalNodeId,status:"active"}))
|
|
}finally{session.close()}
|
|
const firstEvidence=await signed.managedInspect(await f.managedObservation(managedId),f.scope())
|
|
const secondEvidence=await signed.managedInspect(await f.managedObservation(secondManagedId),f.scope())
|
|
const fenceWindow=f.scope(4000),expected={binding,participants:[{evidence:firstEvidence,receipt:managed},{evidence:secondEvidence,receipt:signedManaged}]}
|
|
const before=await f.digest(allTables)
|
|
const lease=await signed.core.connect(fenceWindow,async fence=>signed.node.assertResolvedOnFence(fence,expected,fenceWindow))
|
|
try{await lease.query("BEGIN");await lease.query("SELECT 1 AS owned_signed_v2_fence_marker");await lease.query("COMMIT")}finally{lease.release(true)}
|
|
assert.equal(await f.digest(allTables),before)
|
|
const badWindow=f.scope(4000),altered={...expected,binding:{...binding,sourceRecordSha256:"a".repeat(64)}}
|
|
const rejected=await signed.core.connect(badWindow,async fence=>signed.node.assertResolvedOnFence(fence,altered,badWindow))
|
|
try{await assert.rejects(rejected.query("SELECT 1 AS forbidden_signed_v2_pin_marker"))}finally{rejected.release(true)}
|
|
assert.equal(await f.digest(allTables),before)
|
|
acceptPeers=async(destinationId,destinationReceipt,reject,changePin=false)=>{
|
|
const currentSource=await signed.peerInspect(await signed.peerObservation({kind:"server",serverId:secondManagedId}),f.scope())
|
|
const currentDestination=await signed.peerInspect(await signed.peerObservation({kind:"external",enrollmentId:destinationId}),f.scope())
|
|
const {serverId:sourceId,...sourceReceipt}=signedManaged
|
|
const {enrollmentId,...externalReceipt}=destinationReceipt
|
|
const peerExpected:BandwidthResolvedPeerFence={binding:changePin?{...binding,sourceRecordSha256:"f".repeat(64)}:binding,participants:[
|
|
{evidence:currentSource,receipt:{...sourceReceipt,peerRef:{kind:"server",serverId:sourceId}}},
|
|
{evidence:currentDestination,receipt:{...externalReceipt,peerRef:{kind:"external",enrollmentId}}},
|
|
]}
|
|
const {Client}=await import("pg"),originalQuery=Client.prototype.query,pids=new Set<number>()
|
|
let actualMarkers=0,actualWrites=0
|
|
Client.prototype.query=function(this:InstanceType<typeof Client>,...args:unknown[]){
|
|
const connection=this as unknown as {connectionParameters:{user:string;database:string};processID:number}
|
|
if(connection.connectionParameters.user===signed.runtimeRole&&connection.connectionParameters.database===f.databaseName){
|
|
const sql=typeof args[0]==="string"?args[0]:(args[0] as {text?:string})?.text??""
|
|
if(sql.includes("owned_external_peer_final_marker"))actualMarkers++
|
|
if(/^(?:DO|INSERT|UPDATE|DELETE|TRUNCATE|ALTER|CREATE|DROP)\b/i.test(sql.trim()))actualWrites++
|
|
if(connection.processID)pids.add(connection.processID)
|
|
}
|
|
return Reflect.apply(originalQuery,this,args)
|
|
} as typeof Client.prototype.query
|
|
const snapshot=await f.digest(allTables),peerWindow=f.scope(4000)
|
|
try{
|
|
const peerLease=await signed.core.connect(peerWindow,async fence=>signed.node.assertResolvedPeersOnFence(fence,peerExpected,peerWindow))
|
|
try{
|
|
if(reject)await assert.rejects(peerLease.query("SELECT pg_catalog.pg_backend_pid() AS pid /* owned_external_peer_final_marker */"))
|
|
else{await peerLease.query("BEGIN");await peerLease.query("SELECT pg_catalog.pg_backend_pid() AS pid /* owned_external_peer_final_marker */");await peerLease.query("COMMIT")}
|
|
}finally{peerLease.release(true)}
|
|
}finally{Client.prototype.query=originalQuery}
|
|
assert.equal(actualMarkers,reject?0:1);assert.equal(actualWrites,0);assert.equal(pids.size,1)
|
|
assert.equal(await f.digest(allTables),snapshot)
|
|
}
|
|
cases.push("genuine Ed25519 signed core record and bootstrap v2 + owner-only key files authenticate configured source.open/keyedProof; actual managed/external registry transactions reuse existing canonical node with operational HMAC domains; signed v1 footprint and forged v2 pin refuse")
|
|
cases.push("actual configured v2 same-lease alias fence verifies two managed participants through BEGIN/SELECT/COMMIT, rejects changed original source pin without data mutation")
|
|
}
|
|
const otherId=f.externalEndpoint({"system-id":"OWNED-OTHER"}),other=await host.register(await f.externalObservation(otherId),f.scope())
|
|
const core=await createOwnedBandwidthHarness(f.admin),binding=fixtureBinding(managed.canonicalNodeId,other.canonicalNodeId)
|
|
core.register(binding);await core.journal.reserve(binding,f.scope());await core.journal.arm(binding,f.scope());await core.journal.quarantine(binding,f.scope())
|
|
const coreBefore=await f.digest(coreTables)
|
|
assert.equal((await host.retire(externalId,"tombstone",f.scope())).status,"tombstoned")
|
|
assert.equal((await host.retire(externalId,"tombstone",f.scope())).outcome,"existing")
|
|
await assert.rejects(host.register(await f.externalObservation(externalId),f.scope()))
|
|
await assert.rejects(host.resolve(await f.externalObservation(externalId),f.scope()))
|
|
await assert.rejects(host.retire(externalId,"quarantine",f.scope()))
|
|
const replacementId=f.externalEndpoint(claims),replacement=await host.register(await f.externalObservation(replacementId),f.scope())
|
|
assert.equal(replacement.canonicalNodeId,managed.canonicalNodeId);assert.notEqual(replacement.incarnation,external.incarnation)
|
|
await f.managedHost.retire(managedId,"quarantine",f.scope())
|
|
assert.equal(await f.digest(coreTables),coreBefore)
|
|
const overlap=fixtureBinding(replacement.canonicalNodeId,randomUUID());core.register(overlap);await assert.rejects(core.journal.reserve(overlap,f.scope()))
|
|
assert.equal(await f.digest(coreTables),coreBefore)
|
|
cases.push("actual reserve/arm/unknown core occupancy survives managed quarantine, external terminal retirement/replacement alias byte-for-byte; overlapping attempt remains refused")
|
|
{
|
|
// The source is the active signed managed alias; the external destination has
|
|
// a distinct canonical node. Identity checks alone do not clear occupancy.
|
|
await acceptPeers(otherId,other,false)
|
|
await acceptPeers(otherId,other,true,true)
|
|
// The mixed wire tuple cannot use aliases of the same canonical node.
|
|
await acceptPeers(replacementId,replacement,true)
|
|
const otherAliasId=f.externalEndpoint({"system-id":"OWNED-OTHER"}),otherAlias=await host.register(await f.externalObservation(otherAliasId),f.scope())
|
|
assert.equal(otherAlias.canonicalNodeId,other.canonicalNodeId)
|
|
await acceptPeers(otherAliasId,otherAlias,false)
|
|
const aliasOverlap=fixtureBinding(managed.canonicalNodeId,otherAlias.canonicalNodeId);core.register(aliasOverlap)
|
|
await assert.rejects(core.journal.reserve(aliasOverlap,f.scope()));assert.equal(await f.digest(coreTables),coreBefore)
|
|
await host.retire(otherAliasId,"tombstone",f.scope());await acceptPeers(otherAliasId,otherAlias,true)
|
|
for(const kind of ["external-alias","external-event"] as const){
|
|
const id=f.externalEndpoint({"system-id":"OWNED-OTHER"}),incarnation=randomUUID(),eventId=randomUUID(),authorityProof=f.mac("tampered-fixture-original",id)
|
|
const aliasMaterial={...f.root,enrollmentId:id,incarnation,nodeId:other.canonicalNodeId,status:"active"}
|
|
const eventMaterial={...f.root,eventId,enrollmentId:id,incarnation,nodeId:other.canonicalNodeId,kind:"enroll",oldStatus:null,newStatus:"active",authorityProof}
|
|
const connection=await f.owner.connect()
|
|
try{
|
|
await connection.query("BEGIN")
|
|
await connection.query("INSERT INTO mmapp_control.bandwidth_external_node_aliases(enrollment_id,incarnation,node_id,status,record_mac) VALUES($1,$2,$3,'active',$4)",[id,incarnation,other.canonicalNodeId,kind==="external-alias"?"f".repeat(64):f.mac("external-alias",aliasMaterial)])
|
|
await connection.query("INSERT INTO mmapp_control.bandwidth_external_node_events(event_id,enrollment_id,incarnation,node_id,kind,old_status,new_status,authority_proof,event_mac) VALUES($1,$2,$3,$4,'enroll',NULL,'active',$5,$6)",[eventId,id,incarnation,other.canonicalNodeId,authorityProof,kind==="external-event"?"f".repeat(64):f.mac("external-event",eventMaterial)])
|
|
await connection.query("COMMIT")
|
|
}finally{await connection.query("ROLLBACK").catch(()=>{});connection.release()}
|
|
const forged:BandwidthExternalNodeRegistryReceipt={enrollmentId:id,canonicalNodeId:other.canonicalNodeId,incarnation,status:"active",outcome:"new"}
|
|
await acceptPeers(id,forged,true)
|
|
}
|
|
assert.equal(await f.digest(coreTables),coreBefore)
|
|
cases.push("actual signed v2 mixed managed-source/external-destination fence uses genuine v2 observations on one physical PG lease: final marker only for valid distinct canonical participants, zero native DML")
|
|
cases.push("before real final peer marker: changed signed source pin, same-canonical aliases, terminal external alias and separately forged alias/event MACs refuse with zero marker sends and unchanged rows; valid replacement external alias shares occupied canonical node and cannot bypass actual unknown journal occupancy")
|
|
}
|
|
|
|
{
|
|
const before=await f.digest(allTables),connection=await f.admin.connect()
|
|
try{
|
|
await connection.query("BEGIN");await connection.query("SET LOCAL session_replication_role=replica")
|
|
await assert.rejects(connection.query("INSERT INTO mmapp_control.bandwidth_external_node_aliases(enrollment_id,incarnation,node_id,status,record_mac) VALUES($1,$2,$3,'active',$4)",[randomUUID(),randomUUID(),randomUUID(),"a".repeat(64)]))
|
|
await connection.query("ROLLBACK")
|
|
await connection.query("BEGIN");await connection.query("SET LOCAL session_replication_role=replica")
|
|
await assert.rejects(connection.query("INSERT INTO mmapp_control.bandwidth_external_node_events(event_id,enrollment_id,incarnation,node_id,kind,old_status,new_status,authority_proof,event_mac) VALUES($1,$2,$3,$4,'enroll',NULL,'active',$5,$6)",[randomUUID(),randomUUID(),randomUUID(),replacement.canonicalNodeId,"a".repeat(64),"b".repeat(64)]))
|
|
await connection.query("ROLLBACK")
|
|
}finally{await connection.query("ROLLBACK").catch(()=>{});connection.release()}
|
|
for(const table of extensionTables)await assert.rejects(f.owner.query(`TRUNCATE mmapp_control.${table} CASCADE`),error=>(error as {code?:string}).code==="23514")
|
|
await assert.rejects(f.owner.query("UPDATE mmapp_control.bandwidth_external_node_aliases SET node_id=$1 WHERE enrollment_id=$2",[other.canonicalNodeId,replacementId]))
|
|
await assert.rejects(f.owner.query("UPDATE mmapp_control.bandwidth_external_node_aliases SET status='active' WHERE enrollment_id=$1",[externalId]))
|
|
await assert.rejects(f.owner.query("DELETE FROM mmapp_control.bandwidth_external_node_events WHERE enrollment_id=$1",[replacementId]))
|
|
const missingEvent=await f.owner.connect()
|
|
try{
|
|
await missingEvent.query("BEGIN")
|
|
await missingEvent.query("INSERT INTO mmapp_control.bandwidth_external_node_aliases(enrollment_id,incarnation,node_id,status,record_mac) VALUES($1,$2,$3,'active',$4)",[randomUUID(),randomUUID(),replacement.canonicalNodeId,"a".repeat(64)])
|
|
await assert.rejects(missingEvent.query("COMMIT"),error=>(error as {code?:string}).code==="23514")
|
|
}finally{await missingEvent.query("ROLLBACK").catch(()=>{});missingEvent.release()}
|
|
assert.equal(await f.digest(allTables),before)
|
|
cases.push("ALWAYS reference guards reject absent node/alias under real replica mode; owner TRUNCATE, alias rebinding/reactivation and event deletion refuse without durable mutation")
|
|
}
|
|
{
|
|
const digest=await observeBandwidthExternalNodeRegistryCatalog(f.external,live);assert.match(digest,/^[a-f0-9]{64}$/)
|
|
const combined=await observeBandwidthPeerRegistryCatalog(f.external,live);assert.match(combined,/^[a-f0-9]{64}$/)
|
|
assert.equal(await observeBandwidthPeerRegistryCatalog(f.external,live),combined)
|
|
const incoming=(await f.admin.query(`SELECT t.tgname::text AS name FROM pg_catalog.pg_trigger t
|
|
JOIN pg_catalog.pg_constraint k ON k.oid=t.tgconstraint
|
|
JOIN pg_catalog.pg_class c ON c.oid=k.conrelid JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace
|
|
JOIN pg_catalog.pg_proc p ON p.oid=t.tgfoid
|
|
WHERE t.tgrelid='mmapp_control.bandwidth_nodes'::regclass AND n.nspname='mmapp_control'
|
|
AND c.relname='bandwidth_external_node_aliases' AND p.proname='RI_FKey_restrict_del'`)).rows
|
|
assert.equal(incoming.length,1);assert.match(incoming[0].name,/^[A-Za-z0-9_]+$/)
|
|
const tamper=await f.admin.connect()
|
|
try{
|
|
await tamper.query("BEGIN")
|
|
await tamper.query(`ALTER TABLE mmapp_control.bandwidth_nodes DISABLE TRIGGER "${incoming[0].name}"`)
|
|
await assert.rejects(observeBandwidthPeerRegistryCatalog(tamper,live));await tamper.query("ROLLBACK")
|
|
await tamper.query("BEGIN")
|
|
await tamper.query("CREATE OR REPLACE FUNCTION mmapp_control.bandwidth_node_immutable_guard() RETURNS trigger LANGUAGE plpgsql SET search_path=pg_catalog,mmapp_control AS $body$ BEGIN RETURN NEW; END; $body$;")
|
|
await assert.rejects(observeBandwidthPeerRegistryCatalog(tamper,live));await tamper.query("ROLLBACK")
|
|
await tamper.query("BEGIN")
|
|
await tamper.query("ALTER TABLE mmapp_control.bandwidth_external_node_aliases ALTER COLUMN status SET DEFAULT 'active'")
|
|
await assert.rejects(observeBandwidthPeerRegistryCatalog(tamper,live));await tamper.query("ROLLBACK")
|
|
}finally{await tamper.query("ROLLBACK").catch(()=>{});tamper.release()}
|
|
assert.equal(await observeBandwidthPeerRegistryCatalog(f.external,live),combined)
|
|
// The old footprint cannot bless incoming extension FK triggers. No v1 source
|
|
// or pin is weakened merely to make the extension appear production-ready.
|
|
await assert.rejects(observeBandwidthNodeRegistryCatalog(f.managed,live))
|
|
await f.owner.query("ALTER TABLE mmapp_control.bandwidth_external_node_aliases DISABLE TRIGGER bandwidth_external_node_alias_guard")
|
|
try{await assert.rejects(observeBandwidthExternalNodeRegistryCatalog(f.external,live))}finally{await f.owner.query("ALTER TABLE mmapp_control.bandwidth_external_node_aliases ENABLE ALWAYS TRIGGER bandwidth_external_node_alias_guard")}
|
|
assert.equal(await observeBandwidthExternalNodeRegistryCatalog(f.external,live),digest)
|
|
await f.owner.query(`GRANT DELETE ON mmapp_control.bandwidth_external_node_aliases TO "${f.externalRole}"`)
|
|
try{await assert.rejects(assertBandwidthExternalNodeRegistryRuntimeRole(f.external,roleExpected,live))}finally{await f.owner.query(`REVOKE DELETE ON mmapp_control.bandwidth_external_node_aliases FROM "${f.externalRole}"`)}
|
|
await assertBandwidthExternalNodeRegistryRuntimeRole(f.external,roleExpected,live)
|
|
cases.push("real PG extension and combined catalogs pass stable full digests; incoming FK disable, managed immutable-body replacement, extension column default, external guard disable and overprivileged role fail and restore exact pins; v1 catalog intentionally refuses extension; signed production pin remains open")
|
|
}
|
|
let actualCommitLosses=0,rowsOnlyCommitAcks=0
|
|
for(const mode of ["lost","rows"] as const){
|
|
const id=f.externalEndpoint({"system-id":"OWNED-COMMIT-"+mode}),fault=f.externalHost(mode),token=await f.externalObservation(id)
|
|
await assert.rejects(fault.host.register(token,f.scope()),error=>error instanceof BandwidthExternalNodeRegistryUnknown&&error.automaticReplay===false)
|
|
assert.equal(fault.commits(),1);assert.equal(fault.rollbacks(),0)
|
|
const row=(await f.owner.query("SELECT node_id::text FROM mmapp_control.bandwidth_external_node_aliases WHERE enrollment_id=$1",[id])).rows[0];assert(row)
|
|
assert.equal((await host.resolve(await f.externalObservation(id),f.scope())).canonicalNodeId,row.node_id)
|
|
assert.equal(Number((await f.owner.query("SELECT count(*) AS n FROM mmapp_control.bandwidth_external_node_events WHERE enrollment_id=$1",[id])).rows[0].n),1)
|
|
const retire=f.externalHost(mode)
|
|
await assert.rejects(retire.host.retire(id,"quarantine",f.scope()),error=>error instanceof BandwidthExternalNodeRegistryUnknown&&error.automaticReplay===false)
|
|
assert.equal(retire.commits(),1);assert.equal(retire.rollbacks(),0)
|
|
assert.equal((await host.retire(id,"quarantine",f.scope())).outcome,"existing")
|
|
assert.equal(Number((await f.owner.query("SELECT count(*) AS n FROM mmapp_control.bandwidth_external_node_events WHERE enrollment_id=$1",[id])).rows[0].n),2)
|
|
if(mode==="lost")actualCommitLosses+=2;else rowsOnlyCommitAcks+=2
|
|
}
|
|
cases.push("real COMMIT persists enrollment and retirement before lost ACK/rows-only wrappers: Unknown/no automatic replay, one physical COMMIT, no rollback, durable event counts remain one/two during fresh reconciliation")
|
|
{
|
|
const id=f.externalEndpoint({"system-id":"OWNED-REVOKED"}),token=await f.externalObservation(id),before=await f.digest(allTables)
|
|
let eventInserted=false
|
|
const revoked=f.externalHost(undefined,async sql=>{
|
|
if(sql.startsWith("DO $mmapp_bandwidth_register$")||sql.startsWith("INSERT INTO mmapp_control.bandwidth_external_node_events"))eventInserted=true
|
|
else if(eventInserted&&sql.includes("SELECT installation_id::pg_catalog.text"))f.revoke()
|
|
})
|
|
await assert.rejects(revoked.host.register(token,f.scope()));assert(eventInserted);assert.equal(revoked.commits(),0);assert.equal(revoked.rollbacks(),1)
|
|
await assert.rejects(host.register(await f.externalObservation(id),f.scope()));assert.equal(await f.digest(allTables),before)
|
|
cases.push("original operator grant revoked after actual event INSERT and before final authority SELECT: real transaction rolls back, COMMIT is not sent; fresh genuine observation remains denied")
|
|
}
|
|
assert.equal(await f.digest(coreTables),coreBefore)
|
|
await f.profileMetadata()
|
|
const execution=await acceptExecution();cases.push(...execution.checks)
|
|
cases.push(...await acceptOperator())
|
|
cases.push(...await acceptWriter())
|
|
assert.equal((await f.owner.query("SELECT state FROM mmapp_control.bandwidth_attempts WHERE attempt_id=$1",[binding.attemptId])).rows[0]?.state,"unknown_busy")
|
|
assert.equal(Number((await f.owner.query("SELECT count(*) AS n FROM mmapp_control.bandwidth_node_occupancy WHERE attempt_id=$1",[binding.attemptId])).rows[0].n),2)
|
|
console.log("Owned external bandwidth registry:",JSON.stringify({cases:cases.length,checks:cases,actualLocalhostLicenseGets:f.nativeGets(),actualLocalhostBtestPosts:f.nativePosts(),actualCommitLosses,rowsOnlyCommitAcks,normalMigrationCount:MIGRATION_MANIFEST.length,coreUnknownPairPreserved:true,realChrCalls:0,productionWired:false,combinedSignedProductionPin:false,limitations:["Synthetic explicit operator/quiescence and issuer fixture only; no production enrollment, clone resistance, authenticated bandwidth endpoint mapping or caller activation claim","One runner-owned ephemeral localhost cluster; no remote DB/CHR; native evidence uses localhost license responder"]}))
|
|
}finally{await f.close()}
|