vrpc 3.8.0 → 3.8.2

package/package.json

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

package/vrpc/SubscribeRetrier.js

@@ -0,0 +1,115 @@
+/**
+ * Retries MQTT subscriptions the broker refused (SUBACK qos=128).
+ *
+ * A refusal is not always final: the broker asks an authorization
+ * service for every subscription, and while that service is unavailable
+ * it refuses everything. An agent or client that subscribed in such a
+ * window used to stay deaf for good - connected, looking online, never
+ * receiving a message on the refused topic. This retries with a growing
+ * delay until the broker grants the topic, and forgets everything when a
+ * (re)connect subscribes afresh anyway.
+ *
+ * Browser-safe: timers only.
+ */
+class SubscribeRetrier {
+  /**
+   * @param {Object} options
+   * @param {Function} options.subscribe (topics: String[], options: Object) => void
+   *   the subscribe call to repeat; its own refusal handling schedules again
+   * @param {Object} [options.log] logger with warn()
+   * @param {Number} [options.initialDelayMs=1000]
+   * @param {Number} [options.maxDelayMs=30000]
+   */
+  constructor ({ subscribe, log, initialDelayMs = 1000, maxDelayMs = 30000 }) {
+    this._subscribe = subscribe
+    this._log = log
+    this._initialDelayMs = initialDelayMs
+    this._maxDelayMs = maxDelayMs
+    this._pending = new Map() // options key -> { options, topics: Set }
+    this._inFlight = new Set() // topics of the retry round under way
+    this._timer = null
+    this._attempt = 0
+  }
+
+  /** Topics waiting for a retry. */
+  get pending () {
+    const topics = []
+    for (const group of this._pending.values()) topics.push(...group.topics)
+    return topics
+  }
+
+  /** The delay the next retry will wait, in ms. */
+  get nextDelayMs () {
+    return Math.min(this._initialDelayMs * 2 ** this._attempt, this._maxDelayMs)
+  }
+
+  /**
+   * Remembers refused topics and arms the retry timer if none is armed.
+   *
+   * @param {String[]} topics
+   * @param {Object} [options] the subscribe options to repeat with
+   */
+  schedule (topics, options = {}) {
+    if (!topics || topics.length === 0) return
+    for (const topic of topics) this._inFlight.delete(topic)
+    const key = JSON.stringify(options)
+    const group = this._pending.get(key) || { options, topics: new Set() }
+    for (const topic of topics) group.topics.add(topic)
+    this._pending.set(key, group)
+    if (this._timer) return
+    const delayMs = this.nextDelayMs
+    if (this._log) {
+      this._log.warn(
+        `Retrying ${this.pending.length} refused subscription(s) in ${delayMs} ms: ${this.pending}`
+      )
+    }
+    this._timer = setTimeout(() => this._fire(), delayMs)
+  }
+
+  /**
+   * Called with the topics a subscribe granted: once nothing is pending
+   * any more, the backoff starts over.
+   */
+  granted (topics) {
+    for (const topic of topics) this._inFlight.delete(topic)
+    for (const group of this._pending.values()) {
+      for (const topic of topics) group.topics.delete(topic)
+    }
+    for (const [key, group] of this._pending) {
+      if (group.topics.size === 0) this._pending.delete(key)
+    }
+    // nothing waiting, nothing under way, nothing armed: start over
+    if (this._pending.size === 0 && this._inFlight.size === 0 && !this._timer) {
+      this._attempt = 0
+    }
+  }
+
+  /** Drops every pending retry: a (re)connect subscribes afresh, an end() stops. */
+  cancel () {
+    clearTimeout(this._timer)
+    this._timer = null
+    this._pending.clear()
+    this._inFlight.clear()
+    this._attempt = 0
+  }
+
+  _fire () {
+    this._timer = null
+    this._attempt += 1
+    const groups = Array.from(this._pending.values())
+    this._pending.clear()
+    for (const { topics } of groups) {
+      for (const topic of topics) this._inFlight.add(topic)
+    }
+    for (const { options, topics } of groups) {
+      try {
+        this._subscribe(Array.from(topics), options)
+      } catch (err) {
+        if (this._log) this._log.warn(`Retrying subscription failed: ${err.message}`)
+        this.schedule(Array.from(topics), options)
+      }
+    }
+  }
+}
+
+module.exports = SubscribeRetrier

