85 lines
3.7 KiB
TypeScript
85 lines
3.7 KiB
TypeScript
/** Process-local serialization only; this does not exclude another replica. */
|
|
const btestNodeLocks = new Map<number, Promise<void>>()
|
|
const MAX_TICKETS = 1024
|
|
let liveTickets = 0
|
|
|
|
export interface BtestNodeLockOptions { signal?: AbortSignal; deadlineAt?: number }
|
|
export class BtestNodeLockError extends Error {
|
|
constructor(readonly code: "BTEST_NODE_LOCK_INVALID_INPUT" | "BTEST_NODE_LOCK_QUEUE_FULL" | "BTEST_NODE_LOCK_DEADLINE_EXPIRED") { super(code) }
|
|
}
|
|
function check(options: BtestNodeLockOptions): void {
|
|
options.signal?.throwIfAborted()
|
|
if (options.deadlineAt !== undefined && Date.now() >= options.deadlineAt) throw new BtestNodeLockError("BTEST_NODE_LOCK_DEADLINE_EXPIRED")
|
|
}
|
|
function waitFor(predecessor: Promise<void>, options: BtestNodeLockOptions): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
let settled = false
|
|
let timer: ReturnType<typeof setTimeout> | undefined
|
|
const finish = (error?: unknown, failed = false) => {
|
|
if (settled) return
|
|
settled = true
|
|
if (timer) clearTimeout(timer)
|
|
options.signal?.removeEventListener("abort", aborted)
|
|
if (failed) reject(error)
|
|
else resolve()
|
|
}
|
|
const aborted = () => finish(options.signal!.reason, true)
|
|
const expiry = () => {
|
|
if (settled || options.deadlineAt === undefined) return
|
|
const remaining = options.deadlineAt - Date.now()
|
|
if (remaining <= 0) finish(new BtestNodeLockError("BTEST_NODE_LOCK_DEADLINE_EXPIRED"), true)
|
|
else timer = setTimeout(expiry, Math.min(remaining, 2147483647))
|
|
}
|
|
options.signal?.addEventListener("abort", aborted, { once: true })
|
|
if (options.signal?.aborted) aborted()
|
|
expiry()
|
|
void predecessor.then(() => finish(), error => finish(error, true))
|
|
})
|
|
}
|
|
|
|
export async function withBtestNodeLocks<T>(nodeIds: number[], fn: () => Promise<T>, options: BtestNodeLockOptions = {}): Promise<T> {
|
|
if (!Array.isArray(nodeIds) || nodeIds.length > MAX_TICKETS || Array.from(nodeIds).some(id => !Number.isSafeInteger(id) || id <= 0)) throw new BtestNodeLockError("BTEST_NODE_LOCK_INVALID_INPUT")
|
|
if (options.deadlineAt !== undefined && (!Number.isSafeInteger(options.deadlineAt) || options.deadlineAt < 0)) throw new BtestNodeLockError("BTEST_NODE_LOCK_INVALID_INPUT")
|
|
const scope = { signal: options.signal, deadlineAt: options.deadlineAt }
|
|
const ids = [...new Set(nodeIds)].sort((a, b) => a - b)
|
|
check(scope)
|
|
// Reserve the entire scope before enqueueing anything, including partial pairs.
|
|
if (liveTickets + ids.length > MAX_TICKETS) throw new BtestNodeLockError("BTEST_NODE_LOCK_QUEUE_FULL")
|
|
liveTickets += ids.length
|
|
let registered = 0
|
|
const releases: Array<() => void> = []
|
|
try {
|
|
for (const id of ids) {
|
|
check(scope)
|
|
const predecessor = btestNodeLocks.get(id) ?? Promise.resolve()
|
|
let resolveCurrent!: () => void
|
|
const current = new Promise<void>(resolve => { resolveCurrent = resolve })
|
|
btestNodeLocks.set(id, current)
|
|
registered++
|
|
let released = false
|
|
const release = () => {
|
|
if (released) return
|
|
released = true
|
|
if (btestNodeLocks.get(id) === current) btestNodeLocks.delete(id)
|
|
liveTickets--
|
|
resolveCurrent()
|
|
}
|
|
try {
|
|
await waitFor(predecessor, scope)
|
|
check(scope)
|
|
releases.push(release)
|
|
} catch (error) {
|
|
// Keep a cancelled ticket behind its predecessor; never release another holder.
|
|
void predecessor.then(release, release)
|
|
throw error
|
|
}
|
|
}
|
|
check(scope)
|
|
// Running callbacks retain ownership until settlement, including after abort.
|
|
return await fn()
|
|
} finally {
|
|
liveTickets -= ids.length - registered
|
|
for (let index = releases.length - 1; index >= 0; index--) releases[index]()
|
|
}
|
|
}
|