108 lines
6.6 KiB
TypeScript
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() }
|
|
}
|