A few BUGFIXES and new tests to cover those scenarios + multiple signalling servers!

gulpfile.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const gulp = require('gulp')
+const parallel = require('async/parallel')
 const sigServer = require('./src/sig-server')
 
-let sigS
+let sigS, sigS2
 
 gulp.task('test:node:before', boot)
 gulp.task('test:node:after', stop)
@@ -15,19 +16,47 @@ function boot (done) {
     port: 15555,
     host: '127.0.0.1'
   }
+  const options2 = {
+    port: 15556,
+    host: '127.0.0.1'
+  }
 
-  sigServer.start(options, (err, server) => {
-    if (err) {
-      throw err
-    }
-    sigS = server
-    console.log('signalling on:', server.info.uri)
-    done()
-  })
+  parallel([
+    first,
+    second
+  ], done)
+  function first (cb) {
+    sigServer.start(options, (err, server) => {
+      if (err) {
+        throw err
+      }
+      sigS = server
+      console.log('signalling on:', server.info.uri)
+      cb()
+    })
+  }
+  function second (cb) {
+    sigServer.start(options2, (err, server) => {
+      if (err) {
+        throw err
+      }
+      sigS2 = server
+      console.log('signalling 2 on:', server.info.uri)
+      cb()
+    })
+  }
 }
-
 function stop (done) {
-  sigS.stop(done)
+  parallel([
+    first,
+    second
+  ], done)
+  function first (cb) {
+    sigS.stop(() => cb())
+  }
+  function second (cb) {
+    sigS2.stop(() => cb())
+  }
 }
 
 require('aegir/gulp')(gulp)

src/index.js

