Feat/circuit relay

.aegir.js

@@ -1,6 +1,10 @@
 'use strict'
 
 const createServer = require('ipfsd-ctl').createServer
+const parallel = require('async/parallel')
+const rendezvous = require('libp2p-websocket-star-rendezvous')
+
+let rzserver
 
 const server = createServer()
 module.exports = {
@@ -16,8 +20,28 @@ module.exports = {
   },
   hooks: {
     browser: {
-      pre: server.start.bind(server),
-      post: server.stop.bind(server)
+      pre: (done) => {
+        parallel([
+          (cb) => server.start(cb),
+          (cb) => {
+            rendezvous.start({
+              port: 24642
+            }, (err, _rzserver) => {
+              if (err) {
+                return done(err)
+              }
+              rzserver = _rzserver
+              cb()
+            })
+          }
+        ], done)
+      },
+      post: (done) => {
+        parallel([
+          (cb) => server.stop(cb),
+          (cb) => rzserver.stop(cb)
+        ], done)
+      }
     }
   }
 }

package.json

@@ -17,9 +17,9 @@
   },
   "scripts": {
     "lint": "aegir lint",
-    "test": "aegir test -t node -t browser --no-cors",
-    "test:node": "aegir test -t node -f test/node.js",
-    "test:browser": "aegir test -t browser --no-cors -f test/browser.js"
+    "test": "cross-env IPFS_REUSEPORT=false aegir test -t node -t browser --no-cors",
+    "test:node": "cross-env IPFS_REUSEPORT=false aegir test -t node -f test/node.js",
+    "test:browser": "cross-env IPFS_REUSEPORT=false aegir test -t browser --no-cors -f test/browser.js"
   },
   "pre-commit": [
     "lint"
@@ -45,6 +45,7 @@
     "buffer-loader": "0.0.1",
     "chai": "^4.1.2",
     "cids": "^0.5.2",
+    "cross-env": "^5.1.3",
     "detect-node": "^2.0.3",
     "dir-compare": "^1.4.0",
     "dirty-chai": "^2.0.1",
@@ -53,10 +54,12 @@
     "form-data": "^2.3.1",
     "go-ipfs-dep": "^0.4.13",
     "hat": "0.0.3",
-    "ipfs": "~0.27.7",
+    "ipfs": "^0.28.0",
     "ipfs-api": "^18.1.1",
     "ipfsd-ctl": "~0.29.1",
     "left-pad": "^1.2.0",
+    "libp2p-websocket-star": "^0.7.2",
+    "libp2p-websocket-star-rendezvous": "^0.2.2",
     "lodash": "^4.17.4",
     "mocha": "^4.0.1",
     "ncp": "^2.0.0",

test/browser.js

@@ -4,4 +4,5 @@
 // require('./exchange-files')
 // require('./pubsub')
 require('./kad-dht')
-require('./repo')
+require('./circuit')
+// require('./repo')

test/circuit.js

@@ -0,0 +1,290 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+const expect = chai.expect
+chai.use(dirtyChai)
+
+const parallel = require('async/parallel')
+const series = require('async/series')
+
+const isNode = require('detect-node')
+
+const utils = require('./utils/circuit')
+
+const proc = utils.setUpProcNode
+const js = utils.setUpJsNode
+const go = utils.setUpGoNode
+
+const ws = utils.wsAddr
+const star = utils.wsStarAddr
+const circuit = utils.circuitAddr
+
+const send = utils.send
+
+const base = '/ip4/127.0.0.1/tcp/0'
+
+const connect = (nodeA, nodeB, relay, timeout, callback) => {
+  if (typeof timeout === 'function') {
+    callback = timeout
+    timeout = 1000
+  }
+
+  series([
+    (cb) => nodeA.ipfsd.api.swarm.connect(ws(relay.addrs), cb),
+    (cb) => setTimeout(cb, timeout),
+    (cb) => nodeB.ipfsd.api.swarm.connect(ws(relay.addrs), cb),
+    (cb) => setTimeout(cb, timeout),
+    (cb) => nodeA.ipfsd.api.swarm.connect(circuit(nodeB.addrs), cb)
+  ], callback)
+}
+
+const timeout = 80 * 1000
+const baseTest = {
+  connect,
+  send,
+  timeout
+}
+
+let tests = {
+  'go-go-go': {
+    create: (callback) => series([
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb)
+    ], callback)
+  },
+  'js-go-go': {
+    create: (callback) => series([
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb)
+    ], callback)
+  },
+  'go-go-js': {
+    create: (callback) => series([
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb)
+    ], callback)
+  },
+  'js-go-js': {
+    create: (callback) => series([
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb)
+    ], callback)
+  },
+  'go-js-go': {
+    create: (callback) => series([
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb)
+    ], callback)
+  },
+  'js-js-go': {
+    create: (callback) => series([
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb)
+    ], callback)
+  },
+  'go-js-js': {
+    create: (callback) => series([
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb)
+    ], callback)
+  },
+  'js-js-js': {
+    create: (callback) => series([
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb)
+    ], callback)
+  }
+}
+
+const connWithTimeout = (timeout) => {
+  return (nodeA, nodeB, relay, callback) => {
+    connect(nodeA, nodeB, relay, timeout, callback)
+  }
+}
+const browser = {
+  'browser-go-js': {
+    create:
+      (callback) => series([
+        (cb) => proc([], cb),
+        (cb) => go([`${base}/ws`], cb),
+        (cb) => js([`${base}/ws`], cb)
+      ], callback),
+    connect: connWithTimeout(1500)
+  },
+  'browser-go-go': {
+    create: (callback) => series([
+      (cb) => proc([], cb),
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb)
+    ], callback),
+    connect: connWithTimeout(1500)
+  },
+  'browser-js-js': {
+    create: (callback) => series([
+      (cb) => proc([], cb),
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb)
+    ], callback),
+    connect: connWithTimeout(1500)
+  },
+  'browser-js-go': {
+    create: (callback) => series([
+      (cb) => proc([], cb),
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb)
+    ], callback),
+    connect: connWithTimeout(1500)
+  },
+  'js-go-browser': {
+    create: (callback) => series([
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => proc([], cb)
+    ], callback),
+    connect: connWithTimeout(1500)
+  },
+  'go-go-browser': {
+    create: (callback) => series([
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => proc([], cb)
+    ], callback),
+    connect: connWithTimeout(1500)
+  },
+  'js-js-browser': {
+    create: (callback) => series([
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => proc([], cb)
+    ], callback),
+    connect: connWithTimeout(1500)
+  },
+  'go-js-browser': {
+    create: (callback) => series([
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => proc([], cb)
+    ], callback),
+    connect: connWithTimeout(1500)
+  },
+  'go-browser-browser': {
+    create: (callback) => series([
+      (cb) => go([`${base}/ws`], cb),
+      (cb) => proc([`/ip4/127.0.0.1/tcp/24642/ws/p2p-websocket-star`], cb),
+      (cb) => proc([`/ip4/127.0.0.1/tcp/24642/ws/p2p-websocket-star`], cb)
+    ], callback),
+    connect: (nodeA, nodeB, relay, callback) => {
+      series([
+        (cb) => relay.ipfsd.api.swarm.connect(ws(nodeA.addrs), cb),
+        (cb) => setTimeout(cb, 2000),
+        (cb) => relay.ipfsd.api.swarm.connect(star(nodeB.addrs), cb),
+        (cb) => setTimeout(cb, 2000),
+        (cb) => nodeA.ipfsd.api.swarm.connect(circuit(nodeB.addrs), cb)
+      ], callback)
+    },
+    timeout: 100 * 1000,
+    skip: () => true
+  },
+  'js-browser-browser': {
+    create: (callback) => series([
+      (cb) => js([`${base}/ws`], cb),
+      (cb) => proc([`/ip4/127.0.0.1/tcp/24642/ws/p2p-websocket-star`], cb),
+      (cb) => proc([`/ip4/127.0.0.1/tcp/24642/ws/p2p-websocket-star`], cb)
+    ], callback),
+    connect: (nodeA, nodeB, relay, callback) => {
+      series([
+        (cb) => relay.ipfsd.api.swarm.connect(ws(nodeA.addrs), cb),
+        (cb) => setTimeout(cb, 2000),
+        (cb) => relay.ipfsd.api.swarm.connect(star(nodeB.addrs), cb),
+        (cb) => setTimeout(cb, 2000),
+        (cb) => nodeA.ipfsd.api.swarm.connect(circuit(nodeB.addrs), cb)
+      ], callback)
+    },
+    timeout: 100 * 1000
+  },
+  'browser-browser-go': {
+    create: (callback) => series([
+      (cb) => proc([`/ip4/127.0.0.1/tcp/24642/ws/p2p-websocket-star`], cb),
+      (cb) => proc([`/ip4/127.0.0.1/tcp/24642/ws/p2p-websocket-star`], cb),
+      (cb) => go([`${base}/ws`], cb)
+    ], callback),
+    connect: (nodeA, nodeB, relay, callback) => {
+      series([
+        (cb) => relay.ipfsd.api.swarm.connect(star(nodeA.addrs), cb),
+        (cb) => setTimeout(cb, 2000),
+        (cb) => relay.ipfsd.api.swarm.connect(ws(nodeB.addrs), cb),
+        (cb) => setTimeout(cb, 2000),
+        (cb) => nodeA.ipfsd.api.swarm.connect(circuit(nodeB.addrs), cb)
+      ], callback)
+    },
+    timeout: 100 * 1000,
+    skip: () => true
+  },
+  'browser-browser-js': {
+    create: (callback) => series([
+      (cb) => proc([`/ip4/127.0.0.1/tcp/24642/ws/p2p-websocket-star`], cb),
+      (cb) => proc([`/ip4/127.0.0.1/tcp/24642/ws/p2p-websocket-star`], cb),
+      (cb) => js([`${base}/ws`], cb)
+    ], callback),
+    connect: (nodeA, nodeB, relay, callback) => {
+      series([
+        (cb) => relay.ipfsd.api.swarm.connect(star(nodeA.addrs), cb),
+        (cb) => setTimeout(cb, 2000),
+        (cb) => relay.ipfsd.api.swarm.connect(ws(nodeB.addrs), cb),
+        (cb) => setTimeout(cb, 2000),
+        (cb) => nodeA.ipfsd.api.swarm.connect(circuit(nodeB.addrs), cb)
+      ], callback)
+    }
+  }
+}
+
+describe('circuit', () => {
+  if (!isNode) {
+    tests = Object.assign([], tests, browser)
+  }
+
+  Object.keys(tests).forEach((test) => {
+    let nodes
+    let nodeA
+    let relay
+    let nodeB
+
+    tests[test] = Object.assign({}, baseTest, tests[test])
+    const dsc = tests[test].skip && tests[test].skip() ? describe.skip : describe
+    dsc(test, function () {
+      this.timeout(tests[test].timeout)
+
+      before((done) => {
+        tests[test].create((err, _nodes) => {
+          expect(err).to.not.exist()
+          nodes = _nodes.map((n) => n.ipfsd)
+          nodeA = _nodes[0]
+          relay = _nodes[1]
+          nodeB = _nodes[2]
+          done()
+        })
+      })
+
+      after((done) => parallel(nodes.map((ipfsd) => (cb) => ipfsd.stop(cb)), done))
+
+      it('connect', (done) => {
+        tests[test].connect(nodeA, nodeB, relay, done)
+      })
+
+      it('send', (done) => {
+        tests[test].send(nodeA.ipfsd.api, nodeB.ipfsd.api, done)
+      })
+    })
+  })
+})

test/exchange-files.js

@@ -17,6 +17,8 @@ const join = require('path').join
 const os = require('os')
 const hat = require('hat')
 
+const isWindows = os.platform() === 'win32'
+
 const rmDir = promisify(rimraf)
 
 const DaemonFactory = require('ipfsd-ctl')
@@ -175,6 +177,11 @@ describe('exchange files', () => {
 
   // TODO these tests are not fetching the full dir??
   describe('get directory', () => dirs.forEach((num) => {
+    // skipping until https://github.com/ipfs/interop/issues/9 is addressed
+    if (isWindows) {
+      return
+    }
+
     it(`go -> js: depth: 5, num: ${num}`, function () {
       this.timeout(50 * 1000)
       const dir = tmpDir()