vrpc 3.0.1 → 3.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vrpc",
-  "version": "3.0.1",
+  "version": "3.0.4",
   "description": "Variadic Remote Procedure Calls",
   "main": "index.js",
   "directories": {

package/vrpc/VrpcAdapter.js

@@ -390,7 +390,7 @@ class VrpcAdapter {
   }
 
   static _call (json) {
-    const before = Object.keys(VrpcAdapter._listeners).length
+    this._mustTrackClient = false // reset client tracking flag
     switch (json.f) {
       case '__createIsolated__':
         VrpcAdapter._handleCreateIsolated(json)
@@ -408,10 +408,9 @@ class VrpcAdapter {
         // this call may have the side-effect of taking a listener on board
         VrpcAdapter._handleCall(json)
     }
-    const after = Object.keys(VrpcAdapter._listeners).length
     // if we took a listener on board we must tell our caller such that
     // things can be cleaned up later.
-    return after > before
+    return this._mustTrackClient
   }
 
   static _handleCreateIsolated (json) {
@@ -593,13 +592,7 @@ class VrpcAdapter {
       if (VrpcAdapter._isFunction(entry.removeAllListeners)) {
         entry.removeAllListeners()
       }
-      for (const [key, { clients, instance }] of Object.entries(
-        VrpcAdapter._listeners
-      )) {
-        if (instance === instanceId) {
-          VrpcAdapter._listeners[key] = { clients }
-        }
-      }
+      delete VrpcAdapter._listeners[instanceId]
       VrpcAdapter._instances.delete(instanceId)
       return true
     }
@@ -607,16 +600,18 @@ class VrpcAdapter {
   }
 
   static _unregisterClient (clientId) {
-    for (const [key, value] of Object.entries(VrpcAdapter._listeners)) {
-      const { instance, event, listener, clients } = value
-      clients.delete(clientId)
-      if (clients.size === 0) {
-        if (event) {
-          VrpcAdapter.getInstance(instance).removeListener(event, listener)
+    Object.entries(VrpcAdapter._listeners).forEach(([ik, iv]) => {
+      Object.entries(iv).forEach(([ek, ev]) => {
+        const { clients, listener, event } = ev
+        if (clients.has(clientId)) {
+          clients.delete(clientId)
+          if (clients.size === 0) {
+            VrpcAdapter.getInstance(ik).removeListener(event, listener)
+            delete VrpcAdapter._listeners[ik][ek]
+          }
         }
-        delete VrpcAdapter._listeners[key]
-      }
-    }
+      })
+    })
   }
 
   static _validate (schema, params) {
@@ -628,102 +623,162 @@ class VrpcAdapter {
   }
 
   static _unwrapArguments (json, instanceId) {
-    const sender = json.s
-    let context = json.c
-    let func = json.f
-    let args = json.a
-    // things are different if we came from callAll (instanceId !== undefined)
-    if (instanceId) {
-      context = instanceId
-      func = args[0]
-      args = args.slice(1)
-    }
-    const unwrapped = instanceId ? [func] : []
+    const clientId = json.s
+    // if we came from a "callAll" we will have an instanceId defined
+    // things are different for callAll as we have to dispatch the instanceIds
+    const isCallAll = instanceId !== undefined
+    const context = isCallAll ? instanceId : json.c
+    const args = isCallAll ? json.a.slice(1) : json.a
+    const func = isCallAll ? json.a[0] : json.f
+    const unwrapped = isCallAll ? [func] : []
     for (const arg of args) {
-      // find those args that actually need to be functions
-      if (typeof arg === 'string' && arg.slice(0, 5) === '__f__') {
-        const callback = this._generateCallback(arg, sender, instanceId)
-        unwrapped.push(callback)
-      } else if (typeof arg === 'string' && arg.slice(0, 5) === '__e__') {
-        const listener = this._generateListener(arg, sender, instanceId)
-        unwrapped.push(listener)
-        // start tracking clients that are registering event listeners
-        if (!VrpcAdapter._listeners[arg]) {
-          VrpcAdapter._listeners[arg] = {
-            listener,
-            clients: new Set([sender]),
-            instances: new Set(),
-            event: null
+      if (typeof arg === 'string') {
+        if (arg.startsWith('__f__')) {
+          // function callback
+          unwrapped.push(
+            this._generateCallback({
+              clientId,
+              isCallAll,
+              instanceId: context,
+              eventId: arg
+            })
+          )
+        } else if (arg.startsWith('__e__')) {
+          // event registration
+          if (func === 'on' || func === 'addListener') {
+            this._mustTrackClient = true
+            const listener = VrpcAdapter._registerListener({
+              clientId,
+              isCallAll,
+              instanceId: context,
+              eventId: arg,
+              event: args[0]
+            })
+            if (
+              VrpcAdapter.getInstance(context)
+                .listeners(arg)
+                .includes(listener)
+            ) {
+              return null // skip call as listener is already registered
+            }
+            unwrapped.push(listener)
+            // event un-registration
+          } else if (func === 'off' || func === 'removeListener') {
+            const listener = VrpcAdapter._unregisterListener({
+              clientId,
+              instanceId: context,
+              eventId: arg
+            })
+            if (!listener) {
+              return null // skip call as others are still interested
+            }
+            unwrapped.push(listener)
+          } else {
+            this._mustTrackClient = true
+            const listener = VrpcAdapter._registerListener({
+              clientId,
+              isCallAll,
+              instanceId: context,
+              eventId: arg,
+              event: null
+            })
+            unwrapped.push(listener)
           }
         } else {
-          VrpcAdapter._listeners[arg].clients.add(sender)
-        }
-        // see whether the requested listener is an EventEmitter registration
-        if (func === 'on' || func === 'addListener') {
-          // if this event is already registered on the given instance
-          // avoid a second registration
-          if (
-            VrpcAdapter._listeners[arg].event &&
-            VrpcAdapter._listeners[arg].instances.has(context)
-          ) {
-            return null // means that this call won't be forwarded
-          }
-          VrpcAdapter._listeners[arg].event = args[0]
-          VrpcAdapter._listeners[arg].instances.add(context)
-        }
-        if (func === 'off' || func === 'removeListener') {
-          const {
-            clients,
-            instances,
-            listener,
-            event
-          } = VrpcAdapter._listeners[arg]
-          clients.delete(sender)
-          instances.delete(context)
-          if (clients.size === 0) {
-            delete VrpcAdapter._listeners[arg]
-            VrpcAdapter.getInstance(context).off(event, listener)
-          }
-          return null // means that this call won't be forwarded
+          unwrapped.push(arg)
         }
       } else {
-        // default behavior is to not touch
+        // regular argument
         unwrapped.push(arg)
       }
     }
     return unwrapped
   }
 
-  static _removeAllListeners (event, sender, context) {
-    for (const [key, value] of Object.entries(VrpcAdapter._listeners)) {
-      if (value.event === event) {
-        value.clients.delete(sender)
-        if (value.clients.size === 0) {
-          delete VrpcAdapter._listeners[key]
-          VrpcAdapter.getInstance(context).off(event, value.listener)
+  static _generateCallback ({ eventId, clientId, instanceId, isCallAll }) {
+    return (...innerArgs) => {
+      // "callAll" event notifications expect the instanceId as first argument
+      const a = isCallAll ? [instanceId, ...innerArgs] : [...innerArgs]
+      VrpcAdapter._callback({ a, s: clientId, i: eventId })
+    }
+  }
+
+  static _registerListener ({
+    eventId,
+    clientId,
+    instanceId,
+    event,
+    isCallAll
+  }) {
+    if (!VrpcAdapter._listeners[instanceId]) {
+      VrpcAdapter._listeners[instanceId] = {
+        [eventId]: {
+          event,
+          clients: new Set([clientId]),
+          listener: VrpcAdapter._generateListener({
+            eventId,
+            instanceId,
+            isCallAll
+          })
         }
       }
+    } else if (!VrpcAdapter._listeners[instanceId][eventId]) {
+      VrpcAdapter._listeners[instanceId][eventId] = {
+        event,
+        clients: new Set([clientId]),
+        listener: VrpcAdapter._generateListener({
+          eventId,
+          instanceId,
+          isCallAll
+        })
+      }
+    } else {
+      VrpcAdapter._listeners[instanceId][eventId].clients.add(clientId)
     }
+    return VrpcAdapter._listeners[instanceId][eventId].listener
   }
 
-  static _generateCallback (id, sender, instanceId) {
+  static _generateListener ({ eventId, instanceId, isCallAll }) {
     return (...innerArgs) => {
-      // callAll expects the instanceId as first argument
-      const a = instanceId ? [instanceId, ...innerArgs] : [...innerArgs]
-      VrpcAdapter._callback({ a, s: sender, i: id })
+      const a = isCallAll ? [instanceId, ...innerArgs] : [...innerArgs]
+      VrpcAdapter._callback({ a, i: eventId })
     }
   }
 
-  static _generateListener (id, sender, instanceId) {
-    return (...innerArgs) => {
-      // do not even emit for already offline clients
-      if (!VrpcAdapter._listeners[id]) return
-      // callAll expects the instanceId as first argument
-      const a = instanceId ? [instanceId, ...innerArgs] : [...innerArgs]
-      VrpcAdapter._callback({ a, s: sender, i: id })
+  static _unregisterListener ({ eventId, clientId, instanceId }) {
+    if (
+      VrpcAdapter._listeners[instanceId] &&
+      VrpcAdapter._listeners[instanceId][eventId]
+    ) {
+      const { listener, clients } = VrpcAdapter._listeners[instanceId][eventId]
+      clients.delete(clientId)
+      if (clients.size === 0) {
+        delete VrpcAdapter._listeners[instanceId][eventId]
+        if (Object.keys(VrpcAdapter._listeners[instanceId]).length === 0) {
+          delete VrpcAdapter._listeners[instanceId]
+        }
+        return listener
+      }
     }
   }
 
+  static _removeAllListeners (event, clientId, instanceId) {
+    const eventIds = VrpcAdapter._listeners[instanceId]
+    if (!eventIds) return
+    Object.entries(eventIds).forEach(([ek, ev]) => {
+      if (ev.event === event && ev.clients.has(clientId)) {
+        ev.clients.delete(clientId)
+        if (ev.clients.size === 0) {
+          VrpcAdapter.getInstance(instanceId).removeListener(
+            ev.event,
+            ev.listener
+          )
+          delete VrpcAdapter._listeners[instanceId][ek]
+        }
+      }
+    })
+  }
+
   static _handlePromise (json, promise) {
     try {
       const cid = VrpcAdapter._correlationId++ % Number.MAX_SAFE_INTEGER

package/vrpc/VrpcAgent.js

@@ -48,7 +48,7 @@ class VrpcAgent extends EventEmitter {
     })
     parser.add_argument('-d', '--domain', {
       help: 'Domain name',
-      default: domain || 'public.vrpc'
+      default: domain || 'vrpc'
     })
     parser.add_argument('-t', '--token', {
       help: 'access token',
@@ -92,10 +92,10 @@ class VrpcAgent extends EventEmitter {
    *
    * @constructor
    * @param {Object} obj
-   * @param {String} [obj.username] MQTT username (if no token is used)
+   * @param {String} [obj.username] MQTT username
    * @param {String} [obj.password] MQTT password (if no token is provided)
-   * @param {String} [obj.token] Access token as generated by: https://app.vrpc.io (only optional when using default domain and broker)
-   * @param {String} [obj.domain='public.vrpc'] The domain under which the agent-provided code is reachable
+   * @param {String} [obj.token] Access token
+   * @param {String} [obj.domain='vrpc'] The domain under which the agent-provided code is reachable
    * @param {String} [obj.agent='<user>-<pathId>@<hostname>-<platform>-js'] This agent's name
    * @param {String} [obj.broker='mqtts://vrpc.io:8883'] Broker url in form: `<scheme>://<host>:<port>`
    * @param {Object} [obj.log=console] Log object (must support debug, info, warn, and error level)
@@ -104,7 +104,7 @@ class VrpcAgent extends EventEmitter {
    *
    * @example
    * const agent = new Agent({
-   *   domain: 'public.vrpc'
+   *   domain: 'vrpc'
    *   agent: 'myAgent'
    * })
    */
@@ -112,7 +112,7 @@ class VrpcAgent extends EventEmitter {
     username,
     password,
     token,
-    domain = 'public.vrpc',
+    domain = 'vrpc',
     agent = VrpcAgent._generateAgentName(),
     broker = 'mqtts://vrpc.io:8883',
     log = 'console',
@@ -130,7 +130,6 @@ class VrpcAgent extends EventEmitter {
     this._broker = broker
     this._qos = bestEffort ? 0 : 1
     this._version = version
-    this._isReconnect = false
     if (log === 'console') {
       this._log = console
       this._log.debug = () => {}
@@ -169,12 +168,15 @@ class VrpcAgent extends EventEmitter {
       .createHash('md5')
       .update(this._domain + this._agent)
       .digest('hex')
-      .substr(0, 20)
+      .substring(0, 20)
     let username = this._username
     let password = this._password
     if (this._token) {
-      username = '__token__'
+      username = `${this._domain}:${this._agent}`
       password = this._token
+    } else if (!this._password) {
+      username = `${this._domain}:${this._agent}`
+      password = this._generateToken()
     }
     this._options = {
       username,
@@ -194,12 +196,7 @@ class VrpcAgent extends EventEmitter {
     this._log.info(`Agent  : ${this._agent}`)
     this._log.info(`Broker : ${this._broker}`)
     this._log.info('Connecting to MQTT server...')
-    const wasEnded = await this._clearPersistedSession()
-    if (wasEnded) return
-    this._client = mqtt.connect(this._broker, {
-      ...this._options,
-      clean: false
-    })
+    this._client = mqtt.connect(this._broker, this._options)
     this._client.on('connect', this._handleConnect.bind(this))
     this._client.on('reconnect', this._handleReconnect.bind(this))
     this._client.on('error', this._handleError.bind(this))
@@ -238,7 +235,6 @@ class VrpcAgent extends EventEmitter {
         }
       }
       await new Promise(resolve => this._client.end(false, {}, resolve))
-      await this._clearPersistedSession()
     } catch (err) {
       this._log.error(err, `Problem during disconnecting agent: ${err.message}`)
     }
@@ -250,10 +246,31 @@ class VrpcAgent extends EventEmitter {
       .createHash('md5')
       .update(path.resolve())
       .digest('hex')
-      .substr(0, 4)
+      .substring(0, 4)
     return `${username}-${pathId}@${os.hostname()}-${os.platform()}-js`
   }
 
+  _generateToken () {
+    const uid =
+      this._domain +
+      this._agent +
+      os.userInfo().username +
+      path.resolve() +
+      os.arch() +
+      os.homedir() +
+      os.hostname() +
+      os.platform() +
+      os.release() +
+      os.totalmem() +
+      os.type() +
+      JSON.stringify(os.networkInterfaces()) +
+      JSON.stringify(os.cpus().map(({ model }) => model))
+    return crypto
+      .createHash('md5')
+      .update(uid)
+      .digest('hex')
+  }
+
   _validateDomain (domain) {
     if (!domain) throw new Error('The domain must be specified')
     if (domain.match(/[+/#*]/)) {
@@ -281,27 +298,6 @@ class VrpcAgent extends EventEmitter {
     })
   }
 
-  /**
-   * @return {Boolean} true if `agent.end()` was explicitly called
-   */
-  async _clearPersistedSession () {
-    // Clear potentially existing persisted sessions
-    const client = mqtt.connect(this._broker, { ...this._options, clean: true })
-    client.on('error', err => this.emit('error', err))
-    client.on('offline', () => this.emit('offline'))
-    client.on('reconnect', () => this.emit('reconnect'))
-    return new Promise(resolve => {
-      client.on('connect', () => {
-        client.end(false, {}, () => resolve(false))
-      })
-      // Will be triggered if the user called 'agent.end()'
-      this.once('end', () => {
-        client.end()
-        resolve(true)
-      })
-    })
-  }
-
   _mqttPublish (topic, message, options) {
     this._client.publish(
       topic,
@@ -371,6 +367,8 @@ class VrpcAgent extends EventEmitter {
         resolve()
       } else {
         this._client.once('connect', resolve)
+        // Will be triggered if the user called 'agent.end()'
+        this.once('end', resolve)
       }
     })
   }
@@ -409,16 +407,6 @@ class VrpcAgent extends EventEmitter {
 
   _handleConnect () {
     this._log.info('[OK]')
-    if (this._isReconnect) {
-      this._publishAgentInfoMessage()
-      const classes = this._getClasses()
-      classes.forEach(className => {
-        this._publishClassInfoMessage(className)
-      })
-      this.emit('connect')
-      this._isReconnect = false
-      return
-    }
     try {
       const topics = this._generateTopics()
       if (topics.length > 0) this._mqttSubscribe(topics)
@@ -666,7 +654,6 @@ class VrpcAgent extends EventEmitter {
   }
 
   _handleReconnect () {
-    this._isReconnect = true
     this._log.warn(`Reconnecting to ${this._broker}`)
     this.emit('reconnect')
   }

package/vrpc/VrpcClient.js

@@ -59,9 +59,9 @@ class VrpcClient extends EventEmitter {
    *
    * @constructor
    * @param {Object} options
-   * @param {String} options.token Access token as generated by: https://app.vrpc.io
-   * @param {String} options.username MQTT username (if no token is used)
-   * @param {String} options.password MQTT password (if no token is provided)
+   * @param {String} [options.username] MQTT username
+   * @param {String} [options.password] MQTT password (if no token is provided)
+   * @param {String} [options.token] Access token
    * @param {String} options.domain Sets the domain
    * @param {String} [options.agent="*"] Sets default agent
    * @param {String} [options.broker="mqtts://vrpc.io:8883"] Broker url in form: `<scheme>://<host>:<port>`
@@ -70,14 +70,14 @@ class VrpcClient extends EventEmitter {
    * @param {Boolean} [options.bestEffort=false] If true, message will be sent with best effort, i.e. no caching if offline
    * @example
    * const client = new VrpcClient({
-   *   domain: 'public.vrpc',
+   *   domain: 'vrpc',
    *   broker: 'mqtt://vrpc.io'
    * })
    */
   constructor ({
     token,
-    username,
     password,
+    username,
     domain,
     agent = '*',
     broker = 'mqtts://vrpc.io:8883',
@@ -152,7 +152,7 @@ class VrpcClient extends EventEmitter {
     let username = this._username
     let password = this._password
     if (this._token) {
-      username = '__token__'
+      username = username || this._generateUserName()
       password = this._token
     }
     const options = {
@@ -660,10 +660,13 @@ class VrpcClient extends EventEmitter {
     return new Promise(resolve => this._client.end(false, {}, resolve))
   }
 
+  _generateUserName () {
+    return `${this._domain}:client@${os.hostname()}-${os.platform()}-js`
+  }
+
   _createMqttClientId () {
     const clientInfo =
       os.arch() +
-      JSON.stringify(os.cpus()) +
       os.homedir() +
       os.hostname() +
       JSON.stringify(os.networkInterfaces()) +
@@ -694,6 +697,12 @@ class VrpcClient extends EventEmitter {
           this._log.warn(
             `Could not publish MQTT message because: ${err.message}`
           )
+          if (err.message === 'client disconnecting') {
+            // Workaround for an already reported bug in MQTT.js (#1284)
+            this._log.info('Forcing reconnect now...')
+            this._client.disconnecting = false
+            this._client.end(true, {}, () => this._client.reconnect())
+          }
         }
       }
     )
@@ -708,6 +717,12 @@ class VrpcClient extends EventEmitter {
           this._log.warn(
             `Could not subscribe to topic: ${topic} because: ${err.message}`
           )
+          if (err.message === 'client disconnecting') {
+            // Workaround for an already reported bug in MQTT.js (#1284)
+            this._log.info('Forcing reconnect now...')
+            this._client.disconnecting = false
+            this._client.end(true, {}, () => this._client.reconnect())
+          }
         } else {
           if (granted.length === 0) {
             this._log.debug(`Already subscribed to: ${topic}`)
@@ -933,7 +948,8 @@ class VrpcClient extends EventEmitter {
           if (typeof ret === 'string' && ret.substring(0, 5) === '__p__') {
             this._eventEmitter.once(ret, promiseData => {
               // TODO improve error message here, like above
-              if (promiseData.e) reject(new Error(`[vrpc ${agent}-${c}-${f}]: ${promiseData.e}`))
+              if (promiseData.e)
+                reject(new Error(`[vrpc ${agent}-${c}-${f}]: ${promiseData.e}`))
               else resolve(promiseData.r)
             })
           } else {
@@ -1068,7 +1084,9 @@ class VrpcClient extends EventEmitter {
       : `${this._domain}/${agent}/${className}/${event}`
     const id = `__e__${topic}`
     if (this._cachedSubscriptions[topic]) {
-      const index = this._cachedSubscriptions[topic].findIndex(x => x.callback === callback)
+      const index = this._cachedSubscriptions[topic].findIndex(
+        x => x.callback === callback
+      )
       if (index === -1) {
         this._log.warn(`Failed removing event listener ${id}`)
         return null

package/vrpc/vrpc-agent-js

@@ -23,7 +23,7 @@ parser.add_argument(
   {
     help: 'The prefix for all vrpc communication',
     type: 'string',
-    default: 'public.vrpc'
+    default: 'vrpc'
   }
 )
 parser.add_argument(