Files
MikrotikManager/backend/src/services/server-poll-rest-authority.sql-helper.ts
T

120 lines
9.4 KiB
TypeScript

/** Owned fresh PostgreSQL acceptance using the fixed REST host and its actual
* authority factory. No source, signer, SQL, session or authority overrides. */
import assert from "node:assert/strict"
import { randomUUID } from "node:crypto"
import { createServer } from "node:http"
import { basename, dirname, resolve } from "node:path"
import type { AuthUser } from "../lib/permissions.js"
import type { ServerPollRestContext } from "./server-poll-rest.js"
export async function acceptServerPollRestAuthoritySql(options: { httpRoute?: true } = {}) {
// These assertions precede all imports capable of creating a configured pool.
assert.equal(process.env.MMAPP_OWN_SERVER_POLL_STORAGE_FRESH, "true")
const endpoint = new URL(process.env.DATABASE_URL ?? "")
assert.equal(endpoint.hostname, "127.0.0.1"); assert.equal(endpoint.pathname, "/postgres")
assert(process.env.MCP_STATE_DIR && basename(dirname(resolve(process.env.MCP_STATE_DIR))).startsWith("mm-mcp-test-"))
const { pool } = await import("../db/index.js")
const { ensurePartitionFor } = await import("../db/partitions.js")
const { executeDurableServerPollRest } = await import("./server-poll-rest.js")
const ownerId = "owned-rest-authority-" + randomUUID(), name = "owned-rest-authority"
let serverId: number | undefined, requests = 0, checkedAdmissions = 0, dispatchFailure = false
let app: Awaited<ReturnType<typeof import("../index.js")["buildApp"]>> | undefined
let httpOrigin = ""
const paths: string[] = []
const listener = createServer(async (request, response) => {
requests++; paths.push(request.url ?? "")
try {
assert.equal(request.method, "GET")
const rows = (await pool.query(`SELECT a.receipt_id,a.claim_token,a.claim_attempted_at,a.used_rows,
u.admissions,u.reserved_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.owner_id=$1 AND a.identity_kind='rest' AND e.context_proof=a.context_proof`, [ownerId])).rows
assert.equal(rows.length, 1); assert.equal(rows[0].claim_token, null)
assert(rows[0].claim_attempted_at); assert(Number(rows[0].used_rows) >= 1)
assert.equal(Number(rows[0].admissions), 1); assert.equal(Number(rows[0].reserved_rows), 4019)
assert.equal(rows[0].reserved_bytes, "8421376"); checkedAdmissions++
const result = request.url === "/rest/system/identity" ? { name }
: request.url === "/rest/system/resource" ? { version: "7.synthetic", "board-name": "owned", uptime: "1h", "cpu-load": "2", "free-memory": "1024", "total-memory": "2048" }
: request.url === "/rest/interface" ? [{ type: "ether", name: "owned-interface" }]
: request.url === "/rest/ip/address" ? [{ interface: "owned-interface", address: "192.0.2.1/24" }] : null
assert.notEqual(result, null)
response.setHeader("content-type", "application/json"); response.statusCode = 200; response.end(JSON.stringify(result))
} catch {
dispatchFailure = true; response.statusCode = 500; response.end("Owned dispatch refused")
}
})
const actor: AuthUser = { id: ownerId, email: "[email protected]", name: "Owned REST authority", apps: ["mm"],
permissions: ["mm:servers:write"], issuedAt: Date.now() - 1000, expiresAt: Date.now() + 600000 }
const context = (patch: Partial<ServerPollRestContext> = {}): ServerPollRestContext => ({ actor, authRequired: true,
acceptedAt: Date.now(), requestId: randomUUID(), deadlineAt: Date.now() + 180000, ...patch })
const call = async (id: string, accepted: ServerPollRestContext) => {
if (!options.httpRoute) return executeDurableServerPollRest(id, accepted)
assert(app && httpOrigin)
const { env } = await import("../config.js")
const token = accepted.actor ? app.jwt.sign({ iss: env.authIssuer, sub: accepted.actor.id, email: accepted.actor.email, name: accepted.actor.name,
apps: accepted.actor.apps, permissions: accepted.actor.permissions, iat: Math.floor(accepted.actor.issuedAt! / 1000), exp: Math.floor(accepted.actor.expiresAt! / 1000) }) : undefined
const response = await fetch(httpOrigin + "/api/servers/" + encodeURIComponent(id) + "/poll", { method: "POST",
headers: { "content-type": "application/json", "x-request-id": "untrusted-header", ...(token ? { authorization: "Bearer " + token } : {}) },
body: JSON.stringify({ actor: { id: "untrusted-owner" }, authRequired: false, requestId: "untrusted-body", deadlineAt: Date.now() + 86400000 }),
signal: AbortSignal.timeout(185000) })
return { statusCode: response.status, body: await response.json() as Record<string, unknown> }
}
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($1,'127.0.0.1',$2,true,'SYNTHETIC-USER','SYNTHETIC-PRIVATE-PASSWORD',false,true) RETURNING id", [name, port])).rows[0].id)
await ensurePartitionFor(pool, "server_snapshots", "week", new Date())
if (options.httpRoute) {
const { buildApp } = await import("../index.js")
app = await buildApp({ logger: false, startScheduler: false })
await app.listen({ host: "127.0.0.1", port: 0 })
const address = app.server.address(); assert(address && typeof address !== "string")
httpOrigin = `http://127.0.0.1:${address.port}`
}
const before = (await pool.query("SELECT count(*)::int AS n FROM server_poll_storage_admissions")).rows[0].n
const negative = [
await call("invalid-id", context()),
await call(String(serverId), context({ actor: undefined })),
await call(String(serverId), context({ actor: { ...actor, permissions: ["mm:servers:read"] } })),
await call("2147483647", context()),
]
assert.deepEqual(negative.map(reply => reply.statusCode), [400, options.httpRoute ? 401 : 403, 403, 404])
assert.equal(requests, 0)
assert.equal((await pool.query("SELECT count(*)::int AS n FROM server_poll_storage_admissions")).rows[0].n, before)
const started = Date.now()
// Exactly one invocation. A failed/unknown attempt is never replayed here.
const reply = await call(String(serverId), context())
const elapsedMs = Date.now() - started
if (reply.statusCode !== 200) {
const phase = (await pool.query(`SELECT a.used_rows,a.claim_attempted_at IS NOT NULL AS consumed,
EXISTS(SELECT 1 FROM server_poll_receipts r WHERE r.receipt_id=a.receipt_id) AS receipt,
EXISTS(SELECT 1 FROM server_poll_quarantines q WHERE q.receipt_id=a.receipt_id) AS quarantine,
(SELECT stage FROM server_poll_intents i WHERE i.receipt_id=a.receipt_id ORDER BY created_at DESC,stage DESC LIMIT 1) AS last_stage
FROM server_poll_storage_admissions a WHERE owner_id=$1`, [ownerId])).rows
console.log("Owned actual REST authority failure:", JSON.stringify({ elapsedMs, statusCode: reply.statusCode,
nativeGets: requests, phase, publicError: reply.body.error, automaticReplay: false }))
}
assert.equal(reply.statusCode, 200, "Actual REST authority full poll failed; no automatic replay")
assert.equal(dispatchFailure, false); assert.equal(requests, 4); assert.equal(checkedAdmissions, 4)
assert.deepEqual(paths.sort(), ["/rest/interface", "/rest/ip/address", "/rest/system/identity", "/rest/system/resource"])
assert.deepEqual(Object.keys(reply.body).sort(), ["id", "serverId", "polledAt", "status", "latencyMs", "rosVersion", "boardName", "uptime", "cpuLoad", "freeMemory", "totalMemory", "identityName"].sort())
assert.equal(reply.body.serverId, serverId); assert.equal(reply.body.status, "online"); assert.equal(reply.body.identityName, name)
assert.equal(reply.body.rosVersion, "7.synthetic"); assert.equal(reply.body.boardName, "owned"); assert.equal(reply.body.uptime, "1h")
assert.equal(reply.body.cpuLoad, 2); assert.equal(reply.body.freeMemory, 1024); assert.equal(reply.body.totalMemory, 2048)
assert(Number.isSafeInteger(reply.body.id) && Number(reply.body.id) > 0)
assert.equal(typeof reply.body.polledAt, "string"); assert(Number.isFinite(Date.parse(String(reply.body.polledAt))))
assert.equal(typeof reply.body.latencyMs, "number"); assert(Number(reply.body.latencyMs) >= 0)
const serialized = JSON.stringify(reply.body)
for (const secret of ["SYNTHETIC-USER", "SYNTHETIC-PRIVATE-PASSWORD", "rawInterfaces", "rawIpAddresses", "192.0.2.1", "owned-interface"]) assert.equal(serialized.includes(secret), false)
const result = { statusCode: reply.statusCode, elapsedMs, nativeGets: requests, dispatchesAfterConsumedAdmission: checkedAdmissions,
actualRestAuthorityFactory: true, actualProductionSession: true, actualRegisteredHttpRoute: options.httpRoute === true, actualSignedJwt: options.httpRoute === true, httpAppSchedulerStarted: false, negativeStatuses: negative.map(value => value.statusCode),
exactLegacySnapshotShape: true, privateFieldsAbsent: true, automaticReplay: false }
console.log("Owned actual REST authority:", JSON.stringify(result)); return result
} finally {
await app?.close()
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])
}
}