chore: release version v0.9.0

* feat: integrate dht

* better interfaces

* docs: add documentation for peerRouting, contentRouting, dht

* fix: take in passed datastore

* fix: update usage of _getPeerInfo

* fix: getPeerInfo

* docs: update docs

* moar

CHANGELOG.md

@@ -1,3 +1,46 @@
+<a name="0.9.0"></a>
+# [0.9.0](https://github.com/libp2p/js-libp2p/compare/v0.8.0...v0.9.0) (2017-04-06)
+
+
+
+<a name="0.8.0"></a>
+# [0.8.0](https://github.com/libp2p/js-libp2p/compare/v0.7.0...v0.8.0) (2017-03-31)
+
+
+### Bug Fixes
+
+* addition of ipfs id appendix must come before transport filtering ([291e79f](https://github.com/libp2p/js-libp2p/commit/291e79f))
+* avoid deleting nodes from peerBook ([300936f](https://github.com/libp2p/js-libp2p/commit/300936f))
+* correct method on peer-book ([031ecb3](https://github.com/libp2p/js-libp2p/commit/031ecb3))
+
+
+### Features
+
+* append peer id to multiaddr if not there ([59ea9c3](https://github.com/libp2p/js-libp2p/commit/59ea9c3))
+* not remove peer from peerBook on disconnect ([a4b41b0](https://github.com/libp2p/js-libp2p/commit/a4b41b0))
+
+
+
+<a name="0.7.0"></a>
+# [0.7.0](https://github.com/libp2p/js-libp2p/compare/v0.6.2...v0.7.0) (2017-03-29)
+
+
+### Features
+
+* update events to conform with [#74](https://github.com/libp2p/js-libp2p/issues/74) ([f73c045](https://github.com/libp2p/js-libp2p/commit/f73c045))
+
+
+
+<a name="0.6.2"></a>
+## [0.6.2](https://github.com/libp2p/js-libp2p/compare/v0.6.1...v0.6.2) (2017-03-28)
+
+
+
+<a name="0.6.1"></a>
+## [0.6.1](https://github.com/libp2p/js-libp2p/compare/v0.6.0...v0.6.1) (2017-03-27)
+
+
+
 <a name="0.6.0"></a>
 # [0.6.0](https://github.com/libp2p/js-libp2p/compare/v0.5.5...v0.6.0) (2017-03-27)
 

README.md

@@ -75,6 +75,7 @@ const WS = require('libp2p-websockets')
 const spdy = require('libp2p-spdy')
 const secio = require('libp2p-secio')
 const MulticastDNS = require('libp2p-mdns')
+const DHT = require('libp2p-kad-dht')
 
 class Node extends libp2p {
   constructor (peerInfo, peerBook, options) {
@@ -95,7 +96,9 @@ class Node extends libp2p {
       },
       discovery: [
         new MulticastDNS(peerInfo, 'your-identifier')
-      ]
+      ],
+      // DHT is passed as its own enabling PeerRouting, ContentRouting and DHT itself components
+      dht: DHT
     }
 
     super(modules, peerInfo, peerBook, options)
@@ -144,6 +147,36 @@ class Node extends libp2p {
 
 `callback` is a function with the following `function (err) {}` signature, where `err` is an Error in case stopping the node fails.
 
+#### `libp2p.peerRouting.findPeer(id, callback)`
+
+> Looks up for multiaddrs of a peer in the DHT
+
+- `id`: instance of [PeerId][]
+
+#### `libp2p.contentRouting.findProviders(key, timeout, callback)`
+
+- `key`: Buffer
+- `timeout`: Number miliseconds
+
+#### `libp2p.contentRouting.provide(key, timeout, callback)`
+
+- `key`: Buffer
+- `timeout`: Number miliseconds
+
+#### `libp2p.dht.put(key, value, callback)`
+
+- `key`: Buffer
+- `value`: Buffer
+
+#### `libp2p.dht.get(key, callback)`
+
+- `key`: Buffer
+
+#### `libp2p.dht.getMany(key, nVals, callback)`
+
+- `key`: Buffer
+- `nVals`: Number
+
 #### `libp2p.handle(protocol, handlerFunc [, matchFunc])`
 
 > Handle new protocol
@@ -158,12 +191,24 @@ class Node extends libp2p {
 
 - `protocol`: String that defines the protocol (e.g '/ipfs/bitswap/1.1.0')
 
-#### `libp2p.on('peer', (peer) => {})`
+#### `libp2p.on('peer:discovery', (peer) => {})`
 
 > Peer has been discovered.
 
 - `peer`: instance of [PeerInfo][]
 
+#### `libp2p.on('peer:connect', (peer) => {})`
+
+> We connected to a new peer
+
+- `peer`: instance of [PeerInfo][]
+
+#### `libp2p.on('peer:disconnect', (peer) => {})`
+
+> We disconnected from Peer
+
+- `peer`: instance of [PeerInfo][]
+
 #### `libp2p.isOn()`
 
 > Check if libp2p is started

package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "JavaScript Skeleton for libp2p bundles",
   "main": "src/index.js",
   "scripts": {
@@ -41,11 +41,12 @@
   },
   "dependencies": {
     "libp2p-ping": "~0.3.2",
-    "libp2p-swarm": "~0.26.19",
-    "multiaddr": "^2.2.3",
-    "peer-book": "~0.3.2",
-    "peer-id": "~0.8.5",
-    "peer-info": "~0.8.5"
+    "libp2p-swarm": "~0.29.1",
+    "mafmt": "^2.1.8",
+    "multiaddr": "^2.3.0",
+    "peer-book": "~0.4.0",
+    "peer-id": "~0.8.7",
+    "peer-info": "~0.9.2"
   },
   "contributors": [
     "David Dias <daviddias.p@gmail.com>",

src/index.js

@@ -1,14 +1,19 @@
 'use strict'
 
+const EventEmitter = require('events').EventEmitter
+const assert = require('assert')
+
+const setImmediate = require('async/setImmediate')
+const each = require('async/each')
+const series = require('async/series')
+
+const Ping = require('libp2p-ping')
 const Swarm = require('libp2p-swarm')
 const PeerId = require('peer-id')
 const PeerInfo = require('peer-info')
 const PeerBook = require('peer-book')
+const mafmt = require('mafmt')
 const multiaddr = require('multiaddr')
-const EventEmitter = require('events').EventEmitter
-const assert = require('assert')
-const Ping = require('libp2p-ping')
-const setImmediate = require('async/setImmediate')
 
 exports = module.exports
 
@@ -25,27 +30,26 @@ class Node extends EventEmitter {
     this.peerBook = _peerBook || new PeerBook()
     this.isOnline = false
 
-    this.swarm = new Swarm(this.peerInfo)
+    this.swarm = new Swarm(this.peerInfo, this.peerBook)
 
     // Attach stream multiplexers
     if (this.modules.connection.muxer) {
       let muxers = this.modules.connection.muxer
       muxers = Array.isArray(muxers) ? muxers : [muxers]
-      muxers.forEach((muxer) => {
-        this.swarm.connection.addStreamMuxer(muxer)
-      })
+      muxers.forEach((muxer) => this.swarm.connection.addStreamMuxer(muxer))
 
       // If muxer exists, we can use Identify
       this.swarm.connection.reuse()
 
-      // Received incommind dial and muxer upgrade happened, reuse this
-      // muxed connection
+      // Received incommind dial and muxer upgrade happened,
+      // reuse this muxed connection
       this.swarm.on('peer-mux-established', (peerInfo) => {
+        this.emit('peer:connect', peerInfo)
         this.peerBook.put(peerInfo)
       })
 
       this.swarm.on('peer-mux-closed', (peerInfo) => {
-        this.peerBook.removeByB58String(peerInfo.id.toB58String())
+        this.emit('peer:disconnect', peerInfo)
       })
     }
 
@@ -62,17 +66,58 @@ class Node extends EventEmitter {
     if (this.modules.discovery) {
       let discoveries = this.modules.discovery
       discoveries = Array.isArray(discoveries) ? discoveries : [discoveries]
+
       discoveries.forEach((discovery) => {
-        discovery.on('peer', (peerInfo) => this.emit('peer', peerInfo))
+        discovery.on('peer', (peerInfo) => this.emit('peer:discovery', peerInfo))
       })
     }
 
     // Mount default protocols
     Ping.mount(this.swarm)
 
-    // Not fully implemented in js-libp2p yet
-    this.routing = undefined
-    this.records = undefined
+    // dht provided components (peerRouting, contentRouting, dht)
+    if (_modules.DHT) {
+      this._dht = new this.modules.DHT(this, 20, _options.DHT && _options.DHT.datastore)
+    }
+
+    this.peerRouting = {
+      findPeer: (id, callback) => {
+        assert(this._dht, 'DHT is not available')
+
+        this._dht.findPeer(id, callback)
+      }
+    }
+
+    this.contentRouting = {
+      findProviders: (key, timeout, callback) => {
+        assert(this._dht, 'DHT is not available')
+
+        this._dht.findProviders(key, timeout, callback)
+      },
+      provide: (key, callback) => {
+        assert(this._dht, 'DHT is not available')
+
+        this._dht.provide(key, callback)
+      }
+    }
+
+    this.dht = {
+      put: (key, value, callback) => {
+        assert(this._dht, 'DHT is not available')
+
+        this._dht.put(key, value, callback)
+      },
+      get: (key, callback) => {
+        assert(this._dht, 'DHT is not available')
+
+        this._dht.get(key, callback)
+      },
+      getMany (key, nVals, callback) {
+        assert(this._dht, 'DHT is not available')
+
+        this._dht.getMany(key, nVals, callback)
+      }
+    }
   }
 
   /*
@@ -88,7 +133,19 @@ class Node extends EventEmitter {
     let transports = this.modules.transport
 
     transports = Array.isArray(transports) ? transports : [transports]
-    const multiaddrs = this.peerInfo.multiaddrs
+
+    // so that we can have webrtc-star addrs without adding manually the id
+    const maOld = []
+    const maNew = []
+    this.peerInfo.multiaddrs.forEach((ma) => {
+      if (!mafmt.IPFS.matches(ma)) {
+        maOld.push(ma)
+        maNew.push(ma.encapsulate('/ipfs/' + this.peerInfo.id.toB58String()))
+      }
+    })
+    this.peerInfo.multiaddrs.replace(maOld, maNew)
+
+    const multiaddrs = this.peerInfo.multiaddrs.toArray()
 
     transports.forEach((transport) => {
       if (transport.filter(multiaddrs).length > 0) {
@@ -102,24 +159,30 @@ class Node extends EventEmitter {
       }
     })
 
-    this.swarm.listen((err) => {
-      if (err) {
-        return callback(err)
-      }
-      if (ws) {
-        this.swarm.transport.add(ws.tag || ws.constructor.name, ws)
-      }
+    series([
+      (cb) => this.swarm.listen(cb),
+      (cb) => {
+        // listeners on, libp2p is on
+        this.isOnline = true
 
-      this.isOnline = true
+        if (ws) {
+          // always add dialing on websockets
+          this.swarm.transport.add(ws.tag || ws.constructor.name, ws)
+        }
 
-      if (this.modules.discovery) {
-        this.modules.discovery.forEach((discovery) => {
-          setImmediate(() => discovery.start(() => {}))
-        })
+        // all transports need to be setup before discover starts
+        if (this.modules.discovery) {
+          return each(this.modules.discovery, (d, cb) => d.start(cb), cb)
+        }
+        cb()
+      },
+      (cb) => {
+        if (this._dht) {
+          return this._dht.start(cb)
+        }
+        cb()
       }
-
-      callback()
-    })
+    ], callback)
   }
 
   /*
@@ -134,7 +197,15 @@ class Node extends EventEmitter {
       })
     }
 
-    this.swarm.close(callback)
+    series([
+      (cb) => {
+        if (this._dht) {
+          return this._dht.stop(cb)
+        }
+        cb()
+      },
+      (cb) => this.swarm.close(cb)
+    ], callback)
   }
 
   isOn () {
@@ -143,34 +214,48 @@ class Node extends EventEmitter {
 
   ping (peer, callback) {
     assert(this.isOn(), OFFLINE_ERROR_MESSAGE)
-    const peerInfo = this._getPeerInfo(peer)
-    callback(null, new Ping(this.swarm, peerInfo))
+    this._getPeerInfo(peer, (err, peerInfo) => {
+      if (err) {
+        return callback(err)
+      }
+
+      callback(null, new Ping(this.swarm, peerInfo))
+    })
   }
 
   dial (peer, protocol, callback) {
     assert(this.isOn(), OFFLINE_ERROR_MESSAGE)
-    const peerInfo = this._getPeerInfo(peer)
 
     if (typeof protocol === 'function') {
       callback = protocol
       protocol = undefined
     }
 
-    this.swarm.dial(peerInfo, protocol, (err, conn) => {
+    this._getPeerInfo(peer, (err, peerInfo) => {
       if (err) {
         return callback(err)
       }
-      this.peerBook.put(peerInfo)
-      callback(null, conn)
+
+      this.swarm.dial(peerInfo, protocol, (err, conn) => {
+        if (err) {
+          return callback(err)
+        }
+        this.peerBook.put(peerInfo)
+        callback(null, conn)
+      })
     })
   }
 
   hangUp (peer, callback) {
     assert(this.isOn(), OFFLINE_ERROR_MESSAGE)
-    const peerInfo = this._getPeerInfo(peer)
 
-    this.peerBook.removeByB58String(peerInfo.id.toB58String())
-    this.swarm.hangUp(peerInfo, callback)
+    this._getPeerInfo(peer, (err, peerInfo) => {
+      if (err) {
+        return callback(err)
+      }
+
+      this.swarm.hangUp(peerInfo, callback)
+    })
   }
 
   handle (protocol, handlerFunc, matchFunc) {
@@ -184,31 +269,33 @@ class Node extends EventEmitter {
   /*
    * Helper method to check the data type of peer and convert it to PeerInfo
    */
-  _getPeerInfo (peer) {
+  _getPeerInfo (peer, callback) {
     let p
+    // PeerInfo
     if (PeerInfo.isPeerInfo(peer)) {
       p = peer
+    // Multiaddr instance (not string)
     } else if (multiaddr.isMultiaddr(peer)) {
       const peerIdB58Str = peer.getPeerId()
       try {
-        p = this.peerBook.getByB58String(peerIdB58Str)
+        p = this.peerBook.get(peerIdB58Str)
       } catch (err) {
         p = new PeerInfo(PeerId.createFromB58String(peerIdB58Str))
       }
-      p.multiaddr.add(peer)
+      p.multiaddrs.add(peer)
+    // PeerId
     } else if (PeerId.isPeerId(peer)) {
       const peerIdB58Str = peer.toB58String()
       try {
-        p = this.peerBook.getByB58String(peerIdB58Str)
+        p = this.peerBook.get(peerIdB58Str)
       } catch (err) {
-        // TODO this is where PeerRouting comes into place
-        throw new Error('No knowledge about: ' + peerIdB58Str)
+        return this.peerRouting.findPeer(peer, callback)
       }
     } else {
-      throw new Error('peer type not recognized')
+      return setImmediate(() => callback(new Error('peer type not recognized')))
     }
 
-    return p
+    setImmediate(() => callback(null, p))
   }
 }