Files
MikrotikManager/backend/src/services/bandwidth-native-permit.sql-helper.ts
T

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}
}