Skip to content

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

TypeScript

test(egress): allocate the DNS fixture UDP/TCP port pair without collisions

Alfredo Lopez5e6f20701696
diff --git a/scripts/tests/wrc-egress-dns-proxy.test.cjs b/scripts/tests/wrc-egress-dns-proxy.test.cjs
index b89bb7664..01374c471 100644
--- a/scripts/tests/wrc-egress-dns-proxy.test.cjs
+++ b/scripts/tests/wrc-egress-dns-proxy.test.cjs
@@ -8,6 +8,7 @@ const { Resolver } = require('node:dns/promises')
const net = require('node:net')
const {
createDnsProxy,
+ listenDnsPair,
readConfig,
question,
dnsResponse,
@@ -66,8 +67,7 @@ async function exchangeTcp(port, message) {
}
async function fixture(t, configuredTargets = targets) {
- const upstream = await udpClient(t)
- const upstreamPort = upstream.address().port
+ const upstream = dgram.createSocket('udp4')
const 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)
@@ -81,8 +81,8 @@ async function fixture(t, configuredTargets = targets) {
}
})
})
- tcpUpstream.listen(upstreamPort, '127.0.0.1')
- await once(tcpUpstream, 'listening')
+ const upstreamPort = await listenDnsPair(upstream, tcpUpstream, 0, '127.0.0.1')
+ t.after(() => new Promise(resolve => upstream.close(resolve)))
t.after(() => new Promise(resolve => tcpUpstream.close(resolve)))
const proxy = createDnsProxy({
targets: configuredTargets,
@@ -410,3 +410,53 @@ test(
await proxy.close()
}
)
+
+// A UDP socket stand-in whose bind reports EADDRINUSE for the first `collisions` calls.
+function collidingUdp(collisions) {
+ const { EventEmitter } = require('node:events')
+ const udp = new EventEmitter()
+ udp.bound = []
+ udp.bind = port => {
+ udp.bound.push(port)
+ setImmediate(() => {
+ if (udp.bound.length <= collisions) {
+ udp.emit('error', Object.assign(new Error('bind EADDRINUSE'), { code: 'EADDRINUSE' }))
+ } else {
+ udp.emit('listening')
+ }
+ })
+ }
+ return udp
+}
+
+test('an ephemeral DNS port pair is reallocated when UDP finds the TCP port taken', async t => {
+ const udp = collidingUdp(2)
+ const tcp = net.createServer()
+ t.after(() => new Promise(resolve => (tcp.listening ? tcp.close(resolve) : resolve())))
+ const port = await listenDnsPair(udp, tcp, 0, '127.0.0.1')
+ assert.equal(udp.bound.length, 3, 'two collisions, then a pair that binds')
+ assert.equal(tcp.listening, true)
+ assert.equal(tcp.address().port, port)
+ assert.equal(udp.bound[2], port, 'UDP joins the port TCP chose')
+})
+
+test('an explicit or exhausted DNS port pair rethrows EADDRINUSE and releases TCP', async () => {
+ const blocker = net.createServer()
+ blocker.listen(0, '127.0.0.1')
+ await once(blocker, 'listening')
+ const fixedUdp = collidingUdp(1)
+ const fixedTcp = net.createServer()
+ const free = blocker.address().port
+ await new Promise(resolve => blocker.close(resolve))
+ await assert.rejects(listenDnsPair(fixedUdp, fixedTcp, free, '127.0.0.1'), { code: 'EADDRINUSE' })
+ assert.equal(fixedUdp.bound.length, 1, 'an explicit port gets one attempt')
+ assert.equal(fixedTcp.listening, false)
+
+ const exhaustedUdp = collidingUdp(Infinity)
+ const exhaustedTcp = net.createServer()
+ await assert.rejects(listenDnsPair(exhaustedUdp, exhaustedTcp, 0, '127.0.0.1'), {
+ code: 'EADDRINUSE',
+ })
+ assert.equal(exhaustedUdp.bound.length, 20, 'every ephemeral attempt was made')
+ assert.equal(exhaustedTcp.listening, false)
+})
diff --git a/tests/e2e/fixtures/package-lock.json b/tests/e2e/fixtures/package-lock.json
index 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.json
index 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.cjs
index 0ae585cee..d60a105a7 100644
--- a/tests/e2e/fixtures/wrc-egress-dns-proxy/server.cjs
+++ b/tests/e2e/fixtures/wrc-egress-dns-proxy/server.cjs
@@ -101,6 +101,45 @@ function increment(counts, mode) {
else throw new Error('Invalid observation mode')
}
+const EPHEMERAL_PAIR_ATTEMPTS = 20
+
+function listenOnce(server, action) {
+ return 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()
+ })
+}
+
+/**
+ * Binds a UDP socket and a TCP server to the same port. TCP and UDP ephemeral
+ * ports are allocated independently, so a port free for one transport can be
+ * taken for the other: with port 0 the TCP port is chosen first and UDP joins
+ * it, choosing a new pair when UDP finds it taken. An explicit port gets one
+ * attempt, and running out of attempts rethrows the last EADDRINUSE.
+ */
+async function listenDnsPair(udp, tcp, port, host) {
+ const attempts = port === 0 ? EPHEMERAL_PAIR_ATTEMPTS : 1
+ for (let attempt = 1; ; attempt++) {
+ await listenOnce(tcp, () => tcp.listen(port, host))
+ try {
+ await listenOnce(udp, () => udp.bind(tcp.address().port, host))
+ return tcp.address().port
+ } catch (error) {
+ await new Promise(resolve => tcp.close(() => resolve()))
+ if (error.code !== 'EADDRINUSE' || attempt >= attempts) throw error
+ }
+ }
+}
+
/** A real UDP/TCP DNS fixture; ephemeral loopback ports are used only by tests. */
function createDnsProxy({
targets,
@@ -464,8 +503,7 @@ function createDnsProxy({
if (started || closing) throw new Error('DNS fixture cannot be started twice')
started = true
try {
- await listen(udp, () => udp.bind(dnsPort, listenHost))
- await listen(tcp, () => tcp.listen(udp.address().port, listenHost))
+ await listenDnsPair(udp, tcp, dnsPort, listenHost)
await listen(control, () => control.listen(controlPort, '127.0.0.1'))
return { dnsPort: udp.address().port, controlPort: control.address().port }
} catch (error) {
@@ -476,7 +514,7 @@ function createDnsProxy({
return { start, close, snapshot, setMode }
}
-module.exports = { createDnsProxy, readConfig, question, dnsResponse, tcpFrame }
+module.exports = { createDnsProxy, listenDnsPair, readConfig, question, dnsResponse, tcpFrame }
if (require.main === module) {
let proxy
try {