123 lines
8.9 KiB
TypeScript
123 lines
8.9 KiB
TypeScript
/** Owned-local PostgreSQL regression only. It deliberately changes disposable
|
|
* runtime SESSION defaults and observes real driver COMMITs; no native traffic. */
|
|
import assert from "node:assert/strict"
|
|
import { randomUUID } from "node:crypto"
|
|
import type { Pool } from "pg"
|
|
import type { createConfiguredBandwidthControlSource } from "./bandwidth-control-source.js"
|
|
import type { BandwidthBinding, BandwidthScope } from "./bandwidth-admission.js"
|
|
import type { ProbeStorageConnection } from "./server-probe-journal-maintenance.js"
|
|
import { assertOwnedBandwidthSql, fixtureBinding, completionProof, scope } from "./bandwidth-admission-process.sql-helper.js"
|
|
|
|
assertOwnedBandwidthSql()
|
|
|
|
export async function acceptBandwidthJournalDurability(source: ReturnType<typeof createConfiguredBandwidthControlSource>, owner: Pool, controlGeneration: string) {
|
|
assertOwnedBandwidthSql()
|
|
const { Client } = await import("pg")
|
|
const { createBandwidthAdmissionSqlJournal } = await import("./bandwidth-admission-storage.js")
|
|
const connect = source.connect.bind(source), eventProof = source.eventProofOnConnection.bind(source)
|
|
const originalQuery = Client.prototype.query, pids = new Set<number>(), commitSettings: string[] = []
|
|
const held = new Set<ProbeStorageConnection>()
|
|
let patched = false, allDefaultsRestored = false
|
|
const acquireFour = async () => {
|
|
// Retain the completed siblings too if one checkout fails: finally must
|
|
// never leave a session owned by this helper checked out.
|
|
const results = await Promise.allSettled(Array.from({ length: 4 }, async () => { const lease = await connect(scope()); held.add(lease); return lease }))
|
|
for (const result of results) if (result.status === "rejected") throw result.reason
|
|
return results.map(result => (result as PromiseFulfilledResult<ProbeStorageConnection>).value)
|
|
}
|
|
const release = (lease: ProbeStorageConnection) => { held.delete(lease); lease.release() }
|
|
try {
|
|
const initial = await acquireFour()
|
|
for (const lease of initial) {
|
|
await lease.query("SET SESSION synchronous_commit=off")
|
|
const row = (await lease.query("SELECT pg_catalog.pg_backend_pid() AS pid,pg_catalog.current_setting('synchronous_commit') AS setting")).rows[0]
|
|
assert.equal(row.setting, "off"); pids.add(Number(row.pid))
|
|
}
|
|
assert.equal(pids.size, 4)
|
|
initial.forEach(release)
|
|
Client.prototype.query = function (this: InstanceType<typeof Client>, ...args: unknown[]) {
|
|
const text = typeof args[0] === "string" ? args[0] : (args[0] as { text?: string })?.text ?? ""
|
|
const pid = (this as unknown as { processID: number }).processID
|
|
if (!pids.has(pid) || !/^COMMIT\s*;?$/i.test(text.trim())) return Reflect.apply(originalQuery, this, args)
|
|
// The real same-driver observation runs inside this transaction and
|
|
// precedes its genuine COMMIT. Neither result is fabricated or replaced.
|
|
return (async () => {
|
|
const observation = await Reflect.apply(originalQuery, this, ["SELECT pg_catalog.current_setting('synchronous_commit') AS setting,pg_catalog.pg_backend_pid() AS pid"])
|
|
assert.equal(Number(observation.rows[0].pid), pid)
|
|
assert.equal(observation.rows[0].setting, "on", "journal COMMIT must override the inherited off SESSION default")
|
|
commitSettings.push(observation.rows[0].setting)
|
|
return Reflect.apply(originalQuery, this, args)
|
|
})()
|
|
} as typeof Client.prototype.query
|
|
patched = true
|
|
const prefix = "durability-" + randomUUID(), bindings = [
|
|
fixtureBinding(prefix + ":A", prefix + ":B", { controlGeneration }),
|
|
fixtureBinding(prefix + ":C", prefix + ":D", { controlGeneration }),
|
|
fixtureBinding(prefix + ":E", prefix + ":F", { controlGeneration }),
|
|
]
|
|
const noSend = new Set<string>()
|
|
const journalFor = (expected: BandwidthBinding) => {
|
|
let active: { connection: ProbeStorageConnection; scope: BandwidthScope } | undefined
|
|
return createBandwidthAdmissionSqlJournal({ now: Date.now,
|
|
connect: async current => {
|
|
assert(!active); const connection = await connect(current); held.add(connection); active = { connection, scope: current }
|
|
return { query: (text, values, options) => connection.query(text, values, options), release(unsafe) { active = undefined; held.delete(connection); connection.release(unsafe) } }
|
|
},
|
|
authorize: async (binding, current) => { assert(Date.now() < current.deadlineAt); current.signal?.throwIfAborted(); assert.deepEqual(binding, expected); assert.equal(binding.controlGeneration, controlGeneration) },
|
|
verifyEvidence: async (transition, binding, evidence) => {
|
|
assert.deepEqual(binding, expected)
|
|
if (transition === "complete") assert.deepEqual(evidence, { terminalProof: completionProof(binding) })
|
|
else if (transition === "release-before-dispatch") { assert(noSend.has(binding.attemptId)); assert.equal((evidence as { proof?: string }).proof, "private-no-send") }
|
|
else assert.equal(evidence, undefined)
|
|
},
|
|
eventProof: async event => { assert(active); return eventProof(event, active.connection, active.scope) },
|
|
})
|
|
}
|
|
const completed = journalFor(bindings[0])
|
|
await completed.reserve(bindings[0], scope()); await completed.arm(bindings[0], scope())
|
|
await completed.complete(bindings[0], { terminalProof: completionProof(bindings[0]) }, scope())
|
|
for (const [index, from] of [[1, "reserved"], [2, "armed"]] as const) {
|
|
const binding = bindings[index], journal = journalFor(binding); noSend.add(binding.attemptId)
|
|
await journal.reserve(binding, scope()); if (from === "armed") await journal.arm(binding, scope())
|
|
await journal.releaseBeforeDispatch(binding, { from, proof: "private-no-send" }, scope())
|
|
}
|
|
assert.equal(commitSettings.length, 8)
|
|
const ids = bindings.map(binding => binding.attemptId)
|
|
const attempts = (await owner.query("SELECT attempt_id::text,state,resolution,terminal_proof FROM mmapp_control.bandwidth_attempts WHERE attempt_id=ANY($1::uuid[])", [ids])).rows
|
|
assert.equal(attempts.length, 3)
|
|
for (const binding of bindings) {
|
|
const row = attempts.find(attempt => attempt.attempt_id === binding.attemptId); assert(row); assert.equal(row.state, "released")
|
|
assert.equal(row.resolution, binding === bindings[0] ? "remote_completion" : "proven_not_dispatched")
|
|
assert.equal(row.terminal_proof, binding === bindings[0] ? completionProof(binding) : null)
|
|
}
|
|
assert.equal(Number((await owner.query("SELECT count(*) AS n FROM mmapp_control.bandwidth_node_occupancy WHERE attempt_id=ANY($1::uuid[])", [ids])).rows[0].n), 0)
|
|
const events = (await owner.query("SELECT ack_id::text,attempt_id::text,transition,old_state,new_state,binding_proof,control_generation,evidence_proof FROM mmapp_control.bandwidth_attempt_events WHERE attempt_id=ANY($1::uuid[])", [ids])).rows
|
|
assert.equal(events.length, 8)
|
|
const after = await acquireFour(), afterPids = new Set<number>()
|
|
for (const lease of after) {
|
|
const row = (await lease.query("SELECT pg_catalog.pg_backend_pid() AS pid,pg_catalog.current_setting('synchronous_commit') AS setting")).rows[0]
|
|
afterPids.add(Number(row.pid)); assert.equal(row.setting, "off", "SET LOCAL must not change the reusable SESSION default")
|
|
}
|
|
assert.deepEqual(afterPids, pids)
|
|
for (const event of events) {
|
|
const material = { ackId: event.ack_id, attemptId: event.attempt_id, transition: event.transition, oldState: event.old_state, newState: event.new_state,
|
|
bindingProof: event.binding_proof, controlGeneration: event.control_generation, terminalProof: event.transition === "complete" ? completionProof(bindings[0]) : null }
|
|
assert.equal(event.evidence_proof, await eventProof(material, after[0], scope()))
|
|
}
|
|
for (const lease of after) { await lease.query("SET SESSION synchronous_commit=on"); release(lease) }
|
|
allDefaultsRestored = true
|
|
return { checks: 5, physicalRuntimeSessions: pids.size, actualCommitObservations: commitSettings.length, allCommitSettings: "on", subsequentSessionDefaults: "off", persistedAttempts: attempts.length, persistedEvents: events.length, remainingOccupancy: 0, syntheticPrivateEvidence: true, realNativeCalls: 0 }
|
|
} finally {
|
|
if (patched) Client.prototype.query = originalQuery
|
|
// Also repair the test's SESSION defaults when an assertion fails. Acquire
|
|
// the entire pool, not four sequential checkouts of the same backend.
|
|
if (!allDefaultsRestored) {
|
|
for (const lease of [...held]) { try { await lease.query("SET SESSION synchronous_commit=on") } catch { /* Retired leases are destroyed by their source. */ } finally { held.delete(lease); lease.release(true) } }
|
|
try {
|
|
const leases = await acquireFour()
|
|
for (const lease of leases) { try { await lease.query("SET SESSION synchronous_commit=on") } finally { release(lease) } }
|
|
} finally { for (const lease of [...held]) { held.delete(lease); lease.release(true) } }
|
|
}
|
|
}
|
|
}
|