vrpc 3.5.2 → 3.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vrpc",
-  "version": "3.5.2",
+  "version": "3.6.0",
   "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,40 @@ 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)
+    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.info('Restoring event subscriptions after reconnect...')
-      for (const topic of Object.keys(this._cachedSubscriptions)) {
-        this._mqttSubscribe(topic)
-      }
+        // Single wildcard subscription for ALL continuous remote events
+        await this._mqttSubscribe(`${this._vrpcClientId}/__e__/#`)
 
-      this.emit('connect')
+        // 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 +343,6 @@ class VrpcClient extends EventEmitter {
         resolve()
       })
     })
-    // --------------------------------------------------------------------------------
   }
 
   /**
@@ -456,25 +471,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 +493,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 +556,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 +572,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 +845,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()
+      })
     })
   }
 
@@ -998,13 +1004,32 @@ class VrpcClient extends EventEmitter {
           if (!eventName) {
             throw new Error('VRPC does not support removing all listeners')
           }
-          const topic = `${this._domain}/${agent}/${className}/${instance}:${eventName}`
-          const id = `__e__${topic}`
-          if (this._cachedSubscriptions[topic]) {
-            this._eventEmitter.removeAllListeners(id)
-            this._mqttUnsubscribe(topic)
+
+          const obsoleteTopics = Object.keys(this._cachedSubscriptions).filter(
+            topic => {
+              const tokens = topic.split('/')
+              if (tokens[3] === '__e__') {
+                const topicInstance = tokens[6]
+                const topicEvent = tokens[7]
+                return topicInstance === instance && topicEvent === eventName
+              }
+              // Legacy fallback
+              const expectedOld = `${this._domain}/${agent}/${className}/${instance}:${eventName}`
+              return topic.startsWith(expectedOld)
+            }
+          )
+
+          obsoleteTopics.forEach(topic => {
+            const id = `__e__${topic}`
+            const subscriptions = this._cachedSubscriptions[topic]
+            subscriptions.forEach(({ handler }) => {
+              this._eventEmitter.removeListener(id, handler)
+            })
+            if (!topic.includes('__e__')) {
+              this._mqttUnsubscribe(topic).catch(() => {})
+            }
             delete this._cachedSubscriptions[topic]
-          }
+          })
           try {
             const json = {
               c: instance,
@@ -1030,7 +1055,7 @@ class VrpcClient extends EventEmitter {
         return
       }
       proxy[functionName] = async (...args) => {
-        const wrapped = this._wrapArguments({
+        const wrapped = await this._wrapArguments({
           agent,
           className,
           instance,
@@ -1065,7 +1090,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,23 +1195,32 @@ class VrpcClient extends EventEmitter {
     })
   }
 
-  _wrapArguments ({ agent, className, instance, proxyId, functionName, args }) {
+  async _wrapArguments ({
+    agent,
+    className,
+    instance,
+    proxyId,
+    functionName,
+    args
+  }) {
     const wrapped = []
+
+    // Heuristic for continuous event emitters and their removal
+    const isContinuousEmitter = /^(on|notify|monitor|signal)/.test(functionName)
+    const isContinuousRemover = /^(off|remove|unmonitor|unsignal)/.test(
+      functionName
+    )
+
     for (const [i, x] of args.entries()) {
-      // Check whether provided argument is a function
       if (this._isFunction(x)) {
         const callback = x
         if (
           functionName === 'vrpcOn' ||
-          (functionName === 'on' && i === 1 && typeof args[0] === 'string')
+          (functionName === 'on' && i === 1 && typeof args[0] === 'string') ||
+          isContinuousEmitter
         ) {
-          // special case of an (remote-)event emitter registration
-          // we test three conditions:
-          // 1) functionName must be "on"
-          // 2) callback is second argument
-          // 3) first argument was string
-          const event = args[0]
-          const id = this._onRemoteEvent({
+          const event = typeof args[0] === 'string' ? args[0] : functionName
+          const id = await this._onRemoteEvent({
             agent,
             className,
             instance,
@@ -1196,19 +1230,13 @@ class VrpcClient extends EventEmitter {
           wrapped.push(id)
           continue
         } else if (
-          (functionName === 'off' || functionName === 'removeListener') &&
-          i === 1 &&
-          typeof args[0] === 'string'
+          ((functionName === 'off' || functionName === 'removeListener') &&
+            i === 1 &&
+            typeof args[0] === 'string') ||
+          isContinuousRemover
         ) {
-          const event = args[0]
-          const id = this._offRemoteEvent({
-            agent,
-            className,
-            instance,
-            event,
-            callback
-          })
-          wrapped.push(id)
+          const id = await this._offRemoteEvent({ callback })
+          wrapped.push(id || null)
           continue
         } else {
           // Regular function callback (can be static or member function)
@@ -1221,6 +1249,7 @@ class VrpcClient extends EventEmitter {
           continue
         }
       }
+
       // special case of an EventEmitter provided as argument
       if (this._isEmitter(x)) {
         const { emitter, event } = x
@@ -1236,7 +1265,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,87 +1281,92 @@ 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}`
-
-    // the topic on which any remote event will be published to
-    const topic = instance
-      ? `${this._domain}/${agent}/${className}/${instance}:${eventCallback}`
-      : `${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
 
+    // Route directly to the client's single event inbox wildcard.
+    const topic = `${this._vrpcClientId}/__e__/${agent}/${className}/${
+      instance || '__static__'
+    }/${event}/${callbackId}`
     const id = `__e__${topic}`
 
-    // call our proxy callback when remote events were received
     const handler = ({ a }) => callback.apply(null, a)
+
+    // Only bind to the actual emitter on the first registration
     if (this._eventEmitter.listenerCount(id) === 0) {
       this._eventEmitter.on(id, handler)
     }
+
     if (!this._cachedSubscriptions[topic]) {
-      // when not yet subscribed to this topic do it now
-      this._mqttSubscribe(topic)
       this._cachedSubscriptions[topic] = [{ callback, handler }]
-      return id
+    } else {
+      // We MUST push duplicates to act as a reference counter!
+      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 }) {
-    const callbackId = this._getCallbackId(callback, {
-      readOnly: true
-    })
-    const eventCallback = `${event}-${callbackId}`
-    const topic = instance
-      ? `${this._domain}/${agent}/${className}/${instance}:${eventCallback}`
-      : `${this._domain}/${agent}/${className}/${eventCallback}`
+  async _offRemoteEvent ({ callback }) {
+    const callbackId = this._getCallbackId(callback, { readOnly: true })
+    if (!callbackId) return null
 
-    const id = `__e__${topic}`
+    let foundId = null
+    const topics = Object.keys(this._cachedSubscriptions).filter(
+      t => t.endsWith(`/${callbackId}`) || t.endsWith(`-${callbackId}`)
+    )
 
-    if (this._cachedSubscriptions[topic]) {
+    topics.forEach(topic => {
+      const id = `__e__${topic}`
       const index = this._cachedSubscriptions[topic].findIndex(
         x => x.callback === callback
       )
-      if (index === -1) {
-        this._log.warn(`Failed removing event listener ${id}`)
-        return null
-      }
-      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
+
+      if (index !== -1) {
+        // Decrease the "reference count" by removing one instance
+        this._cachedSubscriptions[topic].splice(index, 1)
+
+        // Only remove from the local event emitter if NO references remain
+        if (this._cachedSubscriptions[topic].length === 0) {
+          delete this._cachedSubscriptions[topic]
+
+          // Legacy cleanup just in case
+          if (!topic.includes('__e__')) {
+            this._mqttUnsubscribe(topic).catch(() => {})
+          }
+
+          // Cleanly wipe all listeners for this specific id
+          this._eventEmitter.removeAllListeners(id)
+        }
+        foundId = id
       }
-      return id
-    } else {
-      this._log.warn(`Can not unsubscribe from non-existing event: ${event}`)
-    }
-    return id
+    })
+    return foundId
   }
 
   _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
+        const tokens = topic.split('/')
+        if (tokens[3] === '__e__') {
+          const topicAgent = tokens[4]
+          const topicInstance = tokens[6]
+          return topicAgent === lostAgent || topicInstance === lostInstance
         }
-        return false
+        // Legacy fallback
+        const [, agent, , instanceEvent] = topic.split('/')
+        const [instance] = (instanceEvent || '').split(':')
+        return agent === lostAgent || instance === lostInstance
       }
     )
     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]
     })