refactor: switch to async iterators

BREAKING CHANGE: Switch to using async/await and async iterators. The transport and connection interfaces have changed.

Author: vasco-santos

.travis.yml

@@ -21,7 +21,6 @@ jobs:
   include:
     - stage: check
       script:
-        - npx aegir commitlint --travis
         - npx aegir dep-check
         - npm run lint
 

README.md

@@ -20,6 +20,16 @@ js-libp2p-utp
 
 [Vasco Santos](https://github.com/vasco-santos).
 
+## API
+
+### Transport
+
+[![](https://raw.githubusercontent.com/libp2p/interface-transport/master/img/badge.png)](https://github.com/libp2p/interface-transport)
+
+### Connection
+
+[![](https://raw.githubusercontent.com/libp2p/interface-connection/master/img/badge.png)](https://github.com/libp2p/interface-connection)
+
 # Acknowledgements
 
 `js-libp2p-utp` is a wrapper on top on [utp](https://github.com/mafintosh/utp) originally developed by [Mathias Buus](https://github.com/mafintosh)

package.json

@@ -27,23 +27,28 @@
   },
   "homepage": "https://github.com/libp2p/js-libp2p-utp",
   "devDependencies": {
-    "aegir": "^18.2.2",
+    "aegir": "^20.0.0",
     "chai": "^4.2.0",
     "dirty-chai": "^2.0.1"
   },
   "dependencies": {
+    "abortable-iterator": "^2.1.0",
     "class-is": "^1.1.0",
     "debug": "^4.1.1",
+    "err-code": "^2.0.0",
     "interface-connection": "~0.3.3",
-    "ip-address": "^5.9.0",
+    "interface-transport": "^0.5.2",
+    "ip-address": "^6.1.0",
+    "it-pipe": "^1.0.1",
     "lodash.includes": "^4.3.0",
     "lodash.isfunction": "^3.0.9",
-    "mafmt": "^6.0.7",
-    "multiaddr": "^6.0.6",
+    "mafmt": "^6.0.8",
+    "multiaddr": "^6.1.0",
     "once": "^1.4.0",
     "pull-stream": "^3.6.11",
     "stream-to-pull-stream": "^1.7.3",
-    "utp-native": "^2.1.3"
+    "streaming-iterables": "^4.1.0",
+    "utp-native": "^2.1.4"
   },
   "contributors": [
     "David Dias <[email protected]>",

src/adapter.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { Adapter } = require('interface-transport')
+const withIs = require('class-is')
+const UTP = require('.')
+
+// Legacy adapter to old transport & connection interface
+class UTPAdapter extends Adapter {
+  constructor () {
+    super(new UTP())
+  }
+}
+
+module.exports = withIs(UTPAdapter, {
+  className: 'UTP',
+  symbolName: '@libp2p/js-libp2p-utp/utp'
+})

src/constants.js

@@ -0,0 +1,8 @@
+'use strict'
+
+// IPFS multi-address code
+module.exports.IPFS_MA_CODE = 421
+
+// Time to wait for a connection to close gracefully before destroying it
+// manually
+module.exports.CLOSE_TIMEOUT = 2000

src/create-listener.js

@@ -1,40 +1,37 @@
 'use strict'
 
+const debug = require('debug')
+const log = debug('libp2p:utp:listen')
+const logError = debug('libp2p:utp:listen:error')
+
 const multiaddr = require('multiaddr')
-const Connection = require('interface-connection').Connection
-// const os = require('os')
 const includes = require('lodash.includes')
 const utp = require('utp-native')
-const toPull = require('stream-to-pull-stream')
-const EventEmitter = require('events').EventEmitter
-const debug = require('debug')
-const log = debug('libp2p:utp')
+const { EventEmitter } = require('events')
 
+const Libp2pSocket = require('./socket')
 const getMultiaddr = require('./get-multiaddr')
 
-const IPFS_CODE = 421
-const CLOSE_TIMEOUT = 2000
-
-function noop () {}
+const { IPFS_MA_CODE, CLOSE_TIMEOUT } = require('./constants')
 
 module.exports = (handler) => {
   const listener = new EventEmitter()
 
   const server = utp.createServer((socket) => {
     // Avoid uncaught errors cause by unstable connections
-    socket.on('error', noop)
+    socket.on('error', (err) => {
+      logError('Error emitted by server handler socket: ' + err.message)
+    })
 
     const addr = getMultiaddr(socket)
-
-    const s = toPull.duplex(socket)
+    const s = new Libp2pSocket(socket, addr)
 
     s.getObservedAddrs = (cb) => cb(null, [addr])
 
     trackSocket(server, socket)
 
-    const conn = new Connection(s)
-    handler(conn)
-    listener.emit('connection', conn)
+    handler && handler(s)
+    listener.emit('connection', s)
   })
 
   server.on('listening', () => listener.emit('listening'))
@@ -44,57 +41,70 @@ module.exports = (handler) => {
   // Keep track of open connections to destroy in case of timeout
   server.__connections = {}
 
-  listener.close = (options, callback) => {
-    if (typeof options === 'function') {
-      callback = options
-      options = {}
+  listener.close = (options = {}) => {
+    if (!server.listening) {
+      return
     }
-    callback = callback || noop
-    options = options || {}
-
-    const timeout = setTimeout(() => {
-      log('unable to close graciously, destroying conns')
-      Object.keys(server.__connections).forEach((key) => {
-        log('destroying %s', key)
-        server.__connections[key].destroy()
-      })
-    }, options.timeout || CLOSE_TIMEOUT)
 
-    server.close(callback)
+    return new Promise((resolve, reject) => {
+      const start = Date.now()
 
-    server.once('close', () => {
-      clearTimeout(timeout)
+      // Attempt to stop the server. If it takes longer than the timeout,
+      // destroy all the underlying sockets manually.
+      const timeout = setTimeout(() => {
+        log('Timeout closing server after %dms, destroying connections manually', Date.now() - start)
+        Object.keys(server.__connections).forEach((key) => {
+          log('destroying %s', key)
+          server.__connections[key].destroy()
+        })
+        resolve()
+      }, options.timeout || CLOSE_TIMEOUT)
+
+      server.once('close', () => clearTimeout(timeout))
+
+      server.close((err) => err ? reject(err) : resolve())
     })
   }
 
   let ipfsId
   let listeningAddr
 
-  listener.listen = (ma, callback) => {
+  listener.listen = (ma) => {
     listeningAddr = ma
     if (includes(ma.protoNames(), 'ipfs')) {
       ipfsId = getIpfsId(ma)
       listeningAddr = ma.decapsulate('ipfs')
     }
 
     const lOpts = listeningAddr.toOptions()
-    log('Listening on %s %s', lOpts.port, lOpts.host)
-    server.listen(Number(lOpts.port), lOpts.host, callback)
+
+    return new Promise((resolve, reject) => {
+      server.listen(Number(lOpts.port), lOpts.host, (err) => {
+        if (err) {
+          return reject(err)
+        }
+
+        log('Listening on %s %s', lOpts.port, lOpts.host)
+        resolve()
+      })
+    })
   }
 
-  listener.getAddrs = (callback) => {
+  listener.getAddrs = () => {
     const multiaddrs = []
     const addr = server.address()
 
     if (!addr) {
-      return callback(new Error('Listener is not ready yet'))
+      throw new Error('Listener is not ready yet')
     }
 
     let ma
     if (addr.family === 'IPv6') {
       ma = multiaddr(`/ip6/${addr.address}/udp/${addr.port}/utp`)
     } else if (addr.family === 'IPv4') {
+      /* eslint-disable no-console */
       console.log(`/ip4/${addr.address}/udp/${addr.port}/utp`)
+      /* eslint-enable no-console */
       ma = multiaddr(`/ip4/${addr.address}/udp/${addr.port}/utp`)
     }
 
@@ -104,15 +114,15 @@ module.exports = (handler) => {
 
     multiaddrs.push(ma)
 
-    callback(null, multiaddrs)
+    return multiaddrs
   }
 
   return listener
 }
 
 function getIpfsId (ma) {
   return ma.stringTuples().filter((tuple) => {
-    return tuple[0] === IPFS_CODE
+    return tuple[0] === IPFS_MA_CODE
   })[0][1]
 }
 

src/index.js

@@ -1,54 +1,75 @@
 'use strict'
 
+const debug = require('debug')
+const log = debug('libp2p:utp')
+const errcode = require('err-code')
+
 const utp = require('utp-native')
-const toPull = require('stream-to-pull-stream')
 const mafmt = require('mafmt')
 const withIs = require('class-is')
 const includes = require('lodash.includes')
 const isFunction = require('lodash.isfunction')
-const Connection = require('interface-connection').Connection
-const once = require('once')
+const { AbortError } = require('interface-transport')
+const Libp2pSocket = require('./socket')
 const createListener = require('./create-listener.js')
-const debug = require('debug')
-const log = debug('libp2p:utp')
 
 function noop () {}
 
 class UTP {
-  dial (ma, options, callback) {
-    if (isFunction(options)) {
-      callback = options
-      options = {}
-    }
-
-    callback = once(callback || noop)
+  async dial (ma, options = {}) {
+    const rawSocket = await this._connect(ma, options)
+    return new Libp2pSocket(rawSocket, ma, options)
+  }
 
+  _connect (ma, options) {
     const cOpts = ma.toOptions()
-    log('Connecting (UTP) to %s %s', cOpts.port, cOpts.host)
+    log('Dialing %s:%s', cOpts.host, cOpts.port)
 
-    const rawSocket = utp.connect(cOpts)
+    return new Promise((resolve, reject) => {
+      if ((options.signal || {}).aborted) {
+        return reject(new AbortError())
+      }
 
-    rawSocket.once('timeout', () => {
-      log('timeout')
-      rawSocket.emit('error', new Error('Timeout'))
-    })
+      const start = Date.now()
+      const rawSocket = utp.connect(cOpts)
 
-    rawSocket.once('error', callback)
+      const onError = (err) => {
+        const msg = `Error dialing ${cOpts.host}:${cOpts.port}: ${err.message}`
+        done(errcode(new Error(msg), err.code))
+      }
 
-    rawSocket.once('connect', () => {
-      rawSocket.removeListener('error', callback)
-      callback()
-    })
+      const onTimeout = () => {
+        log('Timeout dialing %s:%s', cOpts.host, cOpts.port)
+        const err = errcode(new Error(`Timeout after ${Date.now() - start}ms`), 'ETIMEDOUT')
+        // Note: this will result in onError() being called
+        rawSocket.emit('error', err)
+      }
+
+      const onConnect = () => {
+        log('Connected to %s:%s', cOpts.host, cOpts.port)
+        done(null, rawSocket)
+      }
 
-    const socket = toPull.duplex(rawSocket)
+      const onAbort = () => {
+        log('Dial to %s:%s aborted', cOpts.host, cOpts.port)
+        done(new AbortError())
+      }
 
-    const conn = new Connection(socket)
+      const done = (err, res) => {
+        rawSocket.removeListener('error', onError)
+        rawSocket.removeListener('timeout', onTimeout)
+        rawSocket.removeListener('connect', onConnect)
+        options.signal && options.signal.removeEventListener('abort', onAbort)
 
-    conn.getObservedAddrs = (callback) => {
-      return callback(null, [ma])
-    }
+        err ? reject(err) : resolve(res)
+      }
 
-    return conn
+      rawSocket.once('error', onError)
+      rawSocket.once('timeout', onTimeout)
+      rawSocket.once('connect', onConnect)
+      rawSocket.on('close', () => rawSocket.destroy())
+      options.signal && options.signal.addEventListener('abort', onAbort)
+    })
   }
 
   createListener (options, handler) {