homey-api 3.17.4 → 3.17.6

package/lib/HomeyAPI/HomeyAPIV3/SubscriptionRegistry.js

@@ -0,0 +1,345 @@
+'use strict';
+
+const Util = require('../../Util');
+
+class SubscriptionRegistry {
+  constructor({ homey, session }) {
+    this.homey = homey;
+    this.session = session;
+    // Each URI entry represents one wire-level subscription for the current
+    // session revision. Multiple local consumers can share that single server
+    // subscription, and needsReconnect means the consumer state still exists
+    // locally while the server-side subscription must be restored.
+    this.__entries = new Map();
+    this.__destroyed = false;
+
+    this.__onSessionDisconnect = this.__onSessionDisconnect.bind(this);
+    this.__onSessionReconnect = this.__onSessionReconnect.bind(this);
+    this.__onSessionReady = this.__onSessionReady.bind(this);
+    this.__onSessionReadyError = this.__onSessionReadyError.bind(this);
+
+    this.session.on('disconnect', this.__onSessionDisconnect);
+    this.session.on('reconnect', this.__onSessionReconnect);
+    this.session.on('ready', this.__onSessionReady);
+    this.session.on('ready_error', this.__onSessionReadyError);
+  }
+
+  async subscribe(
+    uri,
+    {
+      onConnect = () => {},
+      onReconnect = () => {},
+      onReconnectError = () => {},
+      onDisconnect = () => {},
+      onEvent = () => {},
+    }
+  ) {
+    if (this.__destroyed) {
+      throw new Error('Subscription registry destroyed.');
+    }
+
+    this.homey.__debug('subscribe', uri);
+
+    const entry = this.__getEntry(uri);
+    const consumer = {
+      active: true,
+      handlers: {
+        onConnect,
+        onReconnect,
+        onReconnectError,
+        onDisconnect,
+        onEvent,
+      },
+    };
+
+    entry.consumers.add(consumer);
+
+    try {
+      await this.__ensureEntrySubscribed(entry);
+
+      if (consumer.active) {
+        consumer.handlers.onConnect();
+      }
+    } catch (err) {
+      entry.consumers.delete(consumer);
+      this.__deleteEntryIfUnused(entry);
+      throw err;
+    }
+
+    return {
+      unsubscribe: () => {
+        if (!consumer.active) return;
+
+        consumer.active = false;
+        entry.consumers.delete(consumer);
+        this.__deleteEntryIfUnused(entry);
+      },
+    };
+  }
+
+  destroy() {
+    if (this.__destroyed) return;
+
+    this.__destroyed = true;
+
+    this.session.removeListener('disconnect', this.__onSessionDisconnect);
+    this.session.removeListener('reconnect', this.__onSessionReconnect);
+    this.session.removeListener('ready', this.__onSessionReady);
+    this.session.removeListener('ready_error', this.__onSessionReadyError);
+
+    for (const entry of this.__entries.values()) {
+      entry.consumers.clear();
+      this.__teardownEntry(entry);
+    }
+
+    this.__entries.clear();
+  }
+
+  __getEntry(uri) {
+    if (this.__entries.has(uri)) {
+      return this.__entries.get(uri);
+    }
+
+    const entry = {
+      uri,
+      consumers: new Set(),
+      eventSocket: null,
+      eventHandler: (event, data) => {
+        this.__notifyConsumers(entry, 'onEvent', event, data);
+      },
+      subscribePromise: null,
+      subscribedRevision: 0,
+      pendingRevision: 0,
+      needsReconnect: false,
+      hasConnected: false,
+      reconnectPromise: null,
+      removed: false,
+    };
+
+    this.__entries.set(uri, entry);
+    return entry;
+  }
+
+  async __ensureEntrySubscribed(entry) {
+    if (entry.removed || entry.consumers.size === 0) return;
+
+    if (entry.subscribedRevision === this.session.revision && this.session.isConnected()) {
+      return;
+    }
+
+    if (entry.subscribePromise) {
+      return entry.subscribePromise;
+    }
+
+    const subscribePromise = (async () => {
+      const { homeySocket, revision } = await this.session.ensureConnected();
+
+      if (entry.removed || entry.consumers.size === 0) {
+        return;
+      }
+
+      if (entry.subscribedRevision === revision) {
+        this.__bindEventSocket(entry, homeySocket);
+        return;
+      }
+
+      entry.pendingRevision = revision;
+      this.__bindEventSocket(entry, homeySocket);
+      await this.__subscribeUri(entry, homeySocket);
+
+      if (entry.removed || entry.consumers.size === 0) {
+        homeySocket.emit('unsubscribe', entry.uri);
+        return;
+      }
+
+      entry.subscribedRevision = revision;
+      entry.pendingRevision = 0;
+      entry.hasConnected = true;
+    })();
+
+    entry.subscribePromise = subscribePromise;
+
+    subscribePromise
+      .catch(() => {})
+      .finally(() => {
+        if (entry.subscribePromise === subscribePromise) {
+          entry.subscribePromise = null;
+        }
+      });
+
+    return subscribePromise;
+  }
+
+  async __subscribeUri(entry, homeySocket) {
+    await Util.timeout(
+      new Promise((resolve, reject) => {
+        const onDisconnect = (reason) => {
+          cleanup();
+          reject(new Error(reason));
+        };
+
+        const cleanup = () => {
+          homeySocket.removeListener('disconnect', onDisconnect);
+        };
+
+        homeySocket.once('disconnect', onDisconnect);
+        this.homey.__debug('subscribing', entry.uri);
+        homeySocket.emit('subscribe', entry.uri, (err) => {
+          cleanup();
+
+          if (err) {
+            this.homey.__debug('Failed to subscribe', entry.uri, err);
+            reject(err);
+            return;
+          }
+
+          this.homey.__debug('subscribed', entry.uri);
+          resolve();
+        });
+      }),
+      this.homey.constructor.SUBSCRIBE_TIMEOUT,
+      `Failed to subscribe to ${entry.uri} (Timeout after ${this.homey.constructor.SUBSCRIBE_TIMEOUT}ms).`
+    );
+  }
+
+  __bindEventSocket(entry, homeySocket) {
+    if (entry.eventSocket === homeySocket) return;
+
+    if (entry.eventSocket) {
+      entry.eventSocket.removeListener(entry.uri, entry.eventHandler);
+    }
+
+    entry.eventSocket = homeySocket;
+    entry.eventSocket.on(entry.uri, entry.eventHandler);
+  }
+
+  __onSessionDisconnect(reason) {
+    for (const entry of this.__entries.values()) {
+      if (!entry.hasConnected || entry.consumers.size === 0) {
+        continue;
+      }
+
+      entry.needsReconnect = true;
+      entry.subscribedRevision = 0;
+
+      if (entry.eventSocket) {
+        entry.eventSocket.removeListener(entry.uri, entry.eventHandler);
+        entry.eventSocket = null;
+      }
+
+      this.__notifyConsumers(entry, 'onDisconnect', reason);
+    }
+  }
+
+  __onSessionReady({ revision, homeySocket, isReconnect }) {
+    if (!isReconnect) {
+      return;
+    }
+
+    // The transport can reconnect before the current Homey namespace is ready.
+    // Listen to both reconnect and ready so entries resume promptly, while
+    // ready is the point where the active namespace socket can be rebound.
+    for (const entry of this.__entries.values()) {
+      if (entry.consumers.size === 0 || !entry.needsReconnect) {
+        continue;
+      }
+
+      this.__bindEventSocket(entry, homeySocket);
+      this.__resumeEntry(entry, revision);
+    }
+  }
+
+  __onSessionReconnect() {
+    for (const entry of this.__entries.values()) {
+      if (entry.consumers.size === 0 || !entry.needsReconnect) {
+        continue;
+      }
+
+      this.__resumeEntry(entry);
+    }
+  }
+
+  __onSessionReadyError(err) {
+    for (const entry of this.__entries.values()) {
+      if (!entry.needsReconnect || entry.consumers.size === 0 || entry.reconnectPromise) {
+        continue;
+      }
+
+      this.__notifyConsumers(entry, 'onReconnectError', err);
+    }
+  }
+
+  __resumeEntry(entry, revision = null) {
+    if (entry.reconnectPromise) {
+      return entry.reconnectPromise;
+    }
+
+    const reconnectPromise = (async () => {
+      try {
+        await this.__ensureEntrySubscribed(entry);
+
+        if (
+          entry.removed
+          || entry.consumers.size === 0
+          || (revision != null && entry.subscribedRevision !== revision)
+        ) {
+          return;
+        }
+
+        entry.needsReconnect = false;
+        this.__notifyConsumers(entry, 'onReconnect');
+      } catch (err) {
+        if (entry.removed || entry.consumers.size === 0) {
+          return;
+        }
+
+        this.__notifyConsumers(entry, 'onReconnectError', err);
+      }
+    })();
+
+    entry.reconnectPromise = reconnectPromise;
+
+    reconnectPromise.finally(() => {
+      if (entry.reconnectPromise === reconnectPromise) {
+        entry.reconnectPromise = null;
+      }
+    });
+
+    return reconnectPromise;
+  }
+
+  __notifyConsumers(entry, event, ...args) {
+    for (const consumer of entry.consumers) {
+      if (!consumer.active) continue;
+      consumer.handlers[event](...args);
+    }
+  }
+
+  __deleteEntryIfUnused(entry) {
+    if (entry.consumers.size > 0) return;
+
+    entry.removed = true;
+    this.__entries.delete(entry.uri);
+
+    if (entry.eventSocket) {
+      entry.eventSocket.emit('unsubscribe', entry.uri);
+    } else if (this.session.homeySocket) {
+      this.session.homeySocket.emit('unsubscribe', entry.uri);
+    }
+
+    this.__teardownEntry(entry);
+  }
+
+  __teardownEntry(entry) {
+    if (entry.eventSocket) {
+      entry.eventSocket.removeListener(entry.uri, entry.eventHandler);
+      entry.eventSocket = null;
+    }
+
+    entry.pendingRevision = 0;
+    entry.subscribedRevision = 0;
+    entry.reconnectPromise = null;
+  }
+}
+
+module.exports = SubscriptionRegistry;