Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
test(e2e): reserve shared DNS ports across transports
Alfredo Lopez764ca0475697
diff --git a/scripts/tests/wrc-egress-dns-proxy.test.cjs b/scripts/tests/wrc-egress-dns-proxy.test.cjsindex b89bb7664..9d1ce73e0 100644--- a/scripts/tests/wrc-egress-dns-proxy.test.cjs+++ b/scripts/tests/wrc-egress-dns-proxy.test.cjs@@ -12,6 +12,8 @@ const {question,dnsResponse,tcpFrame,+ listenDnsPair,+ closeDnsListeners,} = require('../../tests/e2e/fixtures/wrc-egress-dns-proxy/server.cjs')const targets = [@@ -65,25 +67,52 @@ async function exchangeTcp(port, message) {}}+async function tcpListener(t, port = 0) {+ const server = net.createServer()+ server.listen(port, '127.0.0.1')+ await once(server, 'listening', { signal: AbortSignal.timeout(2000) })+ t.after(() => new Promise(resolve => server.close(() => resolve())))+ return server+}++async function occupiedDnsTransport(t, transport) {+ const listeners = await listenDnsPair(+ () => ({ udp: dgram.createSocket('udp4'), tcp: net.createServer() }),+ 0,+ '127.0.0.1'+ )+ t.after(() => closeDnsListeners(listeners))+ if (transport === 'UDP') {+ await new Promise(resolve => listeners.tcp.close(() => resolve()))+ return listeners.udp+ }+ await new Promise(resolve => listeners.udp.close(resolve))+ return listeners.tcp+}+async function fixture(t, configuredTargets = targets) {- const upstream = await udpClient(t)- const upstreamPort = upstream.address().portconst respond = message => dnsResponse(message, question(message), 3, '203.0.113.7', 20)- upstream.on('message', (message, rinfo) =>- upstream.send(respond(message), rinfo.port, rinfo.address)+ const upstream = await listenDnsPair(+ () => {+ const udp = dgram.createSocket('udp4')+ udp.on('message', (message, rinfo) => udp.send(respond(message), rinfo.port, rinfo.address))+ const tcp = net.createServer(socket => {+ let pending = Buffer.alloc(0)+ socket.on('data', chunk => {+ pending = Buffer.concat([pending, chunk])+ if (pending.length >= 2 && pending.length >= pending.readUInt16BE(0) + 2) {+ socket.end(tcpFrame(respond(pending.subarray(2, pending.readUInt16BE(0) + 2))))+ }+ })+ })+ return { udp, tcp }+ },+ 0,+ '127.0.0.1')- const tcpUpstream = net.createServer(socket => {- let pending = Buffer.alloc(0)- socket.on('data', chunk => {- pending = Buffer.concat([pending, chunk])- if (pending.length >= 2 && pending.length >= pending.readUInt16BE(0) + 2) {- socket.end(tcpFrame(respond(pending.subarray(2, pending.readUInt16BE(0) + 2))))- }- })- })- tcpUpstream.listen(upstreamPort, '127.0.0.1')- await once(tcpUpstream, 'listening')- t.after(() => new Promise(resolve => tcpUpstream.close(resolve)))+ t.after(() => closeDnsListeners(upstream))+ const upstreamPort = upstream.udp.address().port+ assert.equal(upstream.tcp.address().port, upstreamPort)const proxy = createDnsProxy({targets: configuredTargets,upstream: '127.0.0.1',@@ -109,6 +138,218 @@ async function fixture(t, configuredTargets = targets) {return { proxy, ports, control }}+test(+ 'ephemeral DNS binding recovers from a real UDP collision and preserves runtime faults',+ { timeout: 5000 },+ async t => {+ const occupied = await occupiedDnsTransport(t, 'UDP')+ const occupiedPort = occupied.address().port+ const dnsListeners = []+ const dnsDatagrams = []+ const nativeCreateSocket = dgram.createSocket+ t.mock.method(dgram, 'createSocket', function (...args) {+ const socket = nativeCreateSocket.apply(this, args)+ if (dnsDatagrams.length < 2) dnsDatagrams.push(socket)+ return socket+ })+ const nativeListen = net.Server.prototype.listen+ // Control only the first OS candidate, not the sockets or DNS exchange.+ // The already-bound UDP socket makes the opposite-transport collision real.+ t.mock.method(net.Server.prototype, 'listen', function (port, ...args) {+ if (port === 0 && dnsListeners.length < 2) {+ dnsListeners.push(this)+ if (dnsListeners.length === 1) port = occupiedPort+ }+ return nativeListen.call(this, port, ...args)+ })+ const proxy = createDnsProxy({+ targets,+ upstream: '127.0.0.1',+ listenHost: '127.0.0.1',+ dnsPort: 0,+ controlPort: 0,+ ttlSeconds: 10,+ })+ t.after(() => proxy.close())+ const ports = await proxy.start()+ assert.equal(dnsListeners.length, 2)+ assert.equal(dnsListeners[0].listening, false, 'the failed TCP reservation is released')+ assert.equal(dnsListeners[0].address(), null)+ assert.throws(() => dnsDatagrams[0].address(), { code: 'ERR_SOCKET_DGRAM_NOT_RUNNING' })+ assert.equal(dnsListeners[1].address().port, ports.dnsPort)+ assert.equal(dnsDatagrams[1].address().port, ports.dnsPort)+ assert.notEqual(ports.dnsPort, occupiedPort)+ assert.equal(proxy.snapshot().fault, null, 'a recovered bind collision is not a runtime fault')+ const client = await udpClient(t)+ const wire = query(targets[0].fqdn, 201)+ const expected = dnsResponse(wire, question(wire), 0, targets[0].ip, 10)+ assert.deepEqual(await exchangeUdp(client, ports.dnsPort, wire), expected)+ assert.deepEqual(await exchangeTcp(ports.dnsPort, wire), expected)+ assert.equal(proxy.snapshot().counts.ok, 2)+ // A post-start socket error still invalidates fixture evidence.+ for (const listener of [dnsListeners[1], dnsDatagrams[1]]) {+ listener.emit('error', new Error('test runtime DNS socket error'))+ assert.equal(proxy.snapshot().fault, 'DNS_SOCKET_FAILED')+ assert.equal(proxy.snapshot().counts.ok, 2)+ }+ }+)++test(+ 'ephemeral opposite-transport collisions stop after eight attempts and release every pair',+ { timeout: 5000 },+ async t => {+ const occupied = await occupiedDnsTransport(t, 'UDP')+ const occupiedPort = occupied.address().port+ const attempts = []+ await assert.rejects(+ listenDnsPair(+ () => {+ const udp = dgram.createSocket('udp4')+ const tcp = net.createServer()+ const nativeListen = tcp.listen.bind(tcp)+ tcp.listen = (port, ...args) => nativeListen(port === 0 ? occupiedPort : port, ...args)+ attempts.push({ udp, tcp })+ // Independent cleanup also keeps a broken cleanup implementation+ // from leaving this negative test's real sockets alive.+ t.after(async () => {+ await new Promise(resolve => tcp.close(() => resolve()))+ try {+ udp.close()+ } catch (error) {+ assert.equal(error.code, 'ERR_SOCKET_DGRAM_NOT_RUNNING')+ }+ })+ return { udp, tcp }+ },+ 0,+ '127.0.0.1'+ ),+ { code: 'EADDRINUSE', port: occupiedPort }+ )+ assert.equal(attempts.length, 8)+ for (const { udp, tcp } of attempts) {+ assert.equal(tcp.listening, false)+ assert.equal(tcp.address(), null)+ assert.throws(() => udp.address(), { code: 'ERR_SOCKET_DGRAM_NOT_RUNNING' })+ }+ assert.equal(occupied.address().port, occupiedPort)+ await tcpListener(t, occupiedPort)+ }+)++test(+ 'failed DNS startup releases TCP clients accepted before an opposite-transport collision',+ { timeout: 5000 },+ async t => {+ const occupied = await occupiedDnsTransport(t, 'UDP')+ const occupiedPort = occupied.address().port+ let listeners+ let client+ let accepted+ t.after(async () => {+ client?.destroy()+ accepted?.destroy()+ if (listeners) await closeDnsListeners(listeners)+ })+ await assert.rejects(+ listenDnsPair(+ () => {+ const udp = dgram.createSocket('udp4')+ const tcp = net.createServer(socket => {+ accepted = socket+ })+ const nativeBind = udp.bind.bind(udp)+ // Delay only the bind until a real TCP client has been accepted;+ // the subsequent UDP bind still fails against the occupied socket.+ udp.bind = (port, host) => {+ const connected = once(tcp, 'connection')+ client = net.createConnection({ port, host })+ client.on('error', error => assert.equal(error.code, 'ECONNRESET'))+ connected.then(() => nativeBind(port, host))+ return udp+ }+ listeners = { udp, tcp }+ return listeners+ },+ occupiedPort,+ '127.0.0.1'+ ),+ { code: 'EADDRINUSE', port: occupiedPort }+ )+ assert.equal(accepted.destroyed, true)+ assert.equal(listeners.tcp.address(), null)+ assert.throws(() => listeners.udp.address(), { code: 'ERR_SOCKET_DGRAM_NOT_RUNNING' })+ assert.equal(occupied.address().port, occupiedPort)+ }+)++test(+ 'an ephemeral TCP allocation failure does not retry as an opposite-transport collision',+ { timeout: 5000 },+ async t => {+ const occupied = await tcpListener(t)+ const occupiedPort = occupied.address().port+ const attempts = []+ await assert.rejects(+ listenDnsPair(+ () => {+ const udp = dgram.createSocket('udp4')+ const tcp = net.createServer()+ const nativeListen = tcp.listen.bind(tcp)+ tcp.listen = (port, ...args) => nativeListen(port === 0 ? occupiedPort : port, ...args)+ attempts.push({ udp, tcp })+ return { udp, tcp }+ },+ 0,+ '127.0.0.1'+ ),+ { code: 'EADDRINUSE', port: occupiedPort }+ )+ assert.equal(attempts.length, 1)+ assert.equal(attempts[0].tcp.address(), null)+ assert.throws(() => attempts[0].udp.address(), { code: 'ERR_SOCKET_DGRAM_NOT_RUNNING' })+ assert.equal(occupied.address().port, occupiedPort)+ }+)++for (const transport of ['UDP', 'TCP']) {+ test(+ `a fixed DNS port occupied by ${transport} fails once without changing the requested port`,+ { timeout: 5000 },+ async t => {+ const occupied = await occupiedDnsTransport(t, transport)+ const occupiedPort = occupied.address().port+ const nativeListen = net.Server.prototype.listen+ let attempts = 0+ t.mock.method(net.Server.prototype, 'listen', function (port, ...args) {+ if (port === occupiedPort) attempts+++ return nativeListen.call(this, port, ...args)+ })+ const proxy = createDnsProxy({+ targets,+ upstream: '127.0.0.1',+ listenHost: '127.0.0.1',+ dnsPort: occupiedPort,+ controlPort: 0,+ })+ t.after(() => proxy.close())+ await assert.rejects(proxy.start(), { code: 'EADDRINUSE', port: occupiedPort })+ assert.equal(attempts, 1)+ assert.equal(proxy.snapshot().counts.ok, 0)+ assert.equal(occupied.address().port, occupiedPort)+ if (transport === 'UDP') await tcpListener(t, occupiedPort)+ else {+ const udp = dgram.createSocket('udp4')+ udp.bind(occupiedPort, '127.0.0.1')+ await once(udp, 'listening', { signal: AbortSignal.timeout(2000) })+ t.after(() => new Promise(resolve => udp.close(resolve)))+ }+ await assert.rejects(proxy.start(), /cannot be started twice/)+ }+ )+}+test('target configuration is explicit, bounded, unambiguous, and safe for arbitrary names', () => {const valid = { targets, upstream: '127.0.0.1' }assert.throws(() => readConfig({ TARGET_DNS: 'legacy.example.com', UPSTREAM_DNS: '127.0.0.1' }))diff --git a/tests/e2e/fixtures/package-lock.json b/tests/e2e/fixtures/package-lock.jsonindex 8c88caac1..2e21df64b 100644--- a/tests/e2e/fixtures/package-lock.json+++ b/tests/e2e/fixtures/package-lock.json@@ -1,12 +1,12 @@{"name": "@clerum/e2e-test-fixtures",- "version": "1.0.100",+ "version": "1.0.101","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "@clerum/e2e-test-fixtures",- "version": "1.0.100",+ "version": "1.0.101","dependencies": {"@kubernetes/client-node": "^1.0.0"},diff --git a/tests/e2e/fixtures/package.json b/tests/e2e/fixtures/package.jsonindex b80adc934..0523a0d75 100644--- a/tests/e2e/fixtures/package.json+++ b/tests/e2e/fixtures/package.json@@ -1,6 +1,6 @@{"name": "@clerum/e2e-test-fixtures",- "version": "1.0.100",+ "version": "1.0.101","description": "E2E test fixtures and utilities for Clerum testing","type": "module","main": "index.ts",diff --git a/tests/e2e/fixtures/wrc-egress-dns-proxy/server.cjs b/tests/e2e/fixtures/wrc-egress-dns-proxy/server.cjsindex 0ae585cee..5f3809ad4 100644--- a/tests/e2e/fixtures/wrc-egress-dns-proxy/server.cjs+++ b/tests/e2e/fixtures/wrc-egress-dns-proxy/server.cjs@@ -101,6 +101,85 @@ function increment(counts, mode) {else throw new Error('Invalid observation mode')}+const listen = (server, action) =>+ new Promise((resolve, reject) => {+ const failed = error => {+ server.removeListener('listening', ready)+ server.removeListener('error', failed)+ reject(error)+ }+ const ready = () => {+ server.removeListener('error', failed)+ resolve()+ }+ server.once('error', failed)+ server.once('listening', ready)+ try {+ action()+ } catch (error) {+ failed(error)+ }+ })++async function closeDnsListeners({ udp, tcp }) {+ await new Promise((resolve, reject) => {+ tcp.close(error => {+ if (error && error.code !== 'ERR_SERVER_NOT_RUNNING') reject(error)+ else resolve()+ })+ })+ await new Promise((resolve, reject) => {+ try {+ udp.close(resolve)+ } catch (error) {+ if (error.code === 'ERR_SOCKET_DGRAM_NOT_RUNNING') resolve()+ else reject(error)+ }+ })+}++async function listenDnsPair(createListeners, port, host) {+ // UDP and TCP have separate port allocations. Hold the TCP reservation+ // while binding UDP; only an ephemeral opposite-transport collision may+ // choose another candidate, with at most eight fully cleaned-up attempts.+ const attempts = port === 0 ? 8 : 1+ for (let attempt = 0; attempt < attempts; attempt++) {+ const listeners = createListeners()+ const { udp, tcp } = listeners+ const connections = new Set()+ const connected = socket => connections.add(socket)+ tcp.on('connection', connected)+ let firstError+ const recordError = error => {+ firstError ??= error+ }+ udp.on('error', recordError)+ tcp.on('error', recordError)+ let udpCollision = false+ try {+ await listen(tcp, () => tcp.listen(port, host))+ try {+ await listen(udp, () => udp.bind(tcp.address().port, host))+ } catch (error) {+ udpCollision = error.code === 'EADDRINUSE' && firstError === error+ throw error+ }+ if (firstError) throw firstError+ return listeners+ } catch (error) {+ // A client may arrive before the second transport binds. Closing the+ // listener alone would wait indefinitely for that accepted connection.+ for (const socket of connections) socket.destroy()+ await closeDnsListeners(listeners)+ if (!udpCollision || attempt + 1 === attempts) throw firstError ?? error+ } finally {+ udp.removeListener('error', recordError)+ tcp.removeListener('error', recordError)+ tcp.removeListener('connection', connected)+ }+ }+}+/** A real UDP/TCP DNS fixture; ephemeral loopback ports are used only by tests. */function createDnsProxy({targets,@@ -163,7 +242,8 @@ function createDnsProxy({}const counts = emptyCounts()- const udp = dgram.createSocket('udp4')+ let udp+ let tcpconst connections = new Set()const relays = new Set()let fault = null@@ -372,13 +452,7 @@ function createDnsProxy({}}- udp.on('message', (message, rinfo) =>- handle(message, { transport: 'udp', rinfo, client: `${rinfo.address}:${rinfo.port}` })- )- udp.on('error', () => {- fault = 'DNS_SOCKET_FAILED'- })- const tcp = net.createServer(socket => {+ function acceptTcp(socket) {connections.add(socket)socket.once('close', () => connections.delete(socket))socket.once('error', () => socket.destroy())@@ -402,8 +476,16 @@ function createDnsProxy({})}})- })- tcp.maxConnections = 64+ }+ function createListeners() {+ udp = dgram.createSocket('udp4')+ udp.on('message', (message, rinfo) =>+ handle(message, { transport: 'udp', rinfo, client: `${rinfo.address}:${rinfo.port}` })+ )+ tcp = net.createServer(acceptTcp)+ tcp.maxConnections = 64+ return { udp, tcp }+ }const control = http.createServer((request, response) => {const globalMode = request.url?.match(/^\/mode\/(ok|hold|servfail)$/)?.[1]const laneMode = request.url?.match(/^\/mode\/(ui|worker|canary)\/(ok|hold|servfail)$/)@@ -428,20 +510,6 @@ function createDnsProxy({control.requestTimeout = 5000control.headersTimeout = 5000- const listen = (server, action) =>- new Promise((resolve, reject) => {- const failed = error => {- server.removeListener('listening', ready)- reject(error)- }- const ready = () => {- server.removeListener('error', failed)- resolve()- }- server.once('error', failed)- server.once('listening', ready)- action()- })async function close() {if (closing) returnclosing = true@@ -449,23 +517,19 @@ function createDnsProxy({for (const relayClose of [...relays]) relayClose()for (const socket of connections) socket.destroy()control.closeAllConnections()- await Promise.all(- [tcp, control].map(server => new Promise(resolve => server.close(() => resolve())))- )- await new Promise(resolve => {- try {- udp.close(resolve)- } catch {- resolve()- }- })+ await new Promise(resolve => control.close(() => resolve()))+ if (udp && tcp) await closeDnsListeners({ udp, tcp })}async function start() {if (started || closing) throw new Error('DNS fixture cannot be started twice')started = truetry {- await listen(udp, () => udp.bind(dnsPort, listenHost))- await listen(tcp, () => tcp.listen(udp.address().port, listenHost))+ await listenDnsPair(createListeners, dnsPort, listenHost)+ for (const listener of [udp, tcp]) {+ listener.on('error', () => {+ fault = 'DNS_SOCKET_FAILED'+ })+ }await listen(control, () => control.listen(controlPort, '127.0.0.1'))return { dnsPort: udp.address().port, controlPort: control.address().port }} catch (error) {@@ -476,7 +540,15 @@ function createDnsProxy({return { start, close, snapshot, setMode }}-module.exports = { createDnsProxy, readConfig, question, dnsResponse, tcpFrame }+module.exports = {+ createDnsProxy,+ readConfig,+ question,+ dnsResponse,+ tcpFrame,+ listenDnsPair,+ closeDnsListeners,+}if (require.main === module) {let proxytry {