63 lines
6.1 KiB
TypeScript
63 lines
6.1 KiB
TypeScript
/** Owned opt-in SQL profile only: actual production poll, journal and quota. */
|
|
import assert from "node:assert/strict"
|
|
import { randomUUID } from "node:crypto"
|
|
import { createServer } from "node:http"
|
|
import { readFile } from "node:fs/promises"
|
|
import { resolve } from "node:path"
|
|
|
|
export async function acceptServerPollStorageExecutionSql(){
|
|
assert([process.env.MMAPP_OWN_SERVER_POLL_STORAGE,process.env.MMAPP_OWN_SERVER_POLL_STORAGE_FRESH].includes("true"))
|
|
const {pool}=await import("../db/index.js")
|
|
const {ensurePartitionFor}=await import("../db/partitions.js")
|
|
const {createStorageDurableServerPollSession}=await import("./server-poll-durable-session.js")
|
|
const security=await import("../modules/mcp/security.js")
|
|
let requests=0,serverId:number|undefined,admissionChecked=0,firstReservationBytes=""
|
|
const receiptId=randomUUID(),executionId=randomUUID(),ownerId="owned-full-storage-"+randomUUID()
|
|
const listener=createServer(async(req,res)=>{
|
|
requests++
|
|
try{
|
|
const admission=(await pool.query("SELECT a.claim_token,a.claim_attempted_at,a.used_rows,u.reserved_bytes::text FROM server_poll_storage_admissions a JOIN server_poll_storage_usage u ON u.scope='owner:'||a.owner_id JOIN server_poll_executions e USING(receipt_id) WHERE a.receipt_id=$1 AND a.execution_id=$2 AND a.owner_id=$3",[receiptId,executionId,ownerId])).rows
|
|
assert.equal(admission.length,1);assert.equal(admission[0].claim_token,null);assert(admission[0].claim_attempted_at);assert(Number(admission[0].used_rows)>=1)
|
|
firstReservationBytes=admission[0].reserved_bytes;assert.equal(firstReservationBytes,"8421376");admissionChecked++
|
|
const result=req.url==="/rest/system/identity"?{name:"owned-poll-storage-after"}:req.url==="/rest/system/resource"?{version:"7.synthetic","board-name":"owned",uptime:"1h","cpu-load":"2","free-memory":"1024","total-memory":"2048"}:req.url==="/rest/interface"?[{name:"owned-interface",type:"ether"}]:req.url==="/rest/ip/address"?[{address:"192.0.2.1/24",interface:"owned-interface"}]:null
|
|
res.setHeader("content-type","application/json");res.statusCode=result===null?404:200;res.end(JSON.stringify(result))
|
|
}catch{res.statusCode=500;res.end("SYNTHETIC admission check refused")}
|
|
})
|
|
try{
|
|
await new Promise<void>((yes,no)=>{listener.once("error",no);listener.listen(0,"127.0.0.1",()=>{listener.off("error",no);yes()})})
|
|
const port=(listener.address()as{port:number}).port
|
|
serverId=Number((await pool.query("INSERT INTO servers(name,host,port,enabled,username,password,use_ssl,verify_ssl) VALUES('owned-poll-storage-before','127.0.0.1',$1,true,'SYNTHETIC','SYNTHETIC',false,true) RETURNING id",[port])).rows[0].id)
|
|
await ensurePartitionFor(pool,"server_snapshots","week",new Date())
|
|
const issuedAt=Date.now()-1000,expiresAt=Date.now()+600000,generation=await security.accessGeneration()
|
|
const epoch=(await pool.query("SELECT routing_endpoint_epoch FROM servers WHERE id=$1",[serverId])).rows[0].routing_endpoint_epoch
|
|
const authorityProof=await security.privateSecretFingerprint(security.fingerprint({ownerId,issuedAt,expiresAt,generation,serverId,port,epoch,permissions:["mm:servers:write"],global:true}),"owned-full-storage-authority-v1")
|
|
let authorityReads=0
|
|
const session=createStorageDurableServerPollSession({request:{serverId,receiptId},identity:{kind:"rest",authentication:"local",ownerId,executionId,requestId:randomUUID(),issuedAt,expiresAt},authorize:async(request,ids,signal)=>{
|
|
signal?.throwIfAborted();authorityReads++
|
|
assert(Date.now()>=issuedAt&&Date.now()<expiresAt);assert.equal(request.receiptId,receiptId);assert.equal(request.serverId,serverId)
|
|
assert.equal((await readFile(resolve(security.mcpStateDirectory(),"access-generation"))).toString("hex"),generation)
|
|
const rows=(await pool.query("SELECT id,host,port,enabled,routing_endpoint_epoch,(SELECT count(*)::int FROM mcp_protections) AS protections FROM servers ORDER BY id LIMIT 1001")).rows
|
|
assert.equal(rows.length,1);assert.equal(rows[0].id,serverId);assert.equal(rows[0].host,"127.0.0.1");assert.equal(rows[0].port,port);assert.equal(rows[0].enabled,true);assert.equal(rows[0].routing_endpoint_epoch,epoch);assert.equal(rows[0].protections,0);assert(ids.every(id=>id===serverId))
|
|
return {global:true,serverIds:[serverId!],authorityProof}
|
|
}})
|
|
const plan=await session.prepare(),started=Date.now()
|
|
assert.equal(requests,0)
|
|
console.log("Owned storage-bound poll prepared:",JSON.stringify({maintenanceEffects:plan.maintenance.length}))
|
|
const receipt=await session.execute(plan)
|
|
assert.equal(receipt.complete,true);assert.equal(receipt.maintenanceComplete,true);assert.equal(receipt.configurationVerified,true)
|
|
assert.equal(requests,4);assert.equal(admissionChecked,4)
|
|
const admission=(await pool.query("SELECT max_stages,used_rows,used_bytes::text FROM server_poll_storage_admissions WHERE receipt_id=$1",[receiptId])).rows[0]
|
|
assert.equal(admission.max_stages,plan.maintenance.length+8)
|
|
assert.equal(admission.used_rows,2*(receipt.completedPublications+4)+2)
|
|
assert(Number(admission.used_bytes)>0&&Number(admission.used_bytes)<8388608)
|
|
const repeated=await session.execute(plan)
|
|
assert.equal(repeated.complete,true);assert.equal(requests,4)
|
|
assert.equal((await pool.query("SELECT used_rows FROM server_poll_storage_admissions WHERE receipt_id=$1",[receiptId])).rows[0].used_rows,admission.used_rows)
|
|
const result={fourActualNativeGets:requests,allDispatchesAfterConfirmedConsumedAdmission:admissionChecked,maintenanceEffects:plan.maintenance.length,completedPublications:receipt.completedPublications,fullJournalRows:admission.used_rows,logicalReservationBytes:firstReservationBytes,knownReplayNoNewNativeOrCharge:true,freshAuthorityReads:authorityReads,elapsedWithReplayMs:Date.now()-started,productionQuotaBoundAssembly:true,actualNewRestAuthorityFactory:false,publicRegistration:false}
|
|
console.log("Owned storage-bound full poll:",JSON.stringify(result));return result
|
|
}finally{
|
|
listener.closeAllConnections();if(listener.listening)await new Promise<void>(yes=>listener.close(()=>yes()))
|
|
if(serverId!==undefined)await pool.query("UPDATE servers SET enabled=false WHERE id=$1",[serverId])
|
|
}
|
|
}
|