vrpc 3.8.1 → 3.8.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vrpc",
-  "version": "3.8.1",
+  "version": "3.8.3",
   "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/VrpcAdapter.js

@@ -547,6 +547,17 @@ class VrpcAdapter {
       return
     }
     const unwrapped = VrpcAdapter._unwrapArguments(json)
+    // special case: removing a listener the adapter does not hold (the
+    // client's subscription outlived a restart of this agent, or it sent
+    // no listener at all) - nothing to remove, and the instance's
+    // EventEmitter would throw on a listener that is not a function
+    if (
+      (json.f === 'off' || json.f === 'removeListener') &&
+      typeof unwrapped[1] !== 'function'
+    ) {
+      json.r = true
+      return
+    }
     // Check whether context is a registered class
     const entry = VrpcAdapter._functionRegistry.get(json.c)
     if (entry !== undefined) {

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
@@ -783,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__`,
@@ -920,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(
@@ -1271,6 +1284,17 @@ class VrpcClient extends EventEmitter {
           isContinuousRemover
         ) {
           const id = await this._offRemoteEvent({ callback })
+          if (
+            !id &&
+            (functionName === 'off' || functionName === 'removeListener')
+          ) {
+            // Nothing of ours to remove - the subscription was already
+            // dropped (the instance or its agent went away and the cache
+            // was cleared, or the listener was never registered). Sending
+            // the call anyway would hand the agent a null listener, which
+            // its EventEmitter rejects. Handled locally: nothing to do.
+            return null
+          }
           wrapped.push(id || null)
           continue
         } else {