package/vrpc/VrpcAgent.js

@@ -6,6 +6,7 @@ const { ArgumentParser } = require('argparse')
 const EventEmitter = require('events')
 const jsonStringifySafe = require('json-stringify-safe')
 const VrpcAdapter = require('./VrpcAdapter')
+const SubscribeRetrier = require('./SubscribeRetrier')
 
 const VRPC_PROTOCOL_VERSION = 3
 
@@ -144,6 +145,11 @@ class VrpcAgent extends EventEmitter {
     // maps clientId to instanceId
     this._isolatedInstances = new Map()
     this._sharedInstances = new Map()
+    // refused subscriptions (SUBACK qos=128) are retried until granted
+    this._subscribeRetrier = new SubscribeRetrier({
+      subscribe: (topics, options) => this._mqttSubscribe(topics, options),
+      log: this._log
+    })
 
     // Handle the internal error event in case the user forgot to implement it
     this.on('error', err => {
@@ -213,6 +219,7 @@ class VrpcAgent extends EventEmitter {
    * @returns {Promise} Resolves when disconnected and ended
    */
   async end ({ unregister = false } = {}) {
+    this._subscribeRetrier.cancel()
     try {
       if (!this._client || !this._client.connected) {
         this.emit('end')
@@ -370,7 +377,11 @@ class VrpcAgent extends EventEmitter {
             err.subscribeOptions = options
             this._log.error(err)
             this.emit('error', err)
+            this._subscribeRetrier.schedule(erroneousGranted, options)
           }
+          this._subscribeRetrier.granted(
+            granted.filter(x => x.qos !== 128).map(x => x.topic)
+          )
           const reducedQos = granted.filter(x => x.qos < this._qos)
           if (reducedQos.length > 0) {
             err = new Error(
@@ -471,6 +482,8 @@ class VrpcAgent extends EventEmitter {
 
   _handleConnect () {
     this._log.info('[OK]')
+    // everything is subscribed afresh: pending retries are moot
+    this._subscribeRetrier.cancel()
     try {
       const topics = this._generateTopics()
       if (topics.length > 0) this._mqttSubscribe(topics)

package/vrpc/VrpcClient.js

@@ -41,6 +41,7 @@ const os = require('os')
 const { nanoid } = require('nanoid')
 const mqtt = require('mqtt')
 const EventEmitter = require('events')
+const SubscribeRetrier = require('./SubscribeRetrier')
 
 const VRPC_PROTOCOL_VERSION = 3
 
@@ -135,6 +136,11 @@ class VrpcClient extends EventEmitter {
     this._client = null
     this._cachedSubscriptions = {}
     this._proxies = {}
+    // refused subscriptions (SUBACK qos=128) are retried until granted
+    this._subscribeRetrier = new SubscribeRetrier({
+      subscribe: (topics, options) => this._mqttSubscribe(topics, options).catch(() => {}),
+      log: this._log
+    })
     this._callbackIds = new WeakMap()
     this._emitterListener = new WeakMap()
     this._pendingSubscriptions = new Map()
@@ -247,6 +253,8 @@ class VrpcClient extends EventEmitter {
     this._client.on('connect', async () => {
       // forward the good news
       this.emit('connect')
+      // everything is subscribed afresh below: pending retries are moot
+      this._subscribeRetrier.cancel()
       try {
         // This will give us an overview of all remotely available classes
         const agent = this._agent === '*' ? '+' : this._agent
@@ -321,7 +329,7 @@ class VrpcClient extends EventEmitter {
           if (removed.length !== 0) {
             this.emit('instanceGone', removed, { domain, agent, className })
             removed.forEach(lostInstance =>
-              this._clearCachedSubscriptions({ lostInstance })
+              this._clearCachedSubscriptions({ lostInstance, agent, className })
             )
           }
           if (added.length !== 0) {
@@ -438,7 +446,14 @@ class VrpcClient extends EventEmitter {
       v: VRPC_PROTOCOL_VERSION
     }
     const proxy = await this._getProxy(agent, className, json)
-    if (instance && cacheProxy) this._proxies[instance] = proxy
+    if (instance && cacheProxy) {
+      this._proxies[`${agent}/${className}/${instance}`] = {
+        agent,
+        className,
+        instance,
+        proxy
+      }
+    }
     return proxy
   }
 
@@ -460,7 +475,8 @@ class VrpcClient extends EventEmitter {
     if (!this._isConnected()) {
       throw new Error('Client is not connected')
     }
-    if (this._proxies[instance]) return this._proxies[instance]
+    const cached = this._cachedProxy(instance, options)
+    if (cached) return cached
     const { agent, className } = await this._getInstanceData(instance, options)
     return this._createProxy(agent, className, instance)
   }
@@ -492,7 +508,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]
+    delete this._proxies[`${agent}/${className}/${instance}`]
     return this._handleAgentAnswer(json, agent)
   }
 
@@ -775,6 +791,7 @@ class VrpcClient extends EventEmitter {
    * @returns {Promise} Resolves when ended
    */
   async end () {
+    this._subscribeRetrier.cancel()
     if (!this._client) return
     this._mqttPublish(
       `${this._vrpcConnectionId}/__clientInfo__`,
@@ -912,7 +929,11 @@ class VrpcClient extends EventEmitter {
               err.subscribeOptions = options
               this._log.error(err.message)
               this.emit('error', err)
+              this._subscribeRetrier.schedule(erroneousGranted, options)
             }
+            this._subscribeRetrier.granted(
+              granted.filter(x => x.qos !== 128).map(x => x.topic)
+            )
             const reducedQos = granted.filter(x => x.qos < this._qos)
             if (reducedQos.length > 0) {
               err = new Error(
@@ -1374,11 +1395,19 @@ class VrpcClient extends EventEmitter {
     return foundId
   }
 
-  _clearCachedSubscriptions ({ lostAgent, lostInstance }) {
+  _clearCachedSubscriptions ({ lostAgent, lostInstance, agent, className }) {
     const obsoleteTopics = Object.keys(this._cachedSubscriptions).filter(
       topic => {
         const sub = this._cachedSubscriptions[topic]
-        return sub.agent === lostAgent || sub.instance === lostInstance
+        if (lostAgent !== undefined) return sub.agent === lostAgent
+        // Instance ids are unique per agent only: a twin of the same id on
+        // another agent (a deployed app next to its builder) keeps its
+        // subscriptions when this one goes
+        return (
+          sub.instance === lostInstance &&
+          sub.agent === agent &&
+          sub.className === className
+        )
       }
     )
 
@@ -1432,12 +1461,25 @@ class VrpcClient extends EventEmitter {
     return instanceData
   }
 
+  _cachedProxy (instance, { agent, className } = {}) {
+    // Instance ids are unique per agent only: a cached proxy is served
+    // solely when it is the one match for the given agent and class - twins
+    // on several agents are resolved through the topology instead
+    const hits = Object.values(this._proxies).filter(
+      x =>
+        x.instance === instance &&
+        (!agent || x.agent === agent) &&
+        (!className || x.className === className)
+    )
+    return hits.length === 1 ? hits[0].proxy : null
+  }
+
   _getInstanceFromCache (instance, options = {}) {
     // when no agent is specified, but an explicit class default exists give
     // such instances priority in being found
     if (!options.agent && this._agent !== '*') {
       const { classes, status } = this._agents[this._agent] || {}
-      if (!classes || status === 'offline') {
+      if (classes && status !== 'offline') {
         for (const className in classes) {
           if (options.className && className !== options.className) continue
           const { instances } = classes[className]