92 lines
7.4 KiB
TypeScript
92 lines
7.4 KiB
TypeScript
/** Actual PostgreSQL -> admission -> strict RouterOS HTTP acceptance. Only an
|
|
* explicitly owned disposable fixture may invoke this helper. */
|
|
import assert from "node:assert/strict"
|
|
import {createServer} from "node:http"
|
|
import {once} from "node:events"
|
|
import {randomUUID} from "node:crypto"
|
|
import type {Pool} from "pg"
|
|
import type {createConfiguredBandwidthControlSource} from "./bandwidth-control-source.js"
|
|
import {createBandwidthAdmission,type BandwidthBinding,type BandwidthJournal,type BandwidthNativePermit,type BandwidthScope} from "./bandwidth-admission.js"
|
|
import {assertOwnedBandwidthSql,fixtureMac,scope} from "./bandwidth-admission-process.sql-helper.js"
|
|
|
|
export async function acceptBandwidthNativePermits(source:ReturnType<typeof createConfiguredBandwidthControlSource>,owner:Pool,controlGeneration:string){
|
|
assertOwnedBandwidthSql()
|
|
const {MikrotikClient}=await import("./mikrotik.js")
|
|
const {createBandwidthAdmissionSqlJournal}=await import("./bandwidth-admission-storage.js")
|
|
const checks:string[]=[]
|
|
let posts=0
|
|
const scenarios=["direct","helper","arm-ack-loss","wrong-client","copied-permit","changed-body","nonterminal"] as const
|
|
for(const scenario of scenarios){
|
|
let scenarioPosts=0,received:unknown
|
|
const server=createServer(async(req,res)=>{
|
|
let text="";for await(const chunk of req)text+=String(chunk)
|
|
assert.equal(req.url,"/rest/tool/bandwidth-test");assert.equal(req.method,"POST")
|
|
received=JSON.parse(text);scenarioPosts++;posts++
|
|
res.setHeader("content-type","application/json")
|
|
res.end(JSON.stringify([{status:scenario==="nonterminal"?"running":"done testing","tx-total-average":"1000","rx-total-average":"2000"}]))
|
|
})
|
|
server.listen(0,"127.0.0.1");await once(server,"listening")
|
|
const address=server.address();assert(address&&typeof address==="object")
|
|
const params={host:"127.0.0.1",port:address.port,useSsl:false,verifySsl:false,username:"synthetic-native-user",password:"synthetic-native-password"}
|
|
const client=new MikrotikClient(params,undefined,{requireBandwidthPermit:true})
|
|
const other=new MikrotikClient(params,undefined,{requireBandwidthPermit:true})
|
|
const nativeBody={address:"198.51.100.42@isolated-test",user:"synthetic-peer",password:"synthetic-peer-password",protocol:"tcp",direction:"both",duration:"3s"}
|
|
let activeConnection:Awaited<ReturnType<typeof source.connect>>|undefined,activeScope:BandwidthScope|undefined,terminalProof:string|undefined,lastRaw:unknown
|
|
const rawJournal=createBandwidthAdmissionSqlJournal({now:Date.now,
|
|
connect:async window=>{activeScope=window;activeConnection=await source.connect(window);return activeConnection},
|
|
authorize:async(binding,window)=>{assert.equal(binding.controlGeneration,controlGeneration);assert.equal(binding.authorityProof,fixtureMac("authority"));assert(Date.now()<window.deadlineAt);window.signal?.throwIfAborted()},
|
|
verifyEvidence:async(transition,_binding,evidence)=>{
|
|
if(transition==="complete"){assert(terminalProof);assert.deepEqual(evidence,{terminalProof})}
|
|
if(transition==="release-before-dispatch")assert.deepEqual(evidence,{from:"armed",proof:"private-no-send"})
|
|
},
|
|
eventProof:async event=>{assert(activeConnection&&activeScope);return source.eventProofOnConnection(event,activeConnection,activeScope)},
|
|
})
|
|
const journal:BandwidthJournal={...rawJournal,arm:async(binding,window)=>{const ack=await rawJournal.arm(binding,window);if(scenario==="arm-ack-loss")throw Error("Owned actual arm COMMIT ACK deliberately lost");return ack}}
|
|
const id=randomUUID(),input={attemptId:id,callerKind:"mcp-speed" as const,operationId:randomUUID(),request:{scenario},
|
|
source:{canonicalNodeId:"strict:"+id+":A",endpointProof:fixtureMac([id,"source"])},
|
|
destination:{canonicalNodeId:"strict:"+id+":B",endpointProof:fixtureMac([id,"remote"])},
|
|
authorityProof:fixtureMac("authority"),authorityGeneration:"synthetic-original-grant",controlGeneration,expiresAt:Date.now()+60000,durationSec:3,nativeBody}
|
|
const admission=createBandwidthAdmission(input,{now:Date.now,cleanupBudgetMs:10000,nativeClient:client,journal,
|
|
keyedProof:async(purpose,value)=>{
|
|
if(purpose==="bandwidth-terminal-v1")assert.deepEqual((value as {raw:unknown}).raw,lastRaw)
|
|
const proof=await source.eventProof({purpose,value},scope())
|
|
if(purpose==="bandwidth-terminal-v1")terminalProof=proof
|
|
return proof
|
|
},
|
|
authorize:async()=>({authorityProof:input.authorityProof,authorityGeneration:input.authorityGeneration,controlGeneration,expiresAt:input.expiresAt}),
|
|
endpoints:async()=>({source:input.source,destination:input.destination}),
|
|
send:async(_binding:Readonly<BandwidthBinding>,body,window,permit)=>{
|
|
const selected=scenario==="wrong-client"?other:client
|
|
const usedPermit=scenario==="copied-permit"?JSON.parse(JSON.stringify(permit)) as BandwidthNativePermit:permit
|
|
const usedBody=scenario==="changed-body"?{...body,address:"203.0.113.99"}:body
|
|
const raw=scenario==="helper"?await selected.bandwidthTest({address:body.address,user:body.user,password:body.password,protocol:"tcp",direction:"both",durationSec:3},window.signal,undefined,usedPermit)
|
|
:await selected.post("/tool/bandwidth-test",usedBody,30000,window.signal,undefined,usedPermit)
|
|
lastRaw=raw
|
|
await assert.rejects(selected.post("/tool/bandwidth-test",body,30000,window.signal,undefined,permit))
|
|
return raw
|
|
},
|
|
})
|
|
try{
|
|
await assert.rejects(client.post("/tool/bandwidth-test",nativeBody))
|
|
await assert.rejects(client.bandwidthTest({address:nativeBody.address,user:nativeBody.user,password:nativeBody.password,durationSec:3}))
|
|
assert.equal(scenarioPosts,0)
|
|
if(scenario==="arm-ack-loss")await assert.rejects(admission.reserveAndArm(scope()),error=>error instanceof Error&&"code" in error&&error.code==="PERSISTENCE_UNKNOWN")
|
|
else{
|
|
const capability=await admission.reserveAndArm(scope())
|
|
if(scenario==="direct"||scenario==="helper")assert.equal((await admission.dispatch(capability)).remoteCompletionConfirmed,true)
|
|
else await assert.rejects(admission.dispatch(capability),error=>error instanceof Error&&"code" in error&&error.code==="REMOTE_UNKNOWN")
|
|
await assert.rejects(admission.dispatch(capability))
|
|
}
|
|
const completed=scenario==="direct"||scenario==="helper"
|
|
const occupancy=await owner.query("SELECT count(*) AS n FROM mmapp_control.bandwidth_node_occupancy WHERE attempt_id=$1",[id])
|
|
assert.equal(Number(occupancy.rows[0].n),completed?0:2)
|
|
assert.equal(scenarioPosts,completed||scenario==="nonterminal"?1:0)
|
|
if(scenarioPosts)assert.deepEqual(received,nativeBody)
|
|
const persisted=await owner.query("SELECT state FROM mmapp_control.bandwidth_attempts WHERE attempt_id=$1",[id])
|
|
assert.equal(persisted.rows[0].state,completed?"released":"unknown_busy")
|
|
checks.push("actual signed-source/runtime-role PG journal -> strict native "+scenario+": "+scenarioPosts+" HTTP POST; exact body, no permit replay; "+(completed?"terminal completion releases both owners":"both owners stay unknown-busy"))
|
|
}finally{server.closeAllConnections();await new Promise<void>((resolve,reject)=>server.close(error=>error?reject(error):resolve()))}
|
|
}
|
|
return {checks,scenarios:scenarios.length,actualLocalhostBandwidthPosts:posts,realChrCalls:0,globalCallerActivation:false,operatorAuthoritySynthetic:true}
|
|
}
|