185 lines
10 KiB
TypeScript
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()
|
|
}
|