vrpc 3.0.3 → 3.1.1

package/package.json

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

package/vrpc/VrpcAdapter.js

@@ -350,9 +350,17 @@ class VrpcAdapter {
             ({ tag }) => tag === 'param' || tag === 'arg' || tag === 'argument'
           )
           if (params.length > 0) {
-            params = params.map(({ name, optional, description, type }) => {
-              return { name, optional, description, type }
-            })
+            params = params.map(
+              ({
+                name,
+                optional,
+                description,
+                type,
+                default: defaultValue
+              }) => {
+                return { name, optional, description, type, defaultValue }
+              }
+            )
           } else {
             params = []
           }
@@ -375,7 +383,8 @@ class VrpcAdapter {
                 name: 'instanceName',
                 optional: false,
                 description: 'Name of the instance to be created',
-                type: 'string'
+                type: 'string',
+                defaultValue: undefined
               },
               ...params
             ]
@@ -390,7 +399,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 +417,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) {
@@ -500,7 +508,8 @@ class VrpcAdapter {
   }
 
   static sanitizeEventListenerReturnValues (ret) {
-    return typeof ret === 'object' &&
+    return ret &&
+      typeof ret === 'object' &&
       ret._events !== undefined &&
       ret._eventsCount !== undefined
       ? true
@@ -593,13 +602,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,18 +610,21 @@ class VrpcAdapter {
   }
 
   static _unregisterClient (clientId) {
-    for (const [key, value] of Object.entries(VrpcAdapter._listeners)) {
-      const { instances, event, listener, clients } = value
-      clients.delete(clientId)
-      if (clients.size === 0) {
-        if (event) {
-          instances.forEach(instance => {
-            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) {
+            const instance = VrpcAdapter.getInstance(ik)
+            if (instance && instance.removeListener) {
+              instance.removeListener(event, listener)
+            }
+            delete VrpcAdapter._listeners[ik][ek]
+          }
         }
-        delete VrpcAdapter._listeners[key]
-      }
-    }
+      })
+    })
   }
 
   static _validate (schema, params) {
@@ -630,102 +636,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

@@ -92,7 +92,7 @@ class VrpcAgent extends EventEmitter {
    *
    * @constructor
    * @param {Object} obj
-   * @param {String} [obj.username='<user>-<pathId>@<hostname>-<platform>-js'] MQTT username
+   * @param {String} [obj.username] MQTT username
    * @param {String} [obj.password] MQTT password (if no token is provided)
    * @param {String} [obj.token] Access token
    * @param {String} [obj.domain='vrpc'] The domain under which the agent-provided code is reachable
@@ -101,6 +101,7 @@ class VrpcAgent extends EventEmitter {
    * @param {Object} [obj.log=console] Log object (must support debug, info, warn, and error level)
    * @param {String} [obj.bestEffort=false] If true, message will be sent with best effort, i.e. no caching if offline
    * @param {String} [obj.version=''] The (user-defined) version of this agent
+   * @param {String} [obj.mqttClientId='<generated()>'] Explicitly set the mqtt client id.
    *
    * @example
    * const agent = new Agent({
@@ -109,15 +110,16 @@ class VrpcAgent extends EventEmitter {
    * })
    */
   constructor ({
-    token,
+    username,
     password,
-    username = VrpcAgent._generateAgentName(),
+    token,
     domain = 'vrpc',
     agent = VrpcAgent._generateAgentName(),
     broker = 'mqtts://vrpc.io:8883',
     log = 'console',
     bestEffort = false,
-    version = ''
+    version = '',
+    mqttClientId = null
   } = {}) {
     super()
     this._validateDomain(domain)
@@ -130,7 +132,13 @@ class VrpcAgent extends EventEmitter {
     this._broker = broker
     this._qos = bestEffort ? 0 : 1
     this._version = version
-    this._isReconnect = false
+    this._mqttClientId =
+      mqttClientId ||
+      `va3${crypto
+        .createHash('md5')
+        .update(this._domain + this._agent)
+        .digest('hex')
+        .substring(0, 20)}`
     if (log === 'console') {
       this._log = console
       this._log.debug = () => {}
@@ -165,23 +173,21 @@ class VrpcAgent extends EventEmitter {
    * rejects
    */
   async serve () {
-    const md5 = crypto
-      .createHash('md5')
-      .update(this._domain + this._agent)
-      .digest('hex')
-      .substr(0, 20)
     let username = this._username
     let password = this._password
     if (this._token) {
-      username = username || this._agent
+      username = `${this._domain}/${this._agent}`
       password = this._token
+    } else if (!this._password) {
+      username = `${this._domain}/${this._agent}`
+      password = this._generateToken()
     }
     this._options = {
       username,
       password,
       keepalive: 30,
       connectTimeout: 10 * 1000,
-      clientId: `va3${md5}`,
+      clientId: this._mqttClientId,
       rejectUnauthorized: false,
       will: {
         topic: `${this._baseTopic}/__agentInfo__`,
@@ -194,12 +200,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,16 +239,11 @@ 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}`)
     }
   }
 
-  static _generateUserName () {
-    return `${os.userInfo().username}@${os.hostname()}-${os.platform()}-js`
-  }
-
   static _generateAgentName () {
     const { username } = os.userInfo()
     const pathId = crypto
@@ -258,6 +254,27 @@ class VrpcAgent extends EventEmitter {
     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(/[+/#*]/)) {
@@ -285,27 +302,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,
@@ -328,9 +324,38 @@ class VrpcAgent extends EventEmitter {
       (err, granted) => {
         if (err) {
           this._log.warn(
-            `Could not subscribe to topic '${topic}', because: ${err.message}`
+            `Could not subscribe to topic(s) '${topic}', because: ${err.message}`
           )
         } else {
+          const topicArray = Array.isArray(topic) ? topic : [topic]
+          const erroneousGranted = granted
+            .filter(x => x.qos === 128)
+            .map(x => x.topic)
+          if (erroneousGranted.length > 0) {
+            err = new Error(
+              `Could not subscribe all ${topicArray.length} topic(s) but got error qos=128 on following ${erroneousGranted.length} topic(s): ${erroneousGranted}`
+            )
+            err.code = 'SUBSCRIBE_FAILED'
+            err.subscribeOptions = options
+            this._log.error(err)
+            this.emit('error', err)
+          }
+          const reducedQos = granted.filter(x => x.qos < this._qos)
+          if (reducedQos.length > 0) {
+            err = new Error(
+              `Could not subscribe all ${
+                topicArray.length
+              } topic(s) at desired qos=${
+                this._qos
+              } but got reduced qos on following ${
+                reducedQos.length
+              } topic(s): ${JSON.stringify(reducedQos)}`
+            )
+            err.code = 'SUBSCRIBE_REDUCED_QOS'
+            err.subscribeOptions = options
+            this._log.warn(err)
+            this.emit('error', err)
+          }
           if (granted.length === 0) {
             this._log.debug(`Already subscribed to topic '${topic}'`)
           }
@@ -375,6 +400,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)
       }
     })
   }
@@ -413,16 +440,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)
@@ -670,7 +687,6 @@ class VrpcAgent extends EventEmitter {
   }
 
   _handleReconnect () {
-    this._isReconnect = true
     this._log.warn(`Reconnecting to ${this._broker}`)
     this.emit('reconnect')
   }