Files
MikrotikManager/backend/src/services/btest-node-locks.ts
T

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]()
}
}