Files
MikrotikManager/backend/src/services/bandwidth-native-dispatch.ts
T

108 lines
6.6 KiB
TypeScript

/** Internal committed-permit scheduling only. A fixed server-owned gate supplies
* actual registry serialization and original-authority checks on ONE lease.
* This module does not mint permits, register nodes or configure a default gate. */
import { ClientRequest } from "node:http"
import type { Socket } from "node:net"
import { TLSSocket } from "node:tls"
import { performance } from "node:perf_hooks"
import type { BandwidthScope } from "./bandwidth-admission.js"
export interface BandwidthNativeDispatchLease {
/** Same-lease shared registry lock and final original/source/peer/owner checks. */
verify(scope: Readonly<BandwidthScope>): Promise<void>
/** Physically destroy the owned read-only lease; never return it healthy. */
close(): void
}
export interface BandwidthNativeDispatchGate {
acquire(scope: Readonly<BandwidthScope>): Promise<BandwidthNativeDispatchLease>
}
export type BandwidthNativeRequestBinder = (request: ClientRequest, sendBytesOnce: () => void) => void
export class BandwidthNativeDispatchError extends Error {
readonly automaticReplay = false
constructor(readonly code: "REFUSED" | "OUTCOME_UNKNOWN") { super("Bandwidth native dispatch " + code) }
}
/** Called only by the private committed-permit dispatcher. start synchronously
* constructs rosPost and binds its exact request BEFORE write/end. A caller
* callback, evidence JSON or a queued Agent request cannot acknowledge handoff. */
export async function dispatchBandwidthNativeRequest<T>(gate: Readonly<BandwidthNativeDispatchGate>, original: Readonly<BandwidthScope>, originalMonotonicEnd: number,
assertOriginalPermit: () => void, start: (bindRequest: BandwidthNativeRequestBinder) => Promise<T>): Promise<T> {
const entered = Date.now(), enteredMono = performance.now(), signal = original.signal
const deadlineAt = Math.min(original.deadlineAt, entered + 5000)
const monotonicEnd = Math.min(originalMonotonicEnd, enteredMono + Math.max(0, deadlineAt - entered))
const controller = new AbortController(), scope = Object.freeze({ deadlineAt, signal: controller.signal })
let active = true, invoked = false, lease: Readonly<BandwidthNativeDispatchLease> | undefined, request: ClientRequest | undefined
let rejectStopped!: (error: BandwidthNativeDispatchError) => void, rejectHandoff: ((error: BandwidthNativeDispatchError) => void) | undefined
const error = () => new BandwidthNativeDispatchError(invoked ? "OUTCOME_UNKNOWN" : "REFUSED")
const closeLease = (strict = false) => {
const current = lease; lease = undefined
if (!current) return
try { current.close() }
catch { try { current.close() } catch { /* Retry physical destruction, never healthy pool return. */ } if (strict) throw error() }
}
const stop = () => { active = false; controller.abort(); request?.destroy(error()); closeLease(); const failure = error(); rejectHandoff?.(failure); rejectStopped(failure) }
const live = () => { if (!active || signal?.aborted || Date.now() >= deadlineAt || performance.now() >= monotonicEnd) throw error() }
const stopped = new Promise<never>((_resolve, reject) => { rejectStopped = reject })
const timer = setTimeout(stop, Math.max(1, monotonicEnd - performance.now()))
signal?.addEventListener("abort", stop, { once: true })
let cleanupRequest = () => {}
const run = async () => {
live(); assertOriginalPermit()
const acquired = await gate.acquire(scope)
if (!active) { try { acquired.close() } catch { try { acquired.close() } catch { /* Late lease must be destroyed. */ } } throw error() }
const ownedLease = Object.freeze({ verify: acquired.verify.bind(acquired), close: acquired.close.bind(acquired) })
lease = ownedLease; live(); assertOriginalPermit()
await ownedLease.verify(scope); live(); assertOriginalPermit()
let acknowledge!: () => void
const handoff = new Promise<void>((resolve, reject) => { acknowledge = resolve; rejectHandoff = reject })
void handoff.catch(() => {})
const bindRequest: BandwidthNativeRequestBinder = (created, sendBytesOnce) => {
if (!(created instanceof ClientRequest)) throw error()
if (!active || request) { created.destroy(error()); throw error() }
request = created
let socketHandled = false, sendStarted = false, cleanupReady = () => {}
const finish = () => { try { live(); if (!sendStarted || !created.socket || created.destroyed) throw error(); acknowledge() } catch { rejectHandoff?.(error()) } }
const failed = () => rejectHandoff?.(error())
const ready = () => {
cleanupReady()
void (async () => {
live(); assertOriginalPermit()
// A queued request may have waited while the original actor, source
// or mapping was revoked. Recheck on THIS lease after socket readiness.
await ownedLease.verify(scope); live(); assertOriginalPermit()
sendStarted = true
sendBytesOnce() // No await between final authority and header/body flush.
})().catch(() => { rejectHandoff?.(error()); created.destroy(error()) })
}
const socket = (current: Socket) => {
if (socketHandled) return
socketHandled = true
if (current instanceof TLSSocket && !current.getPeerFinished()) {
current.once("secureConnect", ready); cleanupReady = () => current.removeListener("secureConnect", ready)
} else if (current.connecting) {
current.once("connect", ready); cleanupReady = () => current.removeListener("connect", ready)
} else ready()
}
created.once("finish", finish); created.once("error", failed); created.once("close", failed)
created.once("socket", socket)
cleanupRequest = () => { cleanupReady(); created.removeListener("socket", socket); created.removeListener("finish", finish); created.removeListener("error", failed); created.removeListener("close", failed) }
if (created.socket) socket(created.socket)
}
// Request construction does not send bytes. The fixed private binder waits
// through Agent queue/DNS/TLS, revalidates, then flushes under the same gate.
invoked = true
const response = start(bindRequest)
void response.catch(() => {})
if (!request) throw error()
await handoff; live()
closeLease(true)
return { response }
}
try {
const completed = await Promise.race([run(), stopped])
// Do not await response here: retire the SHORT SQL lifetime immediately.
// rosPost/admission retain the original response timeout, abort and parser.
return completed.response
} catch { request?.destroy(error()); throw error() }
finally { active = false; clearTimeout(timer); signal?.removeEventListener("abort", stop); controller.abort(); cleanupRequest(); closeLease() }
}