@nxtedition/nxt-undici 6.0.17 → 6.0.18

package/lib/interceptor/dns.js

@@ -1,9 +1,8 @@
 import net from 'node:net'
-import { resolve4 } from 'node:dns'
+import assert from 'node:assert'
+import * as dns from 'node:dns'
 import { DecoratorHandler, getFastNow } from '../utils.js'
 
-const MAX_TTL = 10e3
-
 class Handler extends DecoratorHandler {
   #callback
   #statusCode
@@ -37,33 +36,29 @@ export default () => (dispatch) => {
   const cache = new Map()
   const promises = new Map()
 
-  function resolve(hostname) {
+  function resolve(resolve4, hostname) {
     let promise = promises.get(hostname)
     if (!promise) {
       promise = new Promise((resolve) =>
         resolve4(hostname, { ttl: true }, (err, records) => {
-          let ret
-
           if (err) {
-            ret = { error: err }
+            resolve([err, null])
           } else {
             const now = getFastNow()
-            ret = {
-              value: records.map(({ address, ttl }) => ({
-                address,
-                expires: now + Math.min(MAX_TTL, 1e3 * ttl),
-                pending: 0,
-                errored: 0,
-                counter: 0,
-              })),
-            }
-          }
+            const val = records.map(({ address, ttl }) => ({
+              address,
+              expires: now + 1e3 * ttl,
+              pending: 0,
+              errored: 0,
+              counter: 0,
+            }))
 
-          cache.set(hostname, ret)
+            cache.set(hostname, val)
 
-          promises.delete(hostname)
+            resolve([null, val])
+          }
 
-          resolve(ret)
+          assert(promises.delete(hostname))
         }),
       )
       promises.set(hostname, promise)
@@ -87,16 +82,22 @@ export default () => (dispatch) => {
 
       const now = getFastNow()
 
-      let records = cache.get(hostname)?.value
+      let records = cache.get(hostname)
+
+      const resolve4 = opts.dns.resolve4 || dns.resolve4
 
       if (records == null || records.every((x) => x.expires < now)) {
-        const { value, error } = await resolve(hostname)
-        if (error) {
-          throw error
+        const [err, val] = await resolve(resolve4, hostname)
+
+        if (err) {
+          throw err
         }
-        records = value
+
+        assert(val.every((x) => x.expires > 0))
+
+        records = val
       } else if (records.some((x) => x.expires < now + 1e3)) {
-        resolve(hostname)
+        resolve(resolve4, hostname)
       }
 
       records.sort(

package/lib/interceptor/dns.test.js

@@ -1,3 +1,5 @@
+import { once } from 'node:events'
+import http from 'node:http'
 import { test } from 'tap'
 import { request } from '../index.js'
 
@@ -7,3 +9,74 @@ test('retry destroy pre response', async (t) => {
   t.equal(statusCode, 200)
   t.end()
 })
+
+test('expire & retry on error', async (t) => {
+  t.plan(3)
+
+  const server = http
+    .createServer((req, res) => {
+      res.end()
+    })
+    .listen(0)
+  t.teardown(server.close.bind(server))
+
+  await once(server, 'listening')
+
+  let counter = 0
+  const { body } = await request(`http://asd.com:${server.address().port}`, {
+    dns: {
+      resolve4(hostname, opts, callback) {
+        t.pass()
+        if (counter++ === 0) {
+          process.nextTick(callback, null, [{ address: '11.9.9.9', ttl: 600 }])
+        } else {
+          process.nextTick(callback, null, [{ address: '127.0.0.1', ttl: 600 }])
+        }
+      },
+    },
+    retry: 2,
+  })
+  await body.dump()
+
+  t.pass()
+})
+
+test('expire on error', async (t) => {
+  t.plan(2)
+
+  const server = http
+    .createServer((req, res) => {
+      res.end()
+    })
+    .listen(0)
+  t.teardown(server.close.bind(server))
+
+  await once(server, 'listening')
+
+  try {
+    const { body } = await request(`http://123.com:${server.address().port}`, {
+      dns: {
+        resolve4(hostname, opts, callback) {
+          process.nextTick(callback, null, [{ address: '10.9.9.9', ttl: 600 }])
+        },
+      },
+      retry: false,
+    })
+    await body.dump()
+  } catch (err) {
+    t.equal(err.code, 'UND_ERR_CONNECT_TIMEOUT')
+  }
+
+  const { body } = await request(`http://123.com:${server.address().port}`, {
+    dns: {
+      resolve4(hostname, opts, callback) {
+        process.nextTick(callback, null, [{ address: '127.0.0.1', ttl: 600 }])
+      },
+    },
+    retry: false,
+  })
+  await body.dump()
+
+  console.error('### 4')
+  t.pass()
+})

package/lib/utils.js

@@ -123,6 +123,7 @@ export async function retry(err, retryCount, opts) {
       'EHOSTDOWN',
       'EHOSTUNREACH',
       'EPIPE',
+      'UND_ERR_CONNECT_TIMEOUT',
     ].includes(err.code)
   ) {
     return tp.setTimeout(Math.min(10e3, retryCount * 1e3), undefined, { signal: opts.signal })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/nxt-undici",
-  "version": "6.0.17",
+  "version": "6.0.18",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "main": "lib/index.js",