chore: use classes instead

.aegir.js

@@ -1,10 +1,11 @@
 'use strict'
 
-const createServer = require('./src/server')
+const Server = require('./src/server')
 let server
 
 async function pre () {
-  server = await createServer()
+  server = new Server()
+  await server.start()
 }
 
 function post () {

package.json

@@ -39,7 +39,7 @@
     "it-buffer": "^0.1.1",
     "it-handshake": "^1.0.1",
     "it-length-prefixed": "^3.0.0",
-    "it-pb-rpc": "vasco-santos/it-pb-rpc#fix/read-pb-using-read-lp",
+    "it-pb-rpc": "^0.1.5",
     "libp2p-crypto": "~0.16.3",
     "libp2p-mplex": "^0.9.3",
     "libp2p-secio": "^0.12.2",

src/index.js

@@ -10,7 +10,7 @@ const { AbortError } = require('abortable-iterator')
 // const errcode = require('err-code')
 const withIs = require('class-is')
 
-const createListener = require('./listener')
+const Listener = require('./listener')
 // const mafmt = require('mafmt')
 
 const toConnection = require('./socket-to-conn')
@@ -108,7 +108,10 @@ class Stardust {
 
     handler = handler || noop
 
-    return createListener({ handler, upgrader: this._upgrader }, this, options)
+    return new Listener({
+      handler,
+      upgrader: this._upgrader
+    }, this, options)
   }
 
   /**

src/listener.js

@@ -16,18 +16,26 @@ const { int32BEDecode, int32BEEncode } = require('it-length-prefixed')
 const { JoinInit, JoinChallenge, JoinChallengeSolution, JoinVerify, Discovery, DiscoveryAck, DialRequest, DialResponse, ErrorTranslations } = require('./proto')
 
 const sha5 = (data) => crypto.createHash('sha512').update(data).digest()
-const ACK = Buffer.from('01', 'hex')
 
-module.exports = ({ handler, upgrader }, client, options = {}) => {
-  let address, isConnected, aid
-  const listener = new EventEmitter()
+class Listener extends EventEmitter {
+  constructor ({ handler, upgrader}, client, options) {
+    super()
+    this.client = client
+    this.handler = handler
+    this.upgrader = upgrader
+    this.options = options
+
+    this.address = undefined
+    this.isConnected = undefined
+    this.aid = undefined
+  }
 
-  const getDiscovery = async (wrapped) => {
-    if (!isConnected) {
+  async _getDiscovery (wrapped) {
+    if (!this.isConnected) {
       return
     }
 
-    const baseAddr = address.decapsulate('p2p-stardust')
+    const baseAddr = this.address.decapsulate('p2p-stardust')
     let message
 
     try {
@@ -40,49 +48,49 @@ module.exports = ({ handler, upgrader }, client, options = {}) => {
       console.log('discovery catch err')
     }
 
-    if (!client.discovery._isStarted) {
+    if (!this.client.discovery._isStarted) {
       log('reading discovery, but tossing data since it\'s not enabled')
-      console.log('return')
       return
     }
 
     log('reading discovery')
     message.ids
       .map(id => {
         const pi = new PeerInfo(new PeerId(id))
-        if (pi.id.toB58String() === client.id.toB58String()) return
+        if (pi.id.toB58String() === this.client.id.toB58String()) return
         pi.multiaddrs.add(baseAddr.encapsulate('/p2p-stardust/p2p/' + pi.id.toB58String()))
 
-        console.log('pi', pi)
         return pi
       })
       .filter(Boolean)
-      .forEach(pi => client.discovery.emit('peer', pi))
+      .forEach(pi => this.client.discovery.emit('peer', pi))
 
-    setTimeout(() => getDiscovery(wrapped), 100) // cooldown
+    setTimeout(() => this._getDiscovery(wrapped), 100) // cooldown
   }
 
-  const connectServer = async (addr) => {
-    if (isConnected) return
+  async connectServer (addr) {
+    if (this.isConnected) return
 
     log('connecting to %s', addr)
-    address = addr
-    aid = addr.decapsulate('p2p-stardust')
+    this.address = addr
+    this.aid = addr.decapsulate('p2p-stardust')
 
-    const { stream } = await client.libp2p.dialProtocol(aid, '/p2p/stardust/0.1.0')
+    const { stream } = await this.client.libp2p.dialProtocol(this.aid, '/p2p/stardust/0.1.0')
     const wrapped = Wrap(stream, { lengthDecoder: int32BEDecode, lengthEncoder: int32BEEncode })
 
     log('performing challenge')
+
     const random = crypto.randomBytes(128)
+    await wrapped.writePB({ random128: random, peerID: this.client.id.toJSON() }, JoinInit)
 
-    await wrapped.writePB({ random128: random, peerID: client.id.toJSON() }, JoinInit)
+    log('sent rand')
 
     const { error, saltEncrypted } = await wrapped.readPB(JoinChallenge)
     if (error) {
       console.log('error')
     }
 
-    const saltSecret = client.id.privKey.decrypt(saltEncrypted)
+    const saltSecret = this.client.id.privKey.decrypt(saltEncrypted)
     const solution = sha5(random, saltSecret)
     await wrapped.writePB({ solution }, JoinChallengeSolution)
 
@@ -92,36 +100,38 @@ module.exports = ({ handler, upgrader }, client, options = {}) => {
     }
 
     log('connected')
-    console.log('connected')
-    isConnected = true
+
+    this.isConnected = true
+    this.client.connections[String(this.aid)] = this
 
     // -- TODO handler + conn
-    getDiscovery(wrapped)
+    this._getDiscovery(wrapped)
   }
 
-  listener.listen = async (ma) => {
+  async listen (ma) {
     try {
-      await connectServer(ma)
-      listener.emit('listening')
+      await this.connectServer(ma)
+      this.emit('listening')
     } catch (err) {
-      if (client.softFail) {
+      if (this.client.softFail) {
         // dials will fail, but that's just about it
-        listener.emit('listening')
+        this.emit('listening')
         return
       }
-      listener.emit('error', err)
+      this.emit('error', err)
     }
   }
 
-  listener.getAddrs = () => {
-    return address ? [address] : []
+  getAddrs () {
+    return this.address ? [this.address] : []
   }
 
-  listener.close = () => {
-    isConnected = false
-    delete client.connections[String(aid)]
-    listener.emit('close')
+  close () {
+    if (!this.isConnected) return
+    this.isConnected = false // will prevent new conns, but will keep current ones as interface requires it
+    delete this.client.connections[this.aid]
+    this.emit('close')
   }
+}
 
-  return listener
-}
+module.exports = Listener