/** 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,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>|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(){ 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,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((resolve,reject)=>server.close(error=>error?reject(error):resolve()))} } return {checks,scenarios:scenarios.length,actualLocalhostBandwidthPosts:posts,realChrCalls:0,globalCallerActivation:false,operatorAuthoritySynthetic:true} }