@@ -40,8 +40,6 @@ function cleanUrlSIO (ma) {
 
 class WebRTCStar {
   constructor () {
-    this.maSelf = undefined
-
     this.sioOptions = {
       transports: ['websocket'],
       'force new connection': true
@@ -60,7 +58,11 @@ class WebRTCStar {
     callback = callback ? once(callback) : noop
 
     const intentId = (~~(Math.random() * 1e9)).toString(36) + Date.now()
-    const sioClient = this.listenersRefs[Object.keys(this.listenersRefs)[0]].io
+    const keys = Object.keys(this.listenersRefs)
+                          .filter((key) => cleanUrlSIO(ma) === cleanUrlSIO(multiaddr(key)))
+    const listener = this.listenersRefs[keys[0]]
+    if (!listener) return callback(new Error('signalling server not connected'))
+    const sioClient = listener.io
 
     const spOptions = {
       initiator: true,
@@ -73,11 +75,10 @@ class WebRTCStar {
 
     const conn = new Connection(toPull.duplex(channel))
     let connected = false
-
     channel.on('signal', (signal) => {
       sioClient.emit('ss-handshake', {
         intentId: intentId,
-        srcMultiaddr: this.maSelf.toString(),
+        srcMultiaddr: listener.ma.toString(),
         dstMultiaddr: ma.toString(),
         signal: signal
       })
@@ -130,13 +131,12 @@ class WebRTCStar {
     listener.listen = (ma, callback) => {
       callback = callback ? once(callback) : noop
 
-      this.maSelf = ma
-
       const sioUrl = cleanUrlSIO(ma)
 
       log('Dialing to Signalling Server on: ' + sioUrl)
 
       listener.io = io.connect(sioUrl, sioOptions)
+      listener.ma = ma
 
       listener.io.once('connect_error', callback)
       listener.io.once('error', (err) => {
@@ -148,10 +148,26 @@ class WebRTCStar {
         listener.io.emit('ss-join', ma.toString())
         listener.io.on('ws-handshake', incommingDial)
         listener.io.on('ws-peer', this._peerDiscovered)
+        this.listenersRefs[ma.toString()] = listener
         listener.emit('listening')
         callback()
       })
 
+      listener.close = (callback) => {
+        callback = callback ? once(callback) : noop
+
+        listener.io.emit('ss-leave', ma.toString())
+        setImmediate(() => {
+          listener.io.disconnect()
+          listener.emit('close')
+          callback()
+          delete this.listenersRefs[ma.toString()]
+        })
+      }
+      listener.getAddrs = (callback) => {
+        setImmediate(() => callback(null, [ma]))
+      }
+
       function incommingDial (offer) {
         if (offer.answer || offer.err) {
           return
@@ -188,22 +204,6 @@ class WebRTCStar {
       }
     }
 
-    listener.close = (callback) => {
-      callback = callback ? once(callback) : noop
-
-      listener.io.emit('ss-leave')
-
-      setImmediate(() => {
-        listener.emit('close')
-        callback()
-      })
-    }
-
-    listener.getAddrs = (callback) => {
-      setImmediate(() => callback(null, [this.maSelf]))
-    }
-
-    this.listenersRefs[multiaddr.toString()] = listener
     return listener
   }
 

test/transport/dial.spec.js

@@ -24,6 +24,8 @@ describe('dial', () => {
   const maHSIP = '/ip4/188.166.203.82/tcp/20000'
 
   const maLS = '/ip4/127.0.0.1/tcp/15555'
+  const maLS2 = '/ip4/127.0.0.1/tcp/15556'
+
   // const maGen = (base, id) => multiaddr(`/libp2p-webrtc-star${base}/wss/ipfs/${id}`) // https
   const maGen = (base, id) => multiaddr(`/libp2p-webrtc-star${base}/ws/ipfs/${id}`)
 
@@ -80,7 +82,7 @@ describe('dial', () => {
   })
 
   it('dial offline / non-existent node on IPv4, check callback', (done) => {
-    let maOffline = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/ABCD')
+    let maOffline = maGen(maLS, 'ABCD')
     ws1.dial(maOffline, (err, conn) => {
       expect(err).to.exist
       done()
@@ -90,4 +92,108 @@ describe('dial', () => {
   it.skip('dial on IPv6', (done) => {
     // TODO IPv6 not supported yet
   })
+  describe('complex dial scenarios', () => {
+    let ws1, ws2, ws3
+    const ma1a = maGen(maLS, 'QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooA1')
+    const ma1b = maGen(maLS, 'QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooA2')
+    const ma1c = maGen(maLS2, 'QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooA3')
+    const ma2 = maGen(maLS, 'QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooB1')
+    const ma3 = maGen(maLS2, 'QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooC1')
+    before((done) => {
+      series([
+        first,
+        second,
+        third,
+        fourth,
+        fifth
+      ], done)
+
+      function first (next) {
+        ws1 = new WebRTCStar()
+
+        const listener = ws1.createListener((conn) => {
+          pull(conn, conn)
+        })
+
+        // close immediately
+        listener.listen(ma1a, () => {
+          listener.close(next)
+        })
+      }
+
+      function second (next) {
+        const listener = ws1.createListener((conn) => {
+          pull(conn, conn)
+        })
+
+        listener.listen(ma1b, next)
+      }
+      function third (next) {
+        const listener = ws1.createListener((conn) => {
+          pull(conn, conn)
+        })
+
+        listener.listen(ma1c, next)
+      }
+
+      function fourth (next) {
+        ws2 = new WebRTCStar()
+
+        const listener = ws2.createListener((conn) => {
+          pull(conn, conn)
+        })
+        listener.listen(ma2, next)
+      }
+      function fifth (next) {
+        ws3 = new WebRTCStar()
+
+        const listener = ws3.createListener((conn) => {
+          pull(conn, conn)
+        })
+        listener.listen(ma3, next)
+      }
+    })
+
+    it('dial closed listener should error', (done) => {
+      ws2.dial(ma1a, (err, conn) => {
+        expect(err).to.exist
+        done()
+      })
+    })
+
+    it('dial after first listener is closed and its signalling connection disconnected', (done) => {
+      ws1.dial(ma2, (err, conn) => {
+        expect(err).to.not.exist
+
+        const data = new Buffer('some data')
+
+        pull(
+          pull.values([data]),
+          conn,
+          pull.collect((err, values) => {
+            expect(err).to.not.exist
+            expect(values).to.be.eql([data])
+            done()
+          })
+        )
+      })
+    })
+    it('dial a second node on a different signaling server', (done) => {
+      ws1.dial(ma3, (err, conn) => {
+        expect(err).to.not.exist
+
+        const data = new Buffer('some data')
+
+        pull(
+          pull.values([data]),
+          conn,
+          pull.collect((err, values) => {
+            expect(err).to.not.exist
+            expect(values).to.be.eql([data])
+            done()
+          })
+        )
+      })
+    })
+  })
 })

test/transport/listen.spec.js

@@ -48,6 +48,16 @@ describe('listen', () => {
     })
   })
 
+  it('listen on offline signalling server should error', (done) => {
+    let maOfflineSigServer = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.0/tcp/15555/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooA')
+    const listener = ws.createListener((conn) => {})
+    listener.listen(maOfflineSigServer, (err) => {
+      expect(err).to.exist
+      listener.once('close', done)
+      listener.close()
+    })
+  })
+
   it.skip('close listener with connections, through timeout', (done) => {
     // TODO ? Should this apply ?
   })