homey-api 3.17.3 → 3.17.5

package/lib/HomeyAPI/HomeyAPIV3/SocketSession.js

@@ -0,0 +1,617 @@
+'use strict';
+
+const SocketIOClient = require('socket.io-client');
+const EventEmitter = require('../../EventEmitter');
+const Util = require('../../Util');
+const HomeyAPIError = require('../HomeyAPIError');
+
+const SOCKET_SESSION_NOT_READY_CODE = 'ERR_SOCKET_SESSION_NOT_READY';
+
+class SocketSession extends EventEmitter {
+  static NOT_READY_CODE = SOCKET_SESSION_NOT_READY_CODE;
+
+  constructor(homey) {
+    super();
+
+    this.homey = homey;
+    this.__phase = 'idle';
+    this.__socket = null;
+    this.__homeySocket = null;
+    this.__boundHomeySocket = null;
+    this.__homeySocketHandlers = null;
+    this.__readyPromise = null;
+    this.__readyAbortController = null;
+    this.__readyRevision = 0;
+    this.__destroyed = false;
+    this.__closing = false;
+  }
+
+  get socket() {
+    return this.__socket;
+  }
+
+  get homeySocket() {
+    return this.__homeySocket;
+  }
+
+  get phase() {
+    return this.__phase;
+  }
+
+  get revision() {
+    return this.__readyRevision;
+  }
+
+  isConnected() {
+    return Boolean(this.__homeySocket && this.__homeySocket.connected);
+  }
+
+  isConnecting() {
+    return this.__readyPromise != null;
+  }
+
+  async ensureConnected() {
+    if (this.__destroyed) {
+      throw new Error('Socket session destroyed.');
+    }
+
+    if (this.isConnected()) {
+      return this.__getReadyState();
+    }
+
+    if (this.__readyPromise) {
+      return this.__readyPromise;
+    }
+
+    const isReconnect = this.__readyRevision > 0 || this.__homeySocket != null;
+    const abortController = new AbortController();
+    this.__readyAbortController = abortController;
+
+    const readyPromise = Promise.resolve().then(async () => {
+      if (this.__destroyed) {
+        throw this.__createAbortError('Socket session destroyed.');
+      }
+
+      if (abortController.signal.aborted) {
+        throw this.__createAbortError(abortController.signal.reason);
+      }
+
+      this.__setPhase('connecting');
+
+      const baseUrl = await this.homey.baseUrl;
+
+      if (!this.homey.__token) {
+        await this.homey.login();
+      }
+
+      if (!this.__socket) {
+        this.__createSocket(baseUrl);
+      }
+
+      await this.__waitForSocketConnect(abortController.signal);
+
+      this.__setPhase('handshaking');
+      const namespace = await this.__handshakeClient(abortController.signal);
+      await this.__connectHomeySocket(namespace, abortController.signal);
+
+      this.__readyRevision += 1;
+      this.__setPhase('ready');
+
+      const readyState = {
+        ...this.__getReadyState(),
+        isReconnect,
+      };
+
+      this.emit('ready', readyState);
+
+      return readyState;
+    });
+
+    this.__readyPromise = readyPromise;
+
+    readyPromise
+      .catch((err) => {
+        this.homey.__debug('SocketSession Error', err.message);
+
+        if (!this.__destroyed && !this.__closing && isReconnect) {
+          this.emit('ready_error', err);
+        }
+
+        if (!this.isConnected() && !this.__destroyed && !this.__closing) {
+          this.__setPhase('idle');
+        }
+      })
+      .finally(() => {
+        if (this.__readyPromise === readyPromise) {
+          this.__readyPromise = null;
+        }
+
+        if (this.__readyAbortController === abortController) {
+          this.__readyAbortController = null;
+        }
+      });
+
+    return readyPromise;
+  }
+
+  async requestApi({
+    uri,
+    operation,
+    args,
+    timeout = this.homey.constructor.DEFAULT_TIMEOUT,
+  }) {
+    if (!this.isConnected()) {
+      throw this.__createNotReadyError();
+    }
+
+    const homeySocket = this.__homeySocket;
+
+    return Util.timeout(
+      new Promise((resolve, reject) => {
+        const onDisconnect = (reason) => {
+          cleanup();
+          reject(this.__createNotReadyError(reason));
+        };
+
+        const cleanup = () => {
+          homeySocket.removeListener('disconnect', onDisconnect);
+        };
+
+        homeySocket.once('disconnect', onDisconnect);
+        homeySocket.emit(
+          'api',
+          {
+            args,
+            operation,
+            uri,
+          },
+          (err, result) => {
+            cleanup();
+
+            if (err != null) {
+              reject(this.__normalizeSocketError(err, `Unknown API error for ${operation}.`));
+              return;
+            }
+
+            resolve(result);
+          }
+        );
+      }),
+      timeout
+    );
+  }
+
+  async disconnect() {
+    if (this.__destroyed) return;
+
+    this.__closing = true;
+    this.__cancelReadyCycle('Socket session disconnected.');
+    const shouldEmitDisconnect = this.isConnected();
+    this.__setPhase('disconnecting');
+
+    const homeySocket = this.__homeySocket;
+    if (homeySocket) {
+      homeySocket.removeAllListeners();
+      homeySocket.close();
+      this.__homeySocket = null;
+      this.__unbindHomeySocket();
+    }
+
+    if (this.__socket) {
+      const socket = this.__socket;
+
+      await new Promise((resolve) => {
+        if (socket.connected) {
+          socket.once('disconnect', () => {
+            socket.removeAllListeners();
+            resolve();
+          });
+          socket.disconnect();
+        } else {
+          socket.close();
+          socket.removeAllListeners();
+          resolve();
+        }
+      });
+
+      this.__socket = null;
+    }
+
+    if (shouldEmitDisconnect) {
+      this.emit('disconnect', 'io client disconnect');
+    }
+
+    this.__closing = false;
+    this.__setPhase('idle');
+  }
+
+  destroy() {
+    if (this.__destroyed) return;
+
+    this.__destroyed = true;
+    this.__closing = true;
+    this.__cancelReadyCycle('Socket session destroyed.');
+
+    if (this.__homeySocket) {
+      this.__homeySocket.removeAllListeners();
+      this.__homeySocket.close();
+      this.__homeySocket = null;
+    }
+
+    this.__unbindHomeySocket();
+
+    if (this.__socket) {
+      this.__socket.removeAllListeners();
+      this.__socket.close();
+      this.__socket = null;
+    }
+
+    this.__setPhase('destroyed');
+    this.removeAllListeners();
+  }
+
+  __getReadyState() {
+    return {
+      homeySocket: this.__homeySocket,
+      socket: this.__socket,
+      revision: this.__readyRevision,
+      isReconnect: this.__readyRevision > 1,
+    };
+  }
+
+  __setPhase(phase) {
+    this.__phase = phase;
+  }
+
+  __createSocket(baseUrl) {
+    this.homey.__debug(`SocketIOClient ${baseUrl}`);
+
+    this.__socket = SocketIOClient(baseUrl, {
+      autoConnect: false,
+      transports: ['websocket'],
+      reconnection: this.homey.__reconnect,
+    });
+
+    this.__socket.on('disconnect', (reason) => {
+      this.homey.__debug('SocketIOClient.onDisconnect', reason);
+      this.__handleSessionDisconnect(reason);
+    });
+
+    this.__socket.on('error', (err) => {
+      this.homey.__debug('SocketIOClient.onError', err.message);
+      this.emit('error', err);
+    });
+
+    this.__socket.on('reconnect', () => {
+      this.homey.__debug('SocketIOClient.onReconnect');
+      this.emit('reconnect');
+      this.__scheduleEnsureConnected('reconnect');
+    });
+
+    this.__socket.on('reconnect_attempt', () => {
+      this.homey.__debug('SocketIOClient.onReconnectAttempt');
+      this.emit('reconnect_attempt');
+    });
+
+    this.__socket.on('reconnecting', (attempt) => {
+      this.homey.__debug(`SocketIOClient.onReconnecting (Attempt #${attempt})`);
+      this.emit('reconnecting');
+    });
+
+    this.__socket.on('reconnect_error', (err) => {
+      this.homey.__debug('SocketIOClient.onReconnectError', err.message, err);
+      this.emit('reconnect_error', err);
+    });
+
+    this.__socket.on('connect_error', (err) => {
+      this.homey.__debug('SocketIOClient.onConnectError', err.message);
+      this.emit('connect_error', err);
+    });
+
+    this.__socket.on('connect', () => {
+      this.homey.__debug('SocketIOClient.onConnect');
+      this.emit('connect');
+      this.__scheduleEnsureConnected('connect');
+    });
+  }
+
+  __scheduleEnsureConnected(origin) {
+    if (this.__destroyed || this.__closing || this.isConnected() || this.__readyPromise) {
+      return;
+    }
+
+    this.ensureConnected().catch((err) => {
+      this.homey.__debug(`SocketIOClient.${origin}.ensureConnectedError`, err.message);
+    });
+  }
+
+  __handleSessionDisconnect(reason) {
+    const shouldEmitDisconnect = this.__phase === 'ready' || this.isConnected();
+
+    this.__cancelReadyCycle('Socket disconnected.');
+    this.__setPhase(this.__closing ? 'disconnecting' : 'idle');
+
+    if (shouldEmitDisconnect) {
+      this.emit('disconnect', reason);
+    }
+  }
+
+  async __waitForSocketConnect(signal) {
+    if (this.__socket.connected) return;
+
+    await this.__waitForConnect({
+      socket: this.__socket,
+      signal,
+      errorEvents: ['connect_error'],
+      fallbackMessage: 'Unknown error connecting to Socket.io.',
+    });
+  }
+
+  async __handshakeClient(signal) {
+    this.homey.__debug('__handshakeClient');
+
+    const handshakeClient = (token) => {
+      return new Promise((resolve, reject) => {
+        this.__socket.emit(
+          'handshakeClient',
+          {
+            token,
+            homeyId: this.homey.id,
+          },
+          (err, result) => {
+            if (err != null) {
+              reject(this.__normalizeSocketError(err, 'Unknown handshake error.'));
+              return;
+            }
+
+            resolve(result);
+          }
+        );
+      });
+    };
+
+    const token = this.homey.__token;
+
+    try {
+      const result = await this.__timeoutWithAbort(
+        handshakeClient(token),
+        this.homey.constructor.HANDSHAKE_TIMEOUT,
+        `Failed to handshake client (Timeout after ${this.homey.constructor.HANDSHAKE_TIMEOUT}ms).`,
+        signal
+      );
+
+      this.homey.__debug('SocketIOClient.onHandshakeClientSuccess', `Namespace: ${result.namespace}`);
+
+      return result.namespace;
+    } catch (err) {
+      if ((err.statusCode === 401 || err.code === 401) && this.homey.__api != null) {
+        this.homey.__debug('Token expired, refreshing...');
+        await this.homey.refreshForToken(token, false);
+
+        const result = await this.__timeoutWithAbort(
+          handshakeClient(this.homey.__token),
+          this.homey.constructor.HANDSHAKE_TIMEOUT,
+          `Failed to handshake client (Timeout after ${this.homey.constructor.HANDSHAKE_TIMEOUT}ms).`,
+          signal
+        );
+
+        this.homey.__debug('SocketIOClient.onHandshakeClientSuccess', `Namespace: ${result.namespace}`);
+
+        return result.namespace;
+      }
+
+      throw err;
+    }
+  }
+
+  async __connectHomeySocket(namespace, signal) {
+    this.__homeySocket = this.__socket.io.socket(namespace);
+    this.__bindHomeySocket(namespace, this.__homeySocket);
+
+    if (this.__homeySocket.connected) {
+      return this.__homeySocket;
+    }
+
+    await this.__waitForConnect({
+      socket: this.__homeySocket,
+      signal,
+      errorEvents: ['connect_error', 'error'],
+      fallbackMessage: `Unknown error connecting to namespace ${namespace}.`,
+      onConnect: () => {
+        this.homey.__debug(`SocketIOClient.Namespace[${namespace}].onConnect`);
+      },
+      onConnectError: (err) => {
+        this.homey.__debug(`SocketIOClient.Namespace[${namespace}].onConnectError`, err.message);
+      },
+      open: () => {
+        this.__homeySocket.open();
+      },
+    });
+
+    return this.__homeySocket;
+  }
+
+  __bindHomeySocket(namespace, homeySocket) {
+    if (this.__boundHomeySocket === homeySocket) return;
+
+    this.__unbindHomeySocket();
+
+    this.__homeySocketHandlers = {
+      disconnect: (reason) => {
+        this.homey.__debug(`SocketIOClient.Namespace[${namespace}].onDisconnect`, reason);
+        this.__handleSessionDisconnect(reason);
+      },
+      reconnecting: (attempt) => {
+        this.homey.__debug(`SocketIOClient.Namespace[${namespace}].onReconnecting (Attempt #${attempt})`);
+      },
+      reconnect: () => {
+        this.homey.__debug(`SocketIOClient.Namespace[${namespace}].onReconnect`);
+      },
+      reconnectError: (err) => {
+        this.homey.__debug(`SocketIOClient.Namespace[${namespace}].onReconnectError`, err.message);
+      },
+      connectError: (err) => {
+        this.homey.__debug(`SocketIOClient.Namespace[${namespace}].onConnectError`, err.message);
+      },
+      error: (err) => {
+        this.homey.__debug(`SocketIOClient.Namespace[${namespace}].onError`, err.message || err);
+      },
+    };
+
+    homeySocket.on('disconnect', this.__homeySocketHandlers.disconnect);
+    homeySocket.on('reconnecting', this.__homeySocketHandlers.reconnecting);
+    homeySocket.on('reconnect', this.__homeySocketHandlers.reconnect);
+    homeySocket.on('reconnect_error', this.__homeySocketHandlers.reconnectError);
+    homeySocket.on('connect_error', this.__homeySocketHandlers.connectError);
+    homeySocket.on('error', this.__homeySocketHandlers.error);
+
+    this.__boundHomeySocket = homeySocket;
+  }
+
+  __unbindHomeySocket() {
+    if (!this.__boundHomeySocket || !this.__homeySocketHandlers) {
+      this.__boundHomeySocket = null;
+      this.__homeySocketHandlers = null;
+      return;
+    }
+
+    this.__boundHomeySocket.removeListener('disconnect', this.__homeySocketHandlers.disconnect);
+    this.__boundHomeySocket.removeListener('reconnecting', this.__homeySocketHandlers.reconnecting);
+    this.__boundHomeySocket.removeListener('reconnect', this.__homeySocketHandlers.reconnect);
+    this.__boundHomeySocket.removeListener('reconnect_error', this.__homeySocketHandlers.reconnectError);
+    this.__boundHomeySocket.removeListener('connect_error', this.__homeySocketHandlers.connectError);
+    this.__boundHomeySocket.removeListener('error', this.__homeySocketHandlers.error);
+
+    this.__boundHomeySocket = null;
+    this.__homeySocketHandlers = null;
+  }
+
+  async __waitForConnect({
+    socket,
+    signal,
+    errorEvents = [],
+    fallbackMessage,
+    onConnect = () => {},
+    onConnectError = () => {},
+    open = () => socket.open(),
+  }) {
+    if (socket.connected) return;
+
+    await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        cleanup();
+        reject(this.__createAbortError(signal.reason));
+      };
+
+      const handleConnect = () => {
+        cleanup();
+        onConnect();
+        resolve();
+      };
+
+      const handleConnectError = (err) => {
+        cleanup();
+
+        const normalizedError = this.__normalizeSocketError(err, fallbackMessage);
+        onConnectError(normalizedError);
+        reject(normalizedError);
+      };
+
+      const cleanup = () => {
+        socket.removeListener('connect', handleConnect);
+        for (const errorEvent of errorEvents) {
+          socket.removeListener(errorEvent, handleConnectError);
+        }
+
+        if (signal) {
+          signal.removeEventListener('abort', onAbort);
+        }
+      };
+
+      socket.once('connect', handleConnect);
+      for (const errorEvent of errorEvents) {
+        socket.once(errorEvent, handleConnectError);
+      }
+
+      if (signal) {
+        if (signal.aborted) {
+          cleanup();
+          reject(this.__createAbortError(signal.reason));
+          return;
+        }
+
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+
+      open();
+    });
+  }
+
+  async __timeoutWithAbort(promise, timeout, message, signal) {
+    const abortPromise = signal
+      ? new Promise((_, reject) => {
+          if (signal.aborted) {
+            reject(this.__createAbortError(signal.reason));
+            return;
+          }
+
+          signal.addEventListener(
+            'abort',
+            () => {
+              reject(this.__createAbortError(signal.reason));
+            },
+            { once: true }
+          );
+        })
+      : null;
+
+    if (abortPromise) {
+      return Promise.race([Util.timeout(promise, timeout, message), abortPromise]);
+    }
+
+    return Util.timeout(promise, timeout, message);
+  }
+
+  __cancelReadyCycle(message) {
+    if (this.__readyAbortController) {
+      this.__readyAbortController.abort(message);
+    }
+  }
+
+  __createAbortError(message) {
+    const err = new Error(message || 'Socket session aborted.');
+    err.name = 'AbortError';
+    return err;
+  }
+
+  __createNotReadyError(reason) {
+    const err = new Error(reason || 'Socket session not ready.');
+    err.code = SOCKET_SESSION_NOT_READY_CODE;
+    return err;
+  }
+
+  __normalizeSocketError(err, fallbackMessage) {
+    if (err instanceof Error) {
+      return err;
+    }
+
+    if (typeof err === 'object' && err != null) {
+      return new HomeyAPIError(
+        {
+          stack: err.stack,
+          error: err.error,
+          error_description: err.error_description || err.message,
+        },
+        err.statusCode || err.code
+      );
+    }
+
+    if (typeof err === 'string') {
+      return new Error(err);
+    }
+
+    return new Error(fallbackMessage);
+  }
+}
+
+module.exports = SocketSession;