Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

feat(control-api): add retained authorize body admission owner

Alfredo Lopez97356d77eb0b
diff --git a/control-api/package-lock.json b/control-api/package-lock.json
index 8cd4a6784..fab665aa2 100644
--- a/control-api/package-lock.json
+++ b/control-api/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-control-api",
- "version": "0.1.703",
+ "version": "0.1.704",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-control-api",
- "version": "0.1.703",
+ "version": "0.1.704",
"dependencies": {
"@clerum/display-field": "file:../packages/display-field",
"@clerum/grok-provider-attempt-contract": "file:../packages/grok-provider-attempt-contract",
diff --git a/control-api/package.json b/control-api/package.json
index 67e4cf3ee..04b010bb3 100644
--- a/control-api/package.json
+++ b/control-api/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-control-api",
- "version": "0.1.703",
+ "version": "0.1.704",
"description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets",
"main": "dist/main.js",
"engines": {
diff --git a/control-api/src/middleware/llmProviderAttemptBodyAdmission.ts b/control-api/src/middleware/llmProviderAttemptBodyAdmission.ts
new file mode 100644
index 000000000..a6b819f89
--- /dev/null
+++ b/control-api/src/middleware/llmProviderAttemptBodyAdmission.ts
@@ -0,0 +1,240 @@
+import type { Request, RequestHandler, Response } from 'express'
+import { type Logger, rootLogger } from '../observability/logger.js'
+
+export type AuthorizeBodyAdmissionPolicy = Readonly<{
+ maxInFlight: number
+ readDeadlineMs: number
+ workDeadlineMs: number
+ closeGraceMs: number
+}>
+
+export class AuthorizeWorkInterrupted extends Error {
+ constructor(readonly code: 'authorize_timeout' | 'authorize_aborted') {
+ super(code)
+ this.name = 'AuthorizeWorkInterrupted'
+ }
+}
+
+type ParserError = {
+ type?: unknown
+ status?: unknown
+ body?: unknown
+}
+
+const MAX_TIMER_DELAY_MS = 2_147_483_647
+const LOG_MODULE = 'llm-provider-attempt-body-admission'
+const log = rootLogger.child({ module: LOG_MODULE })
+
+/**
+ * Owns one full permitted authorize body from before parsing until both the
+ * parser callback and the signal-aware authorize work have unwound.
+ *
+ * The count is deliberately not based on Content-Length: chunked bodies remain
+ * accepted, framing is enforced by Node/body-parser, and every admitted
+ * request is charged the same full retained-body unit.
+ */
+export class AuthorizeBodyAdmission {
+ private inFlight = 0
+ private readonly policy: AuthorizeBodyAdmissionPolicy
+
+ constructor(policy: AuthorizeBodyAdmissionPolicy) {
+ if (!Number.isSafeInteger(policy.maxInFlight) || policy.maxInFlight <= 0) {
+ throw new TypeError('maxInFlight must be a positive safe integer')
+ }
+ for (const value of [policy.readDeadlineMs, policy.workDeadlineMs, policy.closeGraceMs]) {
+ if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_TIMER_DELAY_MS) {
+ throw new TypeError('authorize timers must be positive signed-32-bit integers')
+ }
+ }
+ this.policy = Object.freeze({
+ maxInFlight: policy.maxInFlight,
+ readDeadlineMs: policy.readDeadlineMs,
+ workDeadlineMs: policy.workDeadlineMs,
+ closeGraceMs: policy.closeGraceMs,
+ })
+ }
+
+ tryAcquire(): (() => void) | null {
+ if (this.inFlight >= this.policy.maxInFlight) return null
+ this.inFlight += 1
+ let held = true
+ return () => {
+ if (!held) return
+ held = false
+ this.inFlight -= 1
+ }
+ }
+
+ snapshot(): Readonly<{ inFlight: number }> {
+ return { inFlight: this.inFlight }
+ }
+
+ async run(
+ req: Request,
+ res: Response,
+ parser: RequestHandler,
+ work: (signal: AbortSignal) => Promise<void>
+ ): Promise<void> {
+ const release = this.tryAcquire()
+ if (!release) {
+ this.refuseBeforeRead(req, res)
+ return
+ }
+
+ try {
+ await parseToCompletion(req, res, parser, this.policy)
+ if (req.aborted || res.destroyed || res.writableEnded) return
+
+ const cancellation = new AbortController()
+ const abortDisconnected = (): void => {
+ if (!res.writableFinished) {
+ cancellation.abort(new AuthorizeWorkInterrupted('authorize_aborted'))
+ }
+ }
+ res.once('close', abortDisconnected)
+ const workTimer = setTimeout(() => {
+ cancellation.abort(new AuthorizeWorkInterrupted('authorize_timeout'))
+ }, this.policy.workDeadlineMs)
+
+ try {
+ // Work must wire this signal to real dependency termination. Its
+ // promise includes transaction unwind and producer disposal.
+ await work(cancellation.signal)
+ cancellation.signal.throwIfAborted()
+ } catch (err) {
+ if (cancellation.signal.aborted) throw cancellation.signal.reason
+ throw err
+ } finally {
+ clearTimeout(workTimer)
+ res.off('close', abortDisconnected)
+ }
+ } finally {
+ req.body = undefined
+ release()
+ }
+ }
+
+ private refuseBeforeRead(req: Request, res: Response): void {
+ const inFlight = this.inFlight
+ req.pause()
+ let stopped = false
+ let closeTimer: ReturnType<typeof setTimeout> | undefined
+ const stopRejectedBody = (): void => {
+ if (stopped) return
+ stopped = true
+ if (closeTimer !== undefined) clearTimeout(closeTimer)
+ res.off('finish', stopRejectedBody)
+ res.off('close', stopRejectedBody)
+ if (!req.destroyed) req.destroy()
+ }
+ // A blocked or pipelined peer can leave the 503 response unable to reach
+ // finish/close. The unread request body still needs a bounded stop.
+ closeTimer = setTimeout(stopRejectedBody, this.policy.closeGraceMs)
+ res.once('finish', stopRejectedBody)
+ res.once('close', stopRejectedBody)
+ res.setHeader('Connection', 'close')
+ requestLog(req).warn(
+ {
+ event: 'llm_provider_attempt_admission_refused',
+ reason: 'authorize_capacity_exceeded',
+ inFlight,
+ maxInFlight: this.policy.maxInFlight,
+ },
+ 'authorize admission refused before body read'
+ )
+ try {
+ res.status(503).json({ error: 'authorize_capacity_exceeded' })
+ } catch (err) {
+ stopRejectedBody()
+ throw err
+ }
+ }
+}
+
+function removeParserBody(err: unknown): void {
+ if (err && typeof err === 'object' && 'body' in err) {
+ delete (err as ParserError).body
+ }
+}
+
+function parserErrorRequiresConnectionClose(err: unknown): boolean {
+ const typed = err as ParserError
+ return typed?.type === 'entity.too.large' || typed?.status === 413
+}
+
+function requestLog(req: Request): Logger {
+ return req.log?.child({ module: LOG_MODULE }) ?? log
+}
+
+function parseToCompletion(
+ req: Request,
+ res: Response,
+ parser: RequestHandler,
+ policy: AuthorizeBodyAdmissionPolicy
+): Promise<void> {
+ return new Promise((resolve, reject) => {
+ let timedOut = false
+ let settled = false
+ let readStopped = false
+ let closeBackstop: ReturnType<typeof setTimeout> | undefined
+
+ const stopRead = (): void => {
+ if (readStopped) return
+ readStopped = true
+ req.destroy()
+ }
+ const stopDisconnected = (): void => {
+ if (!res.writableFinished) stopRead()
+ }
+ res.once('close', stopDisconnected)
+
+ const timer = setTimeout(() => {
+ timedOut = true
+ requestLog(req).warn(
+ {
+ event: 'llm_provider_attempt_body_refused',
+ reason: 'read_deadline',
+ closeGraceMs: policy.closeGraceMs,
+ },
+ 'authorize body read deadline exceeded'
+ )
+ // This backstop is independent of response finish. A peer that never
+ // reads the 408 must not leave the body reader charged indefinitely.
+ closeBackstop = setTimeout(stopRead, policy.closeGraceMs)
+ res.once('finish', stopRead)
+ if (res.destroyed || res.writableEnded || res.headersSent) {
+ stopRead()
+ return
+ }
+ try {
+ res.setHeader('Connection', 'close')
+ res.status(408).json({ error: 'request_timeout' })
+ } catch {
+ stopRead()
+ }
+ }, policy.readDeadlineMs)
+
+ const finish = (err?: unknown): void => {
+ removeParserBody(err)
+ if (settled) return
+ settled = true
+ clearTimeout(timer)
+ if (closeBackstop !== undefined) clearTimeout(closeBackstop)
+ res.off('finish', stopRead)
+ res.off('close', stopDisconnected)
+ if (!timedOut && err && parserErrorRequiresConnectionClose(err) && !res.headersSent) {
+ res.setHeader('Connection', 'close')
+ }
+ // Capacity remains charged until this callback proves parser unwind.
+ if (timedOut) resolve()
+ else if (err) reject(err)
+ else resolve()
+ }
+
+ try {
+ parser(req, res, finish)
+ } catch (err) {
+ finish(err)
+ }
+ })
+}
diff --git a/control-api/test/llmProviderAttemptBodyAdmission.test.ts b/control-api/test/llmProviderAttemptBodyAdmission.test.ts
new file mode 100644
index 000000000..674f8e317
--- /dev/null
+++ b/control-api/test/llmProviderAttemptBodyAdmission.test.ts
@@ -0,0 +1,631 @@
+import { describe, expect, it, vi } from 'vitest'
+import express, { type Request, type RequestHandler, type Response } from 'express'
+import { EventEmitter } from 'node:events'
+import { type Server, createServer } from 'node:http'
+import net from 'node:net'
+import {
+ AuthorizeBodyAdmission,
+ AuthorizeWorkInterrupted,
+} from '../src/middleware/llmProviderAttemptBodyAdmission.js'
+
+type FakeRequest = EventEmitter & {
+ body?: unknown
+ aborted: boolean
+ destroyed: boolean
+ pause: ReturnType<typeof vi.fn>
+ destroy: ReturnType<typeof vi.fn>
+ log?: FakeRequestLogger
+}
+
+type FakeChildLogger = {
+ warn: ReturnType<typeof vi.fn>
+}
+
+type FakeRequestLogger = {
+ child: ReturnType<typeof vi.fn>
+}
+
+type FakeResponse = EventEmitter & {
+ destroyed: boolean
+ writableEnded: boolean
+ writableFinished: boolean
+ headersSent: boolean
+ statusCode?: number
+ body?: unknown
+ setHeader: ReturnType<typeof vi.fn>
+ status: ReturnType<typeof vi.fn>
+ json: ReturnType<typeof vi.fn>
+}
+
+function fakeRequest(): FakeRequest {
+ const request = new EventEmitter() as FakeRequest
+ request.body = undefined
+ request.aborted = false
+ request.destroyed = false
+ request.pause = vi.fn()
+ request.destroy = vi.fn(() => {
+ request.destroyed = true
+ request.aborted = true
+ request.emit('close')
+ })
+ return request
+}
+
+function fakeResponse(): FakeResponse {
+ const response = new EventEmitter() as FakeResponse
+ response.destroyed = false
+ response.writableEnded = false
+ response.writableFinished = false
+ response.headersSent = false
+ response.setHeader = vi.fn()
+ response.status = vi.fn((code: number) => {
+ response.statusCode = code
+ return response
+ })
+ response.json = vi.fn((body: unknown) => {
+ response.headersSent = true
+ response.body = body
+ return response
+ })
+ return response
+}
+
+function fakeRequestLogger(): { logger: FakeRequestLogger; child: FakeChildLogger } {
+ const childLogger: FakeChildLogger = { warn: vi.fn() }
+ return {
+ logger: { child: vi.fn(() => childLogger) },
+ child: childLogger,
+ }
+}
+
+function deferred<T = void>() {
+ let resolve!: (value: T) => void
+ let reject!: (reason?: unknown) => void
+ const promise = new Promise<T>((promiseResolve, promiseReject) => {
+ resolve = promiseResolve
+ reject = promiseReject
+ })
+ return { promise, resolve, reject }
+}
+
+async function withServer(app: express.Express, run: (port: number) => Promise<void>) {
+ const server = createServer(app)
+ server.listen(0, '127.0.0.1')
+ await EventEmitter.once(server, 'listening')
+ const address = server.address()
+ if (!address || typeof address === 'string') throw new Error('server has no port')
+ try {
+ await run(address.port)
+ } finally {
+ server.closeAllConnections()
+ await new Promise<void>((resolve, reject) =>
+ server.close(error => (error ? reject(error) : resolve()))
+ )
+ }
+}
+
+function readRawResponse(
+ port: number,
+ payload: string | Buffer
+): Promise<{
+ status: number
+ headers: string
+ body: string
+}> {
+ const socket = net.connect(port)
+ const chunks: Buffer[] = []
+ const result = new Promise<{
+ status: number
+ headers: string
+ body: string
+ }>(resolve => {
+ socket.on('data', chunk => chunks.push(Buffer.from(chunk)))
+ socket.on('end', () => {
+ const text = Buffer.concat(chunks).toString('utf8')
+ const headerEnd = text.indexOf('\r\n\r\n')
+ const headers = text.slice(0, headerEnd)
+ resolve({
+ status: Number(/^HTTP\/1\.1 (\d+)/m.exec(headers)?.[1]),
+ headers,
+ body: text.slice(headerEnd + 4),
+ })
+ })
+ })
+ socket.write(payload)
+ socket.end()
+ return result
+}
+
+describe('AuthorizeBodyAdmission policy and idempotence', () => {
+ it('rejects invalid counts and timer values and freezes the accepted policy', () => {
+ const valid = { maxInFlight: 1, readDeadlineMs: 20, workDeadlineMs: 20, closeGraceMs: 5 }
+ const gate = new AuthorizeBodyAdmission(valid)
+ expect(() => {
+ ;(gate as unknown as { policy: { maxInFlight: number } }).policy.maxInFlight = 99
+ }).toThrow(TypeError)
+ const first = gate.tryAcquire()
+ expect(first).not.toBeNull()
+ expect(gate.tryAcquire()).toBeNull()
+ first?.()
+
+ expect(() => new AuthorizeBodyAdmission({ ...valid, maxInFlight: 0 })).toThrow(TypeError)
+ expect(() => new AuthorizeBodyAdmission({ ...valid, maxInFlight: 1.5 })).toThrow(TypeError)
+ for (const key of ['readDeadlineMs', 'workDeadlineMs', 'closeGraceMs'] as const) {
+ expect(() => new AuthorizeBodyAdmission({ ...valid, [key]: 0 })).toThrow(TypeError)
+ expect(() => new AuthorizeBodyAdmission({ ...valid, [key]: 2_147_483_648 })).toThrow(
+ TypeError
+ )
+ }
+ })
+
+ it('an old release cannot free the slot occupied by a newer request', () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 100,
+ workDeadlineMs: 100,
+ closeGraceMs: 10,
+ })
+ const releaseA = gate.tryAcquire()
+ expect(releaseA).not.toBeNull()
+ expect(gate.tryAcquire()).toBeNull()
+ releaseA?.()
+ const releaseB = gate.tryAcquire()
+ expect(releaseB).not.toBeNull()
+ releaseA?.()
+ expect(gate.tryAcquire()).toBeNull()
+ releaseB?.()
+ const releaseC = gate.tryAcquire()
+ expect(releaseC).not.toBeNull()
+ releaseC?.()
+ })
+
+ it('clears retained request bodies and ignores duplicate parser callbacks', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 100,
+ workDeadlineMs: 100,
+ closeGraceMs: 10,
+ })
+ const req = fakeRequest()
+ const res = fakeResponse()
+ const parser = vi.fn((_req: unknown, _res: unknown, next: (err?: unknown) => void) => {
+ _req.body = { retained: true }
+ next()
+ next(new Error('duplicate callback'))
+ })
+ const work = vi.fn(async () => undefined)
+
+ await gate.run(req as never, res as never, parser as RequestHandler, work)
+
+ expect(work).toHaveBeenCalledOnce()
+ expect(req.body).toBeUndefined()
+ expect(gate.tryAcquire()).not.toBeNull()
+ })
+})
+
+describe('AuthorizeBodyAdmission parser lifecycle', () => {
+ it.each([
+ {
+ name: 'malformed JSON',
+ error: Object.assign(new SyntaxError('malformed'), {
+ type: 'entity.parse.failed',
+ body: 'malformed-body',
+ }),
+ expectedConnectionClose: false,
+ },
+ {
+ name: 'over-deep structure',
+ error: Object.assign(new Error('too deep'), {
+ type: 'body.structure.too.deep',
+ body: 'deep-body',
+ }),
+ expectedConnectionClose: false,
+ },
+ {
+ name: 'compressed body',
+ error: Object.assign(new Error('gzip'), {
+ type: 'encoding.unsupported',
+ body: 'compressed-body',
+ }),
+ expectedConnectionClose: false,
+ },
+ {
+ name: 'payload over limit',
+ error: Object.assign(new Error('too large'), {
+ type: 'entity.too.large',
+ status: 413,
+ body: 'oversize-body',
+ }),
+ expectedConnectionClose: true,
+ },
+ ])('propagates the $name parser error after removing its raw body', async case_ => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 100,
+ workDeadlineMs: 100,
+ closeGraceMs: 10,
+ })
+ const req = fakeRequest()
+ const res = fakeResponse()
+ const parser = vi.fn((_req: unknown, _res: unknown, next: (err?: unknown) => void) => {
+ next(case_.error)
+ })
+ const work = vi.fn(async () => undefined)
+
+ await expect(gate.run(req as never, res as never, parser as RequestHandler, work)).rejects.toBe(
+ case_.error
+ )
+
+ expect(work).not.toHaveBeenCalled()
+ expect(case_.error).not.toHaveProperty('body')
+ if (case_.expectedConnectionClose) {
+ expect(res.setHeader).toHaveBeenCalledWith('Connection', 'close')
+ } else {
+ expect(res.setHeader).not.toHaveBeenCalledWith('Connection', 'close')
+ }
+ expect(gate.tryAcquire()).not.toBeNull()
+ })
+
+ it('stops a stalled read through closeGrace even when response finish never arrives', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 15,
+ workDeadlineMs: 100,
+ closeGraceMs: 5,
+ })
+ const req = fakeRequest()
+ const requestLogger = fakeRequestLogger()
+ req.log = requestLogger.logger
+ const res = fakeResponse()
+ const parser = vi.fn((request: FakeRequest, _response: FakeResponse, next: () => void) => {
+ request.once('close', next)
+ })
+ const work = vi.fn(async () => undefined)
+
+ const running = gate.run(req as never, res as never, parser as RequestHandler, work)
+ await vi.waitFor(() => expect(res.body).toEqual({ error: 'request_timeout' }))
+ await running
+
+ expect(req.destroy).toHaveBeenCalledOnce()
+ expect(res.setHeader).toHaveBeenCalledWith('Connection', 'close')
+ expect(work).not.toHaveBeenCalled()
+ expect(EventEmitter.listenerCount(res, 'close')).toBe(0)
+ expect(EventEmitter.listenerCount(res, 'finish')).toBe(0)
+ expect(gate.tryAcquire()).not.toBeNull()
+ expect(req.log?.child).toHaveBeenCalledWith({
+ module: 'llm-provider-attempt-body-admission',
+ })
+ expect(requestLogger.child.warn).toHaveBeenCalledWith(
+ expect.objectContaining({
+ event: 'llm_provider_attempt_body_refused',
+ reason: 'read_deadline',
+ closeGraceMs: 5,
+ }),
+ 'authorize body read deadline exceeded'
+ )
+ })
+
+ it('bounds a never-finishing capacity refusal without reading or starting work', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 100,
+ workDeadlineMs: 100,
+ closeGraceMs: 5,
+ })
+ const holder = gate.tryAcquire()
+ expect(holder).not.toBeNull()
+ const req = fakeRequest()
+ const requestLogger = fakeRequestLogger()
+ req.log = requestLogger.logger
+ const res = fakeResponse()
+ const parser = vi.fn()
+ const work = vi.fn(async () => undefined)
+
+ await gate.run(req as never, res as never, parser as RequestHandler, work)
+ await vi.waitFor(() => expect(req.destroy).toHaveBeenCalledOnce())
+
+ expect(req.pause).toHaveBeenCalledOnce()
+ expect(res.setHeader).toHaveBeenCalledWith('Connection', 'close')
+ expect(res.body).toEqual({ error: 'authorize_capacity_exceeded' })
+ expect(parser).not.toHaveBeenCalled()
+ expect(work).not.toHaveBeenCalled()
+ expect(EventEmitter.listenerCount(res, 'close')).toBe(0)
+ expect(EventEmitter.listenerCount(res, 'finish')).toBe(0)
+ expect(gate.tryAcquire()).toBeNull()
+ expect(req.log?.child).toHaveBeenCalledWith({
+ module: 'llm-provider-attempt-body-admission',
+ })
+ expect(requestLogger.child.warn).toHaveBeenCalledWith(
+ expect.objectContaining({
+ event: 'llm_provider_attempt_admission_refused',
+ reason: 'authorize_capacity_exceeded',
+ inFlight: 1,
+ maxInFlight: 1,
+ }),
+ 'authorize admission refused before body read'
+ )
+
+ holder?.()
+ expect(gate.tryAcquire()).not.toBeNull()
+ })
+
+ it('uses close during parsing only to stop the reader and never starts work', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 100,
+ workDeadlineMs: 100,
+ closeGraceMs: 10,
+ })
+ const req = fakeRequest()
+ const res = fakeResponse()
+ const parser = vi.fn((request: FakeRequest, _response: FakeResponse, next: () => void) => {
+ request.once('close', next)
+ })
+ const work = vi.fn(async () => undefined)
+
+ await Promise.all([
+ gate.run(req as never, res as never, parser as RequestHandler, work),
+ Promise.resolve().then(() => res.emit('close')),
+ ])
+
+ expect(req.destroy).toHaveBeenCalledOnce()
+ expect(work).not.toHaveBeenCalled()
+ expect(gate.tryAcquire()).not.toBeNull()
+ })
+})
+
+describe('AuthorizeBodyAdmission work cancellation', () => {
+ it('preserves typed authorize_timeout after real signal-aware work settles', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 100,
+ workDeadlineMs: 15,
+ closeGraceMs: 10,
+ })
+ const req = fakeRequest()
+ const res = fakeResponse()
+ const parser = vi.fn((_req: unknown, _res: unknown, next: () => void) => next())
+ const work = vi.fn(
+ (signal: AbortSignal) =>
+ new Promise<void>((_resolve, reject) => {
+ signal.addEventListener('abort', () => reject(signal.reason), { once: true })
+ })
+ )
+
+ const error = await gate
+ .run(req as never, res as never, parser as RequestHandler, work)
+ .catch(err => err)
+
+ expect(error).toBeInstanceOf(AuthorizeWorkInterrupted)
+ expect((error as AuthorizeWorkInterrupted).code).toBe('authorize_timeout')
+ expect(EventEmitter.listenerCount(res, 'close')).toBe(0)
+ expect(gate.tryAcquire()).not.toBeNull()
+ })
+
+ it('does not free a work owner on client close until signal-aware work unwinds', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 1000,
+ workDeadlineMs: 5000,
+ closeGraceMs: 10,
+ })
+ const req = fakeRequest()
+ const res = fakeResponse()
+ const parser = vi.fn((_req: unknown, _res: unknown, next: () => void) => next())
+ const workStarted = deferred()
+ const closeObserved = deferred()
+ const allowWorkUnwind = deferred()
+ const workSettled = deferred<AuthorizeWorkInterrupted>()
+ const work = vi.fn(async (signal: AbortSignal) => {
+ workStarted.resolve()
+ await new Promise<void>((_resolve, reject) => {
+ signal.addEventListener(
+ 'abort',
+ async () => {
+ closeObserved.resolve()
+ await allowWorkUnwind.promise
+ reject(signal.reason)
+ },
+ { once: true }
+ )
+ })
+ })
+
+ const running = gate
+ .run(req as never, res as never, parser as RequestHandler, signal =>
+ work(signal).catch((err: AuthorizeWorkInterrupted) => {
+ workSettled.resolve(err)
+ throw err
+ })
+ )
+ .catch(error => error)
+ await workStarted.promise
+ res.emit('close')
+ await closeObserved.promise
+
+ expect(gate.tryAcquire()).toBeNull()
+ allowWorkUnwind.resolve()
+ const error = (await Promise.all([running, workSettled.promise]))[1]
+ expect(error.code).toBe('authorize_aborted')
+ expect(req.body).toBeUndefined()
+ expect(gate.tryAcquire()).not.toBeNull()
+ })
+})
+
+describe('AuthorizeBodyAdmission HTTP fixture', () => {
+ it('preserves chunked JSON and releases after work completes', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 1000,
+ workDeadlineMs: 1000,
+ closeGraceMs: 10,
+ })
+ const parser = express.json({ limit: '1kb', inflate: false })
+ const work = vi.fn(async (req: express.Request, res: Response) => {
+ res.status(200).json({ body: req.body })
+ })
+ const app = express()
+ app.post('/test', (req, res, next) => {
+ void gate.run(req, res, parser, signal => work(req, res, signal)).catch(next)
+ })
+
+ await withServer(app, async port => {
+ const body = JSON.stringify({ chunked: true })
+ const response = await readRawResponse(
+ port,
+ 'POST /test HTTP/1.1\r\n' +
+ 'Host: localhost\r\n' +
+ 'Content-Type: application/json\r\n' +
+ 'Transfer-Encoding: chunked\r\n\r\n' +
+ `${body.length.toString(16)}\r\n${body}\r\n0\r\n\r\n`
+ )
+ expect(response.status).toBe(200)
+ expect(JSON.parse(response.body)).toEqual({ body: { chunked: true } })
+ })
+
+ expect(work).toHaveBeenCalledOnce()
+ expect(gate.tryAcquire()).not.toBeNull()
+ })
+
+ it('refuses an over-cap request before parsing and keeps a disconnected work owner charged', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 1000,
+ workDeadlineMs: 5000,
+ closeGraceMs: 10,
+ })
+ const parser = express.json({ limit: '1kb', inflate: false })
+ const workStarted = deferred()
+ const closeObserved = deferred()
+ const allowWorkUnwind = deferred()
+ const workSettled = deferred<AuthorizeWorkInterrupted>()
+ let mode: 'hold' | 'success' = 'hold'
+ const work = vi.fn(async (req: express.Request, res: Response, signal: AbortSignal) => {
+ if (mode === 'success') {
+ res.status(200).json({ ok: true })
+ return
+ }
+ workStarted.resolve()
+ await new Promise<void>((_resolve, reject) => {
+ signal.addEventListener(
+ 'abort',
+ async () => {
+ closeObserved.resolve()
+ await allowWorkUnwind.promise
+ reject(signal.reason)
+ },
+ { once: true }
+ )
+ })
+ })
+ const app = express()
+ app.post('/test', (req, res, next) => {
+ void gate
+ .run(req, res, parser, signal =>
+ work(req, res, signal).catch((err: AuthorizeWorkInterrupted) => {
+ workSettled.resolve(err)
+ throw err
+ })
+ )
+ .catch(next)
+ })
+
+ await withServer(app, async port => {
+ const firstBody = JSON.stringify({ held: true })
+ const first = net.connect(port)
+ first.write(
+ 'POST /test HTTP/1.1\r\n' +
+ 'Host: localhost\r\n' +
+ 'Content-Type: application/json\r\n' +
+ `Content-Length: ${Buffer.byteLength(firstBody)}\r\n\r\n${firstBody}`
+ )
+ await workStarted.promise
+
+ const refused = await readRawResponse(
+ port,
+ 'POST /test HTTP/1.1\r\n' +
+ 'Host: localhost\r\n' +
+ 'Content-Type: application/json\r\n' +
+ 'Content-Length: 2\r\n\r\n{}'
+ )
+ expect(refused.status).toBe(503)
+ expect(JSON.parse(refused.body)).toEqual({ error: 'authorize_capacity_exceeded' })
+ expect(refused.headers.toLowerCase()).toContain('connection: close')
+ expect(work).toHaveBeenCalledOnce()
+
+ first.destroy()
+ await closeObserved.promise
+ const stillHeld = await readRawResponse(
+ port,
+ 'POST /test HTTP/1.1\r\n' +
+ 'Host: localhost\r\n' +
+ 'Content-Type: application/json\r\n' +
+ 'Content-Length: 2\r\n\r\n{}'
+ )
+ expect(stillHeld.status).toBe(503)
+
+ allowWorkUnwind.resolve()
+ const settled = await workSettled.promise
+ expect(settled.code).toBe('authorize_aborted')
+ mode = 'success'
+
+ const recovered = await readRawResponse(
+ port,
+ 'POST /test HTTP/1.1\r\n' +
+ 'Host: localhost\r\n' +
+ 'Content-Type: application/json\r\n' +
+ 'Content-Length: 2\r\n\r\n{}'
+ )
+ expect(recovered.status).toBe(200)
+ expect(JSON.parse(recovered.body)).toEqual({ ok: true })
+ })
+ })
+
+ it('releases only after the real body-parser callback follows a destroyed stalled request', async () => {
+ const gate = new AuthorizeBodyAdmission({
+ maxInFlight: 1,
+ readDeadlineMs: 5000,
+ workDeadlineMs: 1000,
+ closeGraceMs: 10,
+ })
+ const parser = express.json({ limit: '1kb', inflate: false })
+ const parserStarted = deferred()
+ const wrappedParser: RequestHandler = (req, res, next) => {
+ parserStarted.resolve()
+ parser(req, res, next)
+ }
+ const work = vi.fn(async (_req: express.Request, res: Response) => {
+ res.status(200).json({ ok: true })
+ })
+ const app = express()
+ app.post('/test', (req, res, next) => {
+ void gate.run(req, res, wrappedParser, signal => work(req, res, signal)).catch(next)
+ })
+
+ await withServer(app, async port => {
+ const stalled = net.connect(port)
+ stalled.write(
+ 'POST /test HTTP/1.1\r\n' +
+ 'Host: localhost\r\n' +
+ 'Content-Type: application/json\r\n' +
+ 'Content-Length: 100\r\n\r\n{"partial":'
+ )
+ await parserStarted.promise
+ expect(gate.snapshot().inFlight).toBe(1)
+ stalled.destroy()
+
+ await vi.waitFor(() => expect(gate.snapshot().inFlight).toBe(0))
+ const recovered = await readRawResponse(
+ port,
+ 'POST /test HTTP/1.1\r\n' +
+ 'Host: localhost\r\n' +
+ 'Content-Type: application/json\r\n' +
+ 'Content-Length: 2\r\n\r\n{}'
+ )
+ expect(recovered.status).toBe(200)
+ expect(JSON.parse(recovered.body)).toEqual({ ok: true })
+ })
+
+ expect(work).toHaveBeenCalledOnce()
+ })
+})