vrpc 3.5.2 → 3.5.3

package/package.json

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

package/vrpc/VrpcClient.js

@@ -136,6 +136,8 @@ class VrpcClient extends EventEmitter {
     this._proxies = {}
     this._callbackIds = new WeakMap()
     this._emitterListener = new WeakMap()
+    this._pendingSubscriptions = new Map()
+    this._pendingUnsubscriptions = new Map()
     if (log === 'console') {
       this._log = console
       this._log.debug = () => {}
@@ -200,6 +202,7 @@ class VrpcClient extends EventEmitter {
       this._log.warn('MQTT client went offline.')
       // Clear the cache to ensure a fresh state upon reconnection
       this._agents = {}
+      this._proxies = {}
       this.emit('offline')
     })
 
@@ -216,27 +219,37 @@ class VrpcClient extends EventEmitter {
       this.emit('error', err)
     })
 
-    this._client.on('connect', () => {
-      // This will give us an overview of all remotely available classes
-      const agent = this._agent === '*' ? '+' : this._agent
-      // Agent info
-      this._mqttSubscribe(`${this._domain}/${agent}/__agentInfo__`)
-      // Class info
-      if (this._requiresSchema) {
-        this._mqttSubscribe(`${this._domain}/${agent}/+/__classInfo__`)
-      } else {
-        this._mqttSubscribe(`${this._domain}/${agent}/+/__classInfoConcise__`)
-      }
-      // RPC responses
-      this._mqttSubscribe(this._vrpcClientId)
-
-      // Re-subscribe to all cached event topics
-      this._log.info('Restoring event subscriptions after reconnect...')
-      for (const topic of Object.keys(this._cachedSubscriptions)) {
-        this._mqttSubscribe(topic)
-      }
-
+    this._client.on('connect', async () => {
+      // forward the good news
       this.emit('connect')
+      try {
+        // This will give us an overview of all remotely available classes
+        const agent = this._agent === '*' ? '+' : this._agent
+        // Agent info
+        await this._mqttSubscribe(`${this._domain}/${agent}/__agentInfo__`)
+        // Class info
+        if (this._requiresSchema) {
+          await this._mqttSubscribe(`${this._domain}/${agent}/+/__classInfo__`)
+        } else {
+          await this._mqttSubscribe(
+            `${this._domain}/${agent}/+/__classInfoConcise__`
+          )
+        }
+        // RPC responses
+        await this._mqttSubscribe(this._vrpcClientId)
+
+        // Re-subscribe to all cached event topics
+        this._log.debug('Restoring event subscriptions after reconnect...')
+        const promises = []
+        for (const topic of Object.keys(this._cachedSubscriptions)) {
+          promises.push(this._mqttSubscribe(topic))
+        }
+        await Promise.allSettled(promises)
+      } catch (err) {
+        this._log.error(
+          `Encountered issue while setting up subscriptions after connect: ${err.message}`
+        )
+      }
     })
 
     this._client.on('message', (topic, message) => {
@@ -327,7 +340,6 @@ class VrpcClient extends EventEmitter {
         resolve()
       })
     })
-    // --------------------------------------------------------------------------------
   }
 
   /**
@@ -456,25 +468,7 @@ class VrpcClient extends EventEmitter {
     const topic = `${this._domain}/${agent}/${className}/__static__/__delete__`
     this._mqttPublish(topic, JSON.stringify(json))
     if (this._proxies[instance]) delete this._proxies[instance]
-    const result = await this._handleAgentAnswer(json, agent)
-    // Now that deletion is confirmed, proactively update all local caches
-    if (result) {
-      // 1. Remove from the proxy cache
-      if (this._proxies[instance]) {
-        delete this._proxies[instance]
-      }
-      // 2. Remove from the main agent/instance cache
-      if (this._agents[agent] && this._agents[agent].classes) {
-        const classInfo = this._agents[agent].classes[className]
-        if (classInfo && classInfo.instances) {
-          const index = classInfo.instances.indexOf(instance)
-          if (index > -1) {
-            classInfo.instances.splice(index, 1)
-          }
-        }
-      }
-    }
-    return result
+    return this._handleAgentAnswer(json, agent)
   }
 
   /**
@@ -496,7 +490,7 @@ class VrpcClient extends EventEmitter {
     if (!this._isConnected()) {
       throw new Error('Client is not connected')
     }
-    const wrapped = this._wrapArguments({
+    const wrapped = await this._wrapArguments({
       agent,
       className,
       functionName,
@@ -559,7 +553,7 @@ class VrpcClient extends EventEmitter {
       const agents = this.getAvailableAgents()
       for (const agent of agents) {
         const topic = `${this._domain}/${agent}/${className}/__static__/__callAll__`
-        const wrapped = this._wrapArguments({
+        const wrapped = await this._wrapArguments({
           agent,
           className,
           functionName,
@@ -575,7 +569,7 @@ class VrpcClient extends EventEmitter {
       return result
     }
     const topic = `${this._domain}/${agent}/${className}/__static__/__callAll__`
-    const wrapped = this._wrapArguments({
+    const wrapped = await this._wrapArguments({
       agent,
       className,
       functionName,
@@ -848,68 +842,77 @@ class VrpcClient extends EventEmitter {
     )
   }
 
-  _mqttSubscribe (topic, options) {
-    this._client.subscribe(
-      topic,
-      { qos: this._qos, ...options },
-      (err, granted) => {
-        if (err) {
-          this._log.warn(
-            `Could not subscribe to topic(s): '${topic}', because: ${err.message}`
-          )
-          if (err.message === 'client disconnecting') {
-            // 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.reconnect()
-          }
-        } 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)}`
+  async _mqttSubscribe (topic, options) {
+    return new Promise((resolve, reject) => {
+      this._client.subscribe(
+        topic,
+        { qos: this._qos, ...options },
+        (err, granted) => {
+          if (err) {
+            this._log.warn(
+              `Could not subscribe to topic(s): '${topic}', because: ${err.message}`
             )
-            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}`)
+            if (err.message === 'client disconnecting') {
+              // This most certainly relates to a bug in MQTT.js (#1284)
+              const msg = `Failed to subscribe, because: ${err.message}`
+              this._log.error(msg)
+              this.emit('error', err)
+              this._log.info('Forcing reconnect now...')
+              this._client.disconnecting = false
+              this._client.reconnect()
+              reject(new Error(msg))
+            }
+          } 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.message)
+              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.message)
+              this.emit('error', err)
+            }
+            if (granted.length === 0) {
+              this._log.debug(`Already subscribed to: ${topic}`)
+            }
+            resolve()
           }
         }
-      }
-    )
+      )
+    })
   }
 
-  _mqttUnsubscribe (topic, options) {
-    this._client.unsubscribe(topic, options, err => {
-      if (err) {
-        this._log.warn(
-          `Could not unsubscribe from topic: ${topic} because: ${err.message}`
-        )
-      }
+  async _mqttUnsubscribe (topic, options) {
+    return new Promise((resolve, reject) => {
+      this._client.unsubscribe(topic, options, err => {
+        if (err) {
+          this._log.warn(
+            `Could not unsubscribe from topic: ${topic} because: ${err.message}`
+          )
+        }
+        // we resolve in any case to let the upstream logic flow
+        resolve()
+      })
     })
   }
 
@@ -1002,7 +1005,7 @@ class VrpcClient extends EventEmitter {
           const id = `__e__${topic}`
           if (this._cachedSubscriptions[topic]) {
             this._eventEmitter.removeAllListeners(id)
-            this._mqttUnsubscribe(topic)
+            await this._mqttUnsubscribe(topic)
             delete this._cachedSubscriptions[topic]
           }
           try {
@@ -1030,7 +1033,7 @@ class VrpcClient extends EventEmitter {
         return
       }
       proxy[functionName] = async (...args) => {
-        const wrapped = this._wrapArguments({
+        const wrapped = await this._wrapArguments({
           agent,
           className,
           instance,
@@ -1065,7 +1068,7 @@ class VrpcClient extends EventEmitter {
     if (!uniqueFuncs.has('vrpcOn') && !uniqueFuncs.has('vrpcOff')) {
       proxy.vrpcOn = async (functionName, ...args) => {
         if (!uniqueFuncs.has(functionName)) throw new Error('Bad magic')
-        const wrapped = this._wrapArguments({
+        const wrapped = await this._wrapArguments({
           agent,
           className,
           instance,
@@ -1170,7 +1173,14 @@ class VrpcClient extends EventEmitter {
     })
   }
 
-  _wrapArguments ({ agent, className, instance, proxyId, functionName, args }) {
+  async _wrapArguments ({
+    agent,
+    className,
+    instance,
+    proxyId,
+    functionName,
+    args
+  }) {
     const wrapped = []
     for (const [i, x] of args.entries()) {
       // Check whether provided argument is a function
@@ -1186,7 +1196,7 @@ class VrpcClient extends EventEmitter {
           // 2) callback is second argument
           // 3) first argument was string
           const event = args[0]
-          const id = this._onRemoteEvent({
+          const id = await this._onRemoteEvent({
             agent,
             className,
             instance,
@@ -1201,7 +1211,7 @@ class VrpcClient extends EventEmitter {
           typeof args[0] === 'string'
         ) {
           const event = args[0]
-          const id = this._offRemoteEvent({
+          const id = await this._offRemoteEvent({
             agent,
             className,
             instance,
@@ -1236,7 +1246,7 @@ class VrpcClient extends EventEmitter {
           this._emitterListener.set(emitter, new Map([[event, callback]]))
         }
 
-        const id = this._onRemoteEvent({
+        const id = await this._onRemoteEvent({
           agent,
           className,
           instance,
@@ -1252,7 +1262,7 @@ class VrpcClient extends EventEmitter {
     return wrapped
   }
 
-  _onRemoteEvent ({ agent, className, instance, event, callback }) {
+  async _onRemoteEvent ({ agent, className, instance, event, callback }) {
     const callbackId = this._getCallbackId(callback)
     const eventCallback = `${event}-${callbackId}`
 
@@ -1262,10 +1272,15 @@ class VrpcClient extends EventEmitter {
       : `${this._domain}/${agent}/${className}/${eventCallback}`
 
     // prepare a special id for the agent to know that events should be
-    // published to the provided topic after the prefix and before the suffix
+    // published to the provided topic after the prefix
 
     const id = `__e__${topic}`
 
+    // If a subscription for this topic is already in progress, wait for it to finish.
+    if (this._pendingSubscriptions.has(topic)) {
+      await this._pendingSubscriptions.get(topic)
+    }
+
     // call our proxy callback when remote events were received
     const handler = ({ a }) => callback.apply(null, a)
     if (this._eventEmitter.listenerCount(id) === 0) {
@@ -1273,19 +1288,29 @@ class VrpcClient extends EventEmitter {
     }
     if (!this._cachedSubscriptions[topic]) {
       // when not yet subscribed to this topic do it now
-      this._mqttSubscribe(topic)
-      this._cachedSubscriptions[topic] = [{ callback, handler }]
-      return id
+      const subscribePromise = this._mqttSubscribe(topic)
+      this._pendingSubscriptions.set(topic, subscribePromise) // set lock
+
+      try {
+        await subscribePromise
+        this._cachedSubscriptions[topic] = [{ callback, handler }]
+      } finally {
+        this._pendingSubscriptions.delete(topic) // release lock
+      }
+    } else {
+      // otherwise just add the new callback-handler pair
+      this._cachedSubscriptions[topic].push({ callback, handler })
     }
-    // otherwise just add the new callback-handler pair
-    this._cachedSubscriptions[topic].push({ callback, handler })
     return id
   }
 
-  _offRemoteEvent ({ agent, className, instance, event, callback }) {
+  async _offRemoteEvent ({ agent, className, instance, event, callback }) {
     const callbackId = this._getCallbackId(callback, {
       readOnly: true
     })
+    // If the callback was never registered, we can't do anything.
+    if (!callbackId) return null
+
     const eventCallback = `${event}-${callbackId}`
     const topic = instance
       ? `${this._domain}/${agent}/${className}/${instance}:${eventCallback}`
@@ -1293,6 +1318,10 @@ class VrpcClient extends EventEmitter {
 
     const id = `__e__${topic}`
 
+    if (this._pendingUnsubscriptions.has(topic)) {
+      await this._pendingUnsubscriptions.get(topic)
+    }
+
     if (this._cachedSubscriptions[topic]) {
       const index = this._cachedSubscriptions[topic].findIndex(
         x => x.callback === callback
@@ -1303,16 +1332,21 @@ class VrpcClient extends EventEmitter {
       }
       const [{ handler }] = this._cachedSubscriptions[topic].splice(index, 1)
       if (this._cachedSubscriptions[topic].length === 0) {
-        this._eventEmitter.removeListener(id, handler)
-        this._mqttUnsubscribe(topic)
         delete this._cachedSubscriptions[topic]
-        return id
+        const unsubscribePromise = this._mqttUnsubscribe(topic)
+        this._pendingUnsubscriptions.set(topic, unsubscribePromise) // set lock
+
+        try {
+          await unsubscribePromise
+          this._eventEmitter.removeListener(id, handler)
+        } finally {
+          this._pendingUnsubscriptions.delete(topic) // release lock
+        }
+      } else {
+        this._log.warn(`Can not unsubscribe from non-existing event: ${event}`)
       }
       return id
-    } else {
-      this._log.warn(`Can not unsubscribe from non-existing event: ${event}`)
     }
-    return id
   }
 
   _clearCachedSubscriptions ({ lostAgent, lostInstance }) {
@@ -1328,11 +1362,12 @@ class VrpcClient extends EventEmitter {
     )
     obsoleteTopics.forEach(topic => {
       const id = `__e__${topic}`
-      this._log.info(`Clearing subscriptions for obsolete topic: ${topic}`)
+      this._log.debug(`Clearing subscriptions for obsolete topic: ${topic}`)
       const subscriptions = this._cachedSubscriptions[topic]
       subscriptions.forEach(({ handler }) => {
         this._eventEmitter.removeListener(id, handler)
       })
+      // this async function will never reject
       this._mqttUnsubscribe(topic)
       delete this._cachedSubscriptions[topic]
     })