Files
MikrotikManager/backend/src/services/traffic-flow-write-transaction.pg.test.ts
T

185 lines
10 KiB
TypeScript

import assert from "node:assert/strict"
import { randomUUID } from "node:crypto"
import { readFile } from "node:fs/promises"
import type { PoolClient } from "pg"
import { pool, closePool } from "../db/index.js"
import { commitFlowWrite, reconcileFlowWrite, flowWriteQuery, FlowCommitUnknown, FLOW_WRITE_LOCK_KEY } from "./traffic-flow-write-transaction.js"
import { withFlowWriterExclusion } from "./traffic-flow-writer-exclusion.js"
// Only the disposable embedded-PG runner may invoke this SQL acceptance.
const url = new URL(process.env.DATABASE_URL ?? "postgresql://invalid")
assert.equal(process.env.MMAPP_OWN_FLOW_WRITES, "true")
assert.equal(url.hostname, "127.0.0.1")
assert.equal(url.pathname, "/postgres")
assert.match(process.env.MCP_STATE_DIR ?? "", /mm-mcp-test-/)
const schema = "flow_write_" + randomUUID().replaceAll("-", "")
const connect = async () => {
const client = await pool.connect()
try { await client.query(`SET search_path TO ${schema}`); return client }
catch (error) { client.release(true); throw error }
}
const identity = () => ({ id: randomUUID(), kind: "rebuild" as const, sourceProof: "a".repeat(64) })
const write = async (value: number) => {
for (const table of ["flow_hour_facts", "flow_daily_facts", "events"])
await flowWriteQuery(`INSERT INTO ${table}(value) VALUES($1)`, [value])
return { value }
}
const counts = async () => {
const client = await connect()
try {
const values: number[] = []
for (const table of ["flow_hour_facts", "flow_daily_facts", "events", "flow_write_receipts"])
values.push(Number((await client.query(`SELECT count(*) AS n FROM ${table}`)).rows[0].n))
return values
} finally { client.release() }
}
const waitForLockWaiter = async (pid: number) => {
const deadline = Date.now() + 3000
while (Date.now() < deadline) {
if ((await pool.query("SELECT 1 FROM pg_locks WHERE pid=$1 AND NOT granted AND locktype='advisory'", [pid])).rowCount) return
await new Promise<void>(resolve => setTimeout(resolve, 10))
}
throw Error("Expected PostgreSQL advisory-lock waiter was not observed")
}
try {
await pool.query(`CREATE SCHEMA ${schema}`)
const setup = await connect()
try {
await setup.query(await readFile(new URL("../../drizzle/0032_flow_write_receipts.sql", import.meta.url), "utf8"))
// Shadow publication tables isolate the transaction contract from collector lifecycle.
for (const table of ["flow_hour_facts", "flow_daily_facts", "events"])
await setup.query(`CREATE TABLE ${table}(value integer NOT NULL)`)
} finally { setup.release() }
const success = identity()
assert.deepEqual(await commitFlowWrite(success, () => write(1), undefined, connect), { value: 1 })
assert.deepEqual(await counts(), [1, 1, 1, 1])
let replayed = 0
assert.deepEqual(await commitFlowWrite(success, async () => { replayed++; return write(99) }, undefined, connect), { value: 1 })
assert.equal(replayed, 0)
await assert.rejects(commitFlowWrite({ ...success, sourceProof: "b".repeat(64) }, () => write(2), undefined, connect), /source does not match/)
const rolledBack = identity()
await assert.rejects(commitFlowWrite(rolledBack, async () => { await write(2); throw Error("publication fault") }, undefined, connect), /publication fault/)
assert.deepEqual(await counts(), [1, 1, 1, 1])
assert.deepEqual(await reconcileFlowWrite(rolledBack, undefined, connect), { committed: false, result: null })
// An aborted transaction can answer COMMIT with a successful ROLLBACK tag.
// This is not durable publication acknowledgement and must retain ownership.
const rollbackAcknowledged=identity()
let actualCommitCommand:string|undefined,rollbackBackendDestroyed=false
const abortedCommit=async()=>{
const client=await connect()
return new Proxy(client,{get(target,key){
if(key==="query")return async(...args:unknown[])=>{
if(args[0]==="COMMIT"){
await assert.rejects(target.query("SELECT 1/0"))
const answer=await target.query("COMMIT");actualCommitCommand=answer.command;return answer
}
return (target.query as (...args:unknown[])=>Promise<unknown>).apply(target,args)
}
if(key==="release")return(destroy=false)=>{rollbackBackendDestroyed=destroy;target.release(destroy)}
const value=Reflect.get(target,key);return typeof value==="function"?value.bind(target):value
}})as PoolClient
}
await assert.rejects(commitFlowWrite(rollbackAcknowledged,()=>write(8),undefined,abortedCommit),FlowCommitUnknown)
assert.equal(actualCommitCommand,"ROLLBACK");assert.equal(rollbackBackendDestroyed,true)
assert.deepEqual(await counts(),[1,1,1,1])
assert.deepEqual(await reconcileFlowWrite(rollbackAcknowledged,undefined,connect),{committed:false,result:null})
// Actual COMMIT succeeds, but its response is lost to the caller.
const lost = identity()
const loseAck = async () => {
const client = await connect()
return new Proxy(client, { get(target, key) {
if (key === "query") return async (...args: unknown[]) => {
const result = await (target.query as (...args: unknown[]) => Promise<unknown>).apply(target, args)
if (args[0] === "COMMIT") throw Error("simulated lost COMMIT response")
return result
}
const value = Reflect.get(target, key)
return typeof value === "function" ? value.bind(target) : value
} }) as PoolClient
}
await assert.rejects(commitFlowWrite(lost, () => write(3), undefined, loseAck), FlowCommitUnknown)
assert.deepEqual(await reconcileFlowWrite(lost, undefined, connect), { committed: true, result: { value: 3 } })
assert.deepEqual(await counts(), [2, 2, 2, 2])
// A predecessor still holds its actual PostgreSQL transaction/batch lock.
// Receipt absence must remain inconclusive until that backend is finished.
const pending = identity(), predecessor = await connect()
await predecessor.query("BEGIN")
await predecessor.query("SELECT pg_advisory_xact_lock(hashtextextended($1,0))", ["flow-write-batch:" + pending.id])
await predecessor.query("INSERT INTO flow_write_receipts(batch_id,kind,source_proof,result) VALUES($1,$2,$3,$4)", [pending.id, pending.kind, pending.sourceProof, { value: 4 }])
const observer = await connect(), observerPid = Number((await observer.query("SELECT pg_backend_pid() AS pid")).rows[0].pid)
let finished = false
const waiting = reconcileFlowWrite(pending, undefined, async () => observer).then(value => { finished = true; return value })
try {
await waitForLockWaiter(observerPid)
assert.equal(finished, false)
await predecessor.query("COMMIT")
assert.deepEqual(await waiting, { committed: true, result: { value: 4 } })
} finally { await predecessor.query("ROLLBACK"); predecessor.release(); await waiting }
const absent = identity(), rollingBack = await connect()
await rollingBack.query("BEGIN")
await rollingBack.query("SELECT pg_advisory_xact_lock(hashtextextended($1,0))", ["flow-write-batch:" + absent.id])
const absentObserver = await connect(), absentPid = Number((await absentObserver.query("SELECT pg_backend_pid() AS pid")).rows[0].pid)
let absenceConfirmed = false
const absentWaiting = reconcileFlowWrite(absent, undefined, async () => absentObserver).then(value => { absenceConfirmed = true; return value })
try {
await waitForLockWaiter(absentPid)
assert.equal(absenceConfirmed, false)
await rollingBack.query("ROLLBACK")
assert.deepEqual(await absentWaiting, { committed: false, result: null })
} finally { await rollingBack.query("ROLLBACK"); rollingBack.release(); await absentWaiting }
// The production purge lease must fence an ordinary shared ingest writer too.
let releaseFence: () => void = () => {}, fenceEntered: () => void = () => {}
const fenceReady = new Promise<void>(resolve => { fenceEntered = resolve })
const release = new Promise<void>(resolve => { releaseFence = resolve })
const exclusion = withFlowWriterExclusion(async () => { fenceEntered(); await release }, undefined, connect)
await fenceReady
const blockedClient = await connect(), blockedPid = Number((await blockedClient.query("SELECT pg_backend_pid() AS pid")).rows[0].pid)
let bodyStarted = false
const blockedWrite = commitFlowWrite(identity(), async () => { bodyStarted = true; return write(5) }, undefined, async () => blockedClient)
try {
await waitForLockWaiter(blockedPid)
assert.equal(bodyStarted, false)
} finally { releaseFence(); await exclusion }
assert.deepEqual(await blockedWrite, { value: 5 })
const writer = await connect()
try {
await writer.query("BEGIN")
await writer.query("SELECT pg_advisory_xact_lock_shared($1)", [FLOW_WRITE_LOCK_KEY])
let ran = false
await assert.rejects(commitFlowWrite({ ...identity(), exclusive: true }, async () => { ran = true; return write(5) }, undefined, connect), /writers are busy/)
assert.equal(ran, false)
} finally { await writer.query("ROLLBACK"); writer.release() }
const receiptBlocker = await connect(), cachedObserver = await connect()
await receiptBlocker.query("BEGIN")
await receiptBlocker.query("SELECT pg_advisory_xact_lock(hashtextextended($1,0))", ["flow-write-batch:" + success.id])
const cachedPid = Number((await cachedObserver.query("SELECT pg_backend_pid() AS pid")).rows[0].pid)
let cachedRevoked = false, cachedBody = false
const cachedWaiting = commitFlowWrite(success, async () => { cachedBody = true; return write(98) }, async () => { if (cachedRevoked) throw Error("cached authority revoked during lock wait") }, async () => cachedObserver)
try {
await waitForLockWaiter(cachedPid)
cachedRevoked = true
await receiptBlocker.query("ROLLBACK")
await assert.rejects(cachedWaiting, /cached authority revoked during lock wait/)
assert.equal(cachedBody, false)
} finally { await receiptBlocker.query("ROLLBACK"); receiptBlocker.release() }
const beforeRevocation = await counts()
let revoked = false
await assert.rejects(commitFlowWrite(identity(), async () => { await write(6); revoked = true; return { value: 6 } }, async () => { if (revoked) throw Error("revoked before commit") }, connect), /revoked before commit/)
assert.deepEqual(await counts(), beforeRevocation)
console.log("Flow writer real PostgreSQL: atomic cubes/event/receipt rollback, idempotence, source mismatch, lost COMMIT ACK, observed in-flight COMMIT/rollback advisory barriers, both shared/exclusive lease directions, cached-receipt revocation after real lock wait and pre-COMMIT revocation passed")
} finally {
await pool.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`)
await closePool()
}