fix: release tokens as soon as they are available

src/dialer/dial-request.js

@@ -47,21 +47,21 @@ class DialRequest {
     const tokenHolder = new FIFO()
     tokens.forEach(token => tokenHolder.push(token))
     const dialAbortControllers = this.addrs.map(() => new AbortController())
-    let completedDials = 0
+    let startedDials = 0
 
     try {
       return await pAny(this.addrs.map(async (addr, i) => {
         const token = await tokenHolder.shift() // get token
+        startedDials++
         let conn
         try {
           const signal = dialAbortControllers[i].signal
           conn = await this.dialAction(addr, { ...options, signal: anySignal([signal, options.signal]) })
           // Remove the successful AbortController so it is not aborted
           dialAbortControllers.splice(i, 1)
         } finally {
-          completedDials++
           // If we have more dials to make, recycle the token, otherwise release it
-          if (completedDials < this.addrs.length) {
+          if (startedDials < this.addrs.length) {
             tokenHolder.push(token)
           } else {
             this.dialer.releaseToken(tokens.splice(tokens.indexOf(token), 1)[0])

test/dialing/dial-request.spec.js

@@ -11,6 +11,7 @@ const { AbortError } = require('libp2p-interfaces/src/transport/errors')
 const AbortController = require('abort-controller')
 const AggregateError = require('aggregate-error')
 const pDefer = require('p-defer')
+const delay = require('delay')
 
 const { DialRequest } = require('../../src/dialer/dial-request')
 const createMockConnection = require('../utils/mockConnection')
@@ -50,6 +51,54 @@ describe('Dial Request', () => {
     expect(dialer.releaseToken).to.have.property('callCount', tokens.length)
   })
 
+  it('should release tokens when all addr dials have started', async () => {
+    const mockConnection = await createMockConnection()
+    const deferred = pDefer()
+    const actions = {
+      1: async () => {
+        await delay(0)
+        return Promise.reject(error)
+      },
+      2: async () => {
+        await delay(0)
+        return Promise.reject(error)
+      },
+      3: () => deferred.promise
+    }
+    const dialAction = (num) => actions[num]()
+    const tokens = ['a', 'b']
+    const controller = new AbortController()
+    const dialer = {
+      getTokens: () => [...tokens],
+      releaseToken: () => {}
+    }
+
+    const dialRequest = new DialRequest({
+      addrs: Object.keys(actions),
+      dialer,
+      dialAction
+    })
+
+    sinon.spy(actions, 1)
+    sinon.spy(actions, 2)
+    sinon.spy(actions, 3)
+    sinon.spy(dialer, 'releaseToken')
+    dialRequest.run({ signal: controller.signal })
+    // Let the first dials run
+    await delay(10)
+
+    // Only 1 dial should remain, so 1 token should have been released
+    expect(actions[1]).to.have.property('callCount', 1)
+    expect(actions[2]).to.have.property('callCount', 1)
+    expect(actions[3]).to.have.property('callCount', 1)
+    expect(dialer.releaseToken).to.have.property('callCount', 1)
+
+    // Finish the dial
+    deferred.resolve(mockConnection)
+    await delay(0)
+    expect(dialer.releaseToken).to.have.property('callCount', 2)
+  })
+
   it('should throw an AggregateError if all dials fail', async () => {
     const actions = {
       1: () => Promise.reject(error),