vrpc 3.1.0 → 3.2.0

package/vrpc/VrpcClient.js

@@ -65,11 +65,13 @@ class VrpcClient extends EventEmitter {
    * @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>`
-   * @param {Number} [options.timeout=6000] Maximum time in ms to wait for a RPC answer
+   * @param {Number} [options.timeout=12000] Maximum time in ms to wait for a RPC answer
    * @param {Object} [options.log=console] Log object (must support debug, info, warn, and error level)
-   * @param {Boolean} [options.bestEffort=false] If true, message will be sent with best effort, i.e. no caching if offline
+   * @param {Boolean} [options.bestEffort=true] If true, message will be sent with best effort, i.e. no caching if offline
    * @param {String} [options.mqttClientId='<generated()>'] Explicitly sets the mqtt client id
    * @param {String} [options.identity] Explicitly sets a vrpc client identity
+   * @param {String} [options.keepalive] Sets the MQTT keepalive interval (in seconds)
+   * @param {Boolean} [options.requiresSchema=false] If true, any available schema information is shipped
    * @example
    * const client = new VrpcClient({
    *   domain: 'vrpc',
@@ -83,11 +85,13 @@ class VrpcClient extends EventEmitter {
     domain,
     agent = '*',
     broker = 'mqtts://vrpc.io:8883',
-    timeout = 6 * 1000,
+    timeout = 12 * 1000,
     log = 'console',
-    bestEffort = false,
+    bestEffort = true,
     mqttClientId = null,
-    identity = null
+    identity = null,
+    keepalive = 30,
+    requiresSchema = false
   } = {}) {
     super()
     // domain sanity check
@@ -117,7 +121,9 @@ class VrpcClient extends EventEmitter {
     this._broker = broker
     this._timeout = timeout
     this._identity = identity
+    this._keepalive = keepalive
     this._qos = this._qos = bestEffort ? 0 : 1
+    this._requiresSchema = requiresSchema
 
     this._instance = nanoid(8)
     this._mqttClientId = mqttClientId || this._createMqttClientId()
@@ -170,7 +176,7 @@ class VrpcClient extends EventEmitter {
       username,
       password,
       clean: true,
-      keepalive: 30,
+      keepalive: this._keepalive,
       clientId: this._mqttClientId,
       rejectUnauthorized: false,
       connectTimeout: this._timeout,
@@ -201,7 +207,11 @@ class VrpcClient extends EventEmitter {
       // Agent info
       this._mqttSubscribe(`${this._domain}/${agent}/__agentInfo__`)
       // Class info
-      this._mqttSubscribe(`${this._domain}/${agent}/+/__classInfo__`)
+      if (this._requiresSchema) {
+        this._mqttSubscribe(`${this._domain}/${agent}/+/__classInfo__`)
+      } else {
+        this._mqttSubscribe(`${this._domain}/${agent}/+/__classInfoConcise__`)
+      }
       // RPC responses
       this._mqttSubscribe(this._vrpcClientId)
       this.emit('connect')
@@ -222,10 +232,16 @@ class VrpcClient extends EventEmitter {
         this._agents[agent].status = status
         this._agents[agent].hostname = hostname
         this._agents[agent].version = version
+        if (status === 'offline') {
+          this._clearCachedSubscriptions({ lostAgent: agent })
+        }
         this.emit('agent', { domain, agent, status, hostname, version })
         // ClassInfo message
-      } else if (instance === '__classInfo__') {
-        // Json properties: { klass, instances, memberFunctions, staticFunctions }
+      } else if (
+        instance === '__classInfo__' ||
+        instance === '__classInfoConcise__'
+      ) {
+        // Json properties: { className, instances, memberFunctions, staticFunctions }
         const json = JSON.parse(message.toString())
         this._createIfNotExist(agent)
         const oldClassInfo = this._agents[agent].classes[klass]
@@ -234,15 +250,13 @@ class VrpcClient extends EventEmitter {
         const removed = oldInstances.filter(x => !newInstances.includes(x))
         const added = newInstances.filter(x => !oldInstances.includes(x))
         this._agents[agent].classes[klass] = json
-        const {
-          className,
-          instances,
-          memberFunctions,
-          staticFunctions,
-          meta
-        } = json
+        const { className, instances, memberFunctions, staticFunctions, meta } =
+          json
         if (removed.length !== 0) {
           this.emit('instanceGone', removed, { domain, agent, className })
+          removed.forEach(lostInstance =>
+            this._clearCachedSubscriptions({ lostInstance })
+          )
         }
         if (added.length !== 0) {
           this.emit('instanceNew', added, { domain, agent, className })
@@ -254,7 +268,7 @@ class VrpcClient extends EventEmitter {
           instances,
           memberFunctions,
           staticFunctions,
-          meta
+          meta: meta || {}
         })
         // RPC message
       } else {
@@ -710,10 +724,12 @@ class VrpcClient extends EventEmitter {
             `Could not publish MQTT message because: ${err.message}`
           )
           if (err.message === 'client disconnecting') {
-            // Workaround for an already reported bug in MQTT.js (#1284)
+            // This most certainly relates to a bug in MQTT.js (#1284)
+            this._log.error(`Failed to publish, because: ${err.message}`)
+            this.emit('error', err)
             this._log.info('Forcing reconnect now...')
             this._client.disconnecting = false
-            this._client.end(true, {}, () => this._client.reconnect())
+            this._client.reconnect()
           }
         }
       }
@@ -730,10 +746,12 @@ class VrpcClient extends EventEmitter {
             `Could not subscribe to topic(s): '${topic}', because: ${err.message}`
           )
           if (err.message === 'client disconnecting') {
-            // Workaround for an already reported bug in MQTT.js (#1284)
+            // This most certainly relates to a bug in MQTT.js (#1284)
+            this._log.error(`Failed to subscribe, because: ${err.message}`)
+            this.emit('error', err)
             this._log.info('Forcing reconnect now...')
             this._client.disconnecting = false
-            this._client.end(true, {}, () => this._client.reconnect())
+            this._client.reconnect()
           }
         } else {
           const topicArray = Array.isArray(topic) ? topic : [topic]
@@ -880,8 +898,9 @@ class VrpcClient extends EventEmitter {
               c: instance,
               f: functionName,
               a: [eventName],
-              i: `${this._instance}-${this._invokeId++ %
-                Number.MAX_SAFE_INTEGER}`,
+              i: `${this._instance}-${
+                this._invokeId++ % Number.MAX_SAFE_INTEGER
+              }`,
               s: this._vrpcClientId,
               v: VRPC_PROTOCOL_VERSION
             }
@@ -913,8 +932,9 @@ class VrpcClient extends EventEmitter {
             c: instance,
             f: functionName,
             a: wrapped,
-            i: `${this._instance}-${this._invokeId++ %
-              Number.MAX_SAFE_INTEGER}`,
+            i: `${this._instance}-${
+              this._invokeId++ % Number.MAX_SAFE_INTEGER
+            }`,
             s: this._vrpcClientId,
             v: VRPC_PROTOCOL_VERSION
           }
@@ -947,8 +967,9 @@ class VrpcClient extends EventEmitter {
             c: instance,
             f: functionName,
             a: wrapped.slice(1), // first argument was remote function name
-            i: `${this._instance}-${this._invokeId++ %
-              Number.MAX_SAFE_INTEGER}`,
+            i: `${this._instance}-${
+              this._invokeId++ % Number.MAX_SAFE_INTEGER
+            }`,
             s: this._vrpcClientId,
             v: VRPC_PROTOCOL_VERSION
           }
@@ -982,16 +1003,23 @@ class VrpcClient extends EventEmitter {
       this._eventEmitter.once(i, data => {
         clearTimeout(timer)
         if (data.e) {
-          reject(new Error(`[vrpc ${agent}-${c}-${f}]: ${data.e}`))
+          const { message, cause } = VrpcClient._prepareError(data.e)
+          reject(new Error(`[vrpc ${agent}-${c}-${f}]: ${message}`, { cause }))
         } else {
           const ret = data.r
           // Handle functions returning a promise
           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}`))
-              else resolve(promiseData.r)
+              if (promiseData.e) {
+                const { message, cause } = VrpcClient._prepareError(
+                  promiseData.e
+                )
+                reject(
+                  new Error(`[vrpc ${agent}-${c}-${f}]: ${message}`, { cause })
+                )
+              } else {
+                resolve(promiseData.r)
+              }
             })
           } else {
             resolve(ret)
@@ -1001,17 +1029,26 @@ class VrpcClient extends EventEmitter {
     })
   }
 
+  static _prepareError (rpcError) {
+    if (typeof rpcError === 'object') {
+      return { message: rpcError.message, cause: rpcError.cause }
+    }
+    return { message: rpcError, cause: undefined }
+  }
+
   async _waitForInstance (instance, options = {}) {
     return new Promise((resolve, reject) => {
-      const handler = timer => (instances, { agent, className }) => {
-        if (instances.includes(instance)) {
-          if (options.agent && agent !== options.agent) return
-          if (options.className && className !== options.className) return
-          clearTimeout(timer)
-          this.removeListener('instanceNew', handler)
-          resolve({ agent, className, instance })
+      const handler =
+        timer =>
+        (instances, { agent, className }) => {
+          if (instances.includes(instance)) {
+            if (options.agent && agent !== options.agent) return
+            if (options.className && className !== options.className) return
+            clearTimeout(timer)
+            this.removeListener('instanceNew', handler)
+            resolve({ agent, className, instance })
+          }
         }
-      }
       const timer = setTimeout(() => {
         this.removeListener('instanceNew', handler(timer))
         const msg = `Could not find instance: ${instance} (> ${this._timeout} ms)`
@@ -1068,8 +1105,9 @@ class VrpcClient extends EventEmitter {
         } else {
           // Regular function callback (can be static or member function)
           const remoteId = proxyId || `${agent}-${className}`
-          const id = `__f__${remoteId}-${functionName}-${i}-${this._invokeId++ %
-            Number.MAX_SAFE_INTEGER}`
+          const id = `__f__${remoteId}-${functionName}-${i}-${
+            this._invokeId++ % Number.MAX_SAFE_INTEGER
+          }`
           wrapped.push(id)
           this._eventEmitter.once(id, ({ a }) => x.apply(null, a))
           continue
@@ -1147,6 +1185,29 @@ class VrpcClient extends EventEmitter {
     return id
   }
 
+  _clearCachedSubscriptions ({ lostAgent, lostInstance }) {
+    const obsoleteTopics = Object.keys(this._cachedSubscriptions).filter(
+      topic => {
+        const [, agent, , instanceEvent] = topic.split('/')
+        const [instance] = instanceEvent.split(':')
+        if (agent === lostAgent || instance === lostInstance) {
+          return true
+        }
+        return false
+      }
+    )
+    obsoleteTopics.forEach(topic => {
+      const id = `__e__${topic}`
+      this._log.info(`Clearing subscriptions for obsolete topic: ${topic}`)
+      const subscriptions = this._cachedSubscriptions[topic]
+      subscriptions.forEach(({ handler }) => {
+        this._eventEmitter.removeListener(id, handler)
+      })
+      this._mqttUnsubscribe(topic)
+      delete this._cachedSubscriptions[topic]
+    })
+  }
+
   _stripSignature (method) {
     const pos = method.indexOf('-')
     if (pos > 0) return method.substring(0, pos)
@@ -1164,7 +1225,7 @@ class VrpcClient extends EventEmitter {
 
   _isEmitter (variable) {
     return (
-      typeof variable === 'object' &&
+      variable && typeof variable === 'object' &&
       variable.hasOwnProperty('emitter') &&
       variable.hasOwnProperty('event') &&
       typeof variable.emitter === 'object' &&