@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/src/plugins/worker.ts

@@ -0,0 +1,250 @@
+import { sleep } from '@camera.ui/common/utils';
+import { container } from 'tsyringe';
+
+import { PLUGIN_COMMAND, PLUGIN_STATUS } from '../plugins/types.js';
+import { NamespaceManager } from '../rpc/namespaces.js';
+
+import { CamerasService } from '../api/services/cameras.service.js';
+import { RuntimeFactory } from './runtime/index.js';
+
+import type { Promisify, SubscriptionWrapper } from '@camera.ui/rpc-common';
+import type { Camera, CuiPlugin, DeviceStorage } from '@camera.ui/types';
+import type { CameraUiAPI } from '../api.js';
+import type { SocketService } from '../api/websocket/index.js';
+import type { WorkerRuntime } from '../api/websocket/types.js';
+import type { ProcessMessage, ProcessResponse } from '../plugins/types.js';
+import type { ProxyServer } from '../rpc/index.js';
+import type { PluginNamespaces } from '../rpc/namespaces.js';
+import type { Plugin } from './plugin.js';
+import type { BasePluginRuntime } from './runtime/base.js';
+
+export class PluginWorker {
+  private api: CameraUiAPI;
+  private socketService: SocketService;
+  private proxyServer: ProxyServer;
+  private runtime: BasePluginRuntime;
+
+  private started = false;
+  private shuttingDown = false;
+
+  private subscription?: SubscriptionWrapper;
+  private namespaces: PluginNamespaces;
+
+  private _status: PLUGIN_STATUS = PLUGIN_STATUS.UNKNOWN;
+
+  public get status(): PLUGIN_STATUS {
+    return this._status;
+  }
+
+  constructor(public plugin: Plugin) {
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.socketService = container.resolve<SocketService>('socketService');
+    this.proxyServer = container.resolve<ProxyServer>('proxy');
+
+    this.namespaces = NamespaceManager.pluginNamespaces(this.plugin.id);
+    this.runtime = RuntimeFactory.createRuntime(this.plugin);
+
+    if (this.plugin.disabled) {
+      this._status = PLUGIN_STATUS.DISABLED;
+    }
+  }
+
+  public async pluginProxy(): Promise<Promisify<CuiPlugin>> {
+    return await this.proxyServer.proxy.createRPCProxy<CuiPlugin>(this.namespaces.pluginChildRpc);
+  }
+
+  public async start(): Promise<void> {
+    if (this.isRunning()) {
+      this.runtime.logger.warn(
+        `Cannot start plugin! Plugin ${this.plugin.displayName} (${this.plugin.pluginName}.${this.plugin.info.installedVersion}) already running!`,
+      );
+      return;
+    }
+
+    if (this.plugin.disabled) {
+      this.setStatus(PLUGIN_STATUS.DISABLED);
+      this.runtime.logger.warn(`Can not start plugin. Plugin ${this.plugin.displayName} is disabled!`);
+      return;
+    }
+
+    this.runtime.writeHeader();
+    this.setStatus(PLUGIN_STATUS.STARTING);
+    this.shuttingDown = false;
+
+    return new Promise<void>(async (resolve, reject) => {
+      try {
+        await this.reset();
+        this.subscription = this.proxyServer.proxy.onPluginMessage<ProcessResponse>(this.namespaces.pluginChild, this.onMessage.bind(this, resolve, reject));
+        this.runtime.once('exit', this.handleClose.bind(this));
+        await this.runtime.start();
+      } catch (error) {
+        this.setStatus(PLUGIN_STATUS.ERROR);
+        this.teardown();
+        reject(error);
+      }
+    });
+  }
+
+  public async teardown(destroy?: boolean): Promise<void> {
+    if (this.isRunning()) {
+      this.runtime.logger.log(`Stopping plugin: ${this.plugin.pluginName}.${this.plugin.displayName}...`);
+    }
+
+    this.shuttingDown = true;
+
+    const cameraControllers = this.api.getCameras(this.plugin.id);
+    cameraControllers.forEach((cameraController) => cameraController.disconnect());
+
+    if (destroy) {
+      this.runtime.kill();
+    } else {
+      await this.kill();
+    }
+  }
+
+  public async restart(): Promise<void> {
+    await this.teardown();
+    await sleep(1000);
+    await this.start();
+  }
+
+  public disable(): void {
+    this.teardown();
+    this.setStatus(PLUGIN_STATUS.DISABLED);
+  }
+
+  public getPID(): number {
+    return this.runtime.getPID();
+  }
+
+  public isRunning(): boolean {
+    return this.runtime.isRunning() && this.started;
+  }
+
+  public isReady(): boolean {
+    return this.status === PLUGIN_STATUS.READY || this.status === PLUGIN_STATUS.STARTED;
+  }
+
+  public async cleanup(): Promise<void> {
+    this.runtime.cleanup();
+    await this.teardown();
+  }
+
+  public writeLog(...args: any[]): void {
+    this.runtime.writeLog(...args);
+  }
+
+  public async storageProxy(): Promise<Promisify<DeviceStorage>> {
+    return this.proxyServer.proxy.createRPCProxy<DeviceStorage>(this.namespaces.pluginStorageRpc);
+  }
+
+  private sendMessage(message: ProcessMessage): void {
+    this.proxyServer.proxy.sendToPlugin<ProcessMessage>(this.namespaces.pluginChild, message);
+  }
+
+  private gatherDevices(): Camera[] {
+    const camerasService = new CamerasService();
+    const pluginCameras = camerasService.listTransformedByPluginId(this.plugin.id);
+    const extensionCameras = camerasService.listTransformedByExtension(this.plugin.pluginName, this.plugin.contract.extensions);
+
+    const cameraMap = new Map<string, Camera>();
+    [...pluginCameras, ...extensionCameras].forEach((camera) => {
+      cameraMap.set(camera._id, camera);
+    });
+
+    return Array.from(cameraMap.values());
+  }
+
+  private async kill(): Promise<void> {
+    this.sendMessage({ type: PLUGIN_COMMAND.STOP });
+
+    const cameraControllers = this.api.getCameras(this.plugin.id);
+    cameraControllers.forEach((cameraController) => cameraController.disconnect());
+
+    await this.runtime.stop();
+  }
+
+  private setStatus(status: PLUGIN_STATUS): void {
+    if (this._status === status) {
+      return;
+    }
+
+    this._status = status;
+    this.started = status === PLUGIN_STATUS.STARTED;
+
+    const runtimeInfo: WorkerRuntime = {
+      [this.plugin.pluginName]: {
+        name: this.plugin.pluginName,
+        status: status,
+      },
+    };
+
+    this.socketService.io.of('/status').emit('plugin-process-status', runtimeInfo);
+    this.socketService.io.of('/plugins').emit(`plugin-status-${this.plugin.pluginName}`, runtimeInfo[this.plugin.pluginName]);
+  }
+
+  private async handleClose(): Promise<void> {
+    await this.proxyServer.proxy.disconnectRPCConnection(this.namespaces.pluginChildRpc);
+    await this.proxyServer.proxy.disconnectRPCConnection(this.namespaces.pluginStorageRpc);
+
+    if (this.plugin.disabled) {
+      this.setStatus(PLUGIN_STATUS.DISABLED);
+    } else {
+      this.setStatus(PLUGIN_STATUS.STOPPED);
+    }
+
+    if (!this.shuttingDown) {
+      this.runtime.logger.log(`Restarting plugin: ${this.plugin.pluginName}.${this.plugin.displayName} in 5s...`);
+
+      setTimeout(() => {
+        this.start();
+      }, 5000);
+    }
+  }
+
+  private async reset(): Promise<void> {
+    this.subscription?.unsubscribe();
+    this.subscription = undefined;
+    await sleep(100);
+  }
+
+  private async onMessage(resolve: (value: void | PromiseLike<void>) => void, reject: (reason?: any) => void, message: ProcessResponse) {
+    switch (message.type) {
+      case PLUGIN_STATUS.READY:
+        this.runtime.logger.debug(`Plugin ready: ${this.plugin.displayName} (${this.plugin.pluginName}@${this.plugin.info.installedVersion})`);
+
+        this.setStatus(PLUGIN_STATUS.READY);
+
+        this.sendMessage({
+          type: PLUGIN_COMMAND.START,
+          data: {
+            cameras: this.gatherDevices(),
+            plugin: {
+              id: this.plugin.id,
+              name: this.plugin.pluginName,
+              contract: this.plugin.contract,
+            },
+            storage: {
+              installPath: this.plugin.installPath,
+              storagePath: this.plugin.storagePath,
+            },
+          },
+        });
+        break;
+      case PLUGIN_STATUS.STARTED:
+        this.runtime.logger.log(`Plugin started: ${this.plugin.displayName} (${this.plugin.pluginName}@${this.plugin.info.installedVersion})`);
+        this.setStatus(PLUGIN_STATUS.STARTED);
+        resolve();
+        break;
+      case PLUGIN_STATUS.ERROR:
+        // this.runtime.logger.error(`Plugin error: ${this.plugin.displayName} (${this.plugin.pluginName}@${this.plugin.info.installedVersion})`, message.error);
+        this.setStatus(PLUGIN_STATUS.ERROR);
+        this.teardown();
+        reject(message.error);
+        break;
+      default:
+        this.runtime.logger.warn(`Unknown message type: ${message.type}`);
+        reject(`Unknown message type: ${message.type}`);
+    }
+  }
+}

package/src/rpc/index.ts

@@ -0,0 +1,149 @@
+import { RPCServer } from '@camera.ui/rpc-server';
+import { container } from 'tsyringe';
+import { NamespaceManager } from './namespaces.js';
+
+import { API_EVENT } from '../api.js';
+import { CoreManagerProxy } from '../manager/coreManager.js';
+import { DeviceManagerProxy } from '../manager/deviceManager.js';
+import { NATS } from './server.js';
+import { generateCredentials } from './utils.js';
+
+import type { ResponseMessage } from '@camera.ui/rpc-common';
+import type { StateValues } from '@camera.ui/types';
+import type { CameraUiAPI } from '../api.js';
+import type { ConfigService } from '../services/config/index.js';
+import type { LoggerService } from '../services/logger/index.js';
+import type { CoreManagerNamespaces, DeviceManagerNamespaces } from './namespaces.js';
+import type {
+  CameraDeviceListenerMessagePayload,
+  CameraDeviceListenerStatePayload,
+  CoreManagerProxyEvents,
+  CoreManagerProxyGenericEvent,
+  DeviceManagerProxyEvents,
+  DeviceManagerProxyGenericEvent,
+  ProxyAuth,
+} from './types.js';
+
+export class ProxyServer {
+  private api: CameraUiAPI;
+  private logger: LoggerService;
+  private configService: ConfigService;
+
+  public server: NATS;
+  public proxy!: RPCServer;
+
+  public coreManagerProxy?: CoreManagerProxy;
+  public deviceManagerProxy?: DeviceManagerProxy;
+
+  private initialized = false;
+
+  private namespaces: DeviceManagerNamespaces & CoreManagerNamespaces;
+
+  public auth: ProxyAuth = {
+    cluster: generateCredentials(),
+    server: generateCredentials(),
+  };
+
+  constructor() {
+    container.registerInstance('proxy', this);
+
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.logger = container.resolve<LoggerService>('logger');
+    this.configService = container.resolve<ConfigService>('configService');
+
+    this.server = new NATS(this.auth);
+
+    this.namespaces = {
+      ...NamespaceManager.deviceManagerNamespaces(),
+      ...NamespaceManager.coreManagerNamespaces(),
+    };
+
+    this.api.setMaxListeners(this.api.getMaxListeners() + 1);
+    this.api.once(API_EVENT.SHUTDOWN, this.close.bind(this));
+  }
+
+  public async initialize() {
+    if (this.initialized) {
+      return;
+    }
+
+    this.initialized = true;
+
+    await this.server.start();
+
+    this.proxy = new RPCServer({
+      endpoints: this.server.endpoints.filter((endpoint) => endpoint.startsWith('nats://')),
+      auth: this.auth,
+      tls: {
+        cert: this.configService.ssl.cert.toString('utf8'),
+        key: this.configService.ssl.key.toString('utf8'),
+        ca: this.configService.ssl.ca?.toString('utf8'),
+      },
+      metadata: {
+        id: 'camera.ui',
+        name: 'camera.ui',
+      },
+      connect: {
+        waitForServer: true,
+      },
+      reconnect: {
+        enabled: true,
+      },
+      bundledConnection: false,
+    });
+
+    this.coreManagerProxy = new CoreManagerProxy();
+    this.deviceManagerProxy = new DeviceManagerProxy();
+
+    await this.proxy.start();
+    await this.proxy.registerRPCHandler(this.namespaces.coreManagerRpc, this.coreManagerProxy);
+    await this.proxy.registerRPCHandler(this.namespaces.deviceManagerRpc, this.deviceManagerProxy);
+  }
+
+  public async close(): Promise<void> {
+    await this.server.stop();
+    await this.proxy.stop();
+    this.logger.debug('Proxy server closed');
+  }
+
+  public publishCoreManagerEvent<K extends keyof CoreManagerProxyEvents>(type: K, data: CoreManagerProxyEvents[K]): void {
+    const event: CoreManagerProxyGenericEvent<K> = { type, data };
+    this.proxy.publish(this.namespaces.coreManagerSubject, event);
+  }
+
+  public publishDeviceManagerEvent<K extends keyof DeviceManagerProxyEvents>(pluginId: string, type: K, data: DeviceManagerProxyEvents[K]): void {
+    const namespaces = NamespaceManager.pluginNamespaces(pluginId);
+    const event: DeviceManagerProxyGenericEvent<K> = { type, data };
+    this.proxy.publish(namespaces.pluginDeviceManagerSubject, event);
+  }
+
+  public async requestCoreManagerEvent<K extends keyof CoreManagerProxyEvents, R = any>(type: K, data: CoreManagerProxyEvents[K]): Promise<ResponseMessage<R>> {
+    const event: CoreManagerProxyGenericEvent<K> = { type, data };
+    return this.proxy.request<CoreManagerProxyGenericEvent<K>, R>(this.namespaces.coreManagerSubject, event);
+  }
+
+  public async requestDeviceManagerEvent<K extends keyof DeviceManagerProxyEvents, R = any>(
+    pluginId: string,
+    type: K,
+    data: DeviceManagerProxyEvents[K],
+  ): Promise<ResponseMessage<R>> {
+    const namespaces = NamespaceManager.pluginNamespaces(pluginId);
+    const event: DeviceManagerProxyGenericEvent<K> = { type, data };
+    return this.proxy.request<DeviceManagerProxyGenericEvent<K>, R>(namespaces.pluginDeviceManagerSubject, event);
+  }
+
+  public publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateName: K, data: { newEvent: StateValues[K]; oldEvent: StateValues[K] }): void;
+  public publishCameraEvent(cameraId: string, type: CameraDeviceListenerMessagePayload['type'], data?: any): void;
+  public publishCameraEvent<K extends keyof StateValues>(cameraId: string, stateOrType: K | CameraDeviceListenerMessagePayload['type'], data: any): void {
+    const namespaces = NamespaceManager.cameraNamespaces(cameraId);
+    const event: CameraDeviceListenerStatePayload<K> | CameraDeviceListenerMessagePayload = this.isCameraState(stateOrType)
+      ? { stateName: stateOrType, data }
+      : { type: stateOrType, data };
+    this.proxy.publish(namespaces.cameraSubject, event);
+  }
+
+  private isCameraState(value: any): value is keyof StateValues {
+    const validStateNames: (keyof StateValues)[] = ['light', 'motion', 'audio', 'object', 'doorbell', 'siren'];
+    return validStateNames.includes(value);
+  }
+}

package/src/rpc/namespaces.ts

@@ -0,0 +1,79 @@
+export interface CoreManagerNamespaces {
+  coreManagerSubject: string;
+  coreManagerRpc: string;
+}
+
+export interface DeviceManagerNamespaces {
+  deviceManagerSubject: string;
+  deviceManagerRpc: string;
+}
+
+export interface FrameWorkerNamespaces {
+  frameWorkerChildRpc: string;
+  frameWorkerChild: string;
+}
+
+export interface PluginNamespaces {
+  pluginDeviceManagerSubject: string;
+  pluginChildRpc: string;
+  pluginChild: string;
+  pluginStorageRpc: string;
+}
+
+export interface CameraNamespaces {
+  cameraSubject: string;
+  cameraControllerRpc: string;
+  cameraMotionFrameSubject: string;
+}
+
+export interface PluginCameraNamespaces {
+  cameraInterfacesRpc: string;
+  cameraStorageRpc: string;
+}
+
+export class NamespaceManager {
+  static coreManagerNamespaces(): CoreManagerNamespaces {
+    return {
+      coreManagerSubject: 'coreManager.subscriber',
+      coreManagerRpc: 'coreManager.rpc',
+    };
+  }
+
+  static deviceManagerNamespaces(): DeviceManagerNamespaces {
+    return {
+      deviceManagerSubject: 'deviceManager.subscriber',
+      deviceManagerRpc: 'deviceManager.rpc',
+    };
+  }
+
+  static frameWorkerNamespaces(cameraId: string): FrameWorkerNamespaces {
+    return {
+      frameWorkerChildRpc: `camera.${cameraId}.frameWorker.child.rpc`,
+      frameWorkerChild: `camera.${cameraId}.frameWorker.child`,
+    };
+  }
+
+  static pluginNamespaces(pluginId: string): PluginNamespaces {
+    return {
+      pluginDeviceManagerSubject: `plugin.${pluginId}.deviceManager.subscriber`,
+      pluginChildRpc: `plugin.${pluginId}.child.rpc`,
+      pluginChild: `plugin.${pluginId}.child`,
+      pluginStorageRpc: `plugin.${pluginId}.storage.rpc`,
+    };
+  }
+
+  static cameraNamespaces(cameraId: string): CameraNamespaces {
+    return {
+      cameraSubject: `camera.${cameraId}.subscriber`,
+      cameraMotionFrameSubject: `camera.${cameraId}.motionFrame.subscriber`,
+      cameraControllerRpc: `camera.${cameraId}.controller.rpc`,
+    };
+  }
+
+  static pluginCameraNamespaces(pluginId: string, cameraId: string): PluginCameraNamespaces {
+    return {
+      cameraInterfacesRpc: `plugin.${pluginId}.camera.${cameraId}.cameraInterfaces.rpc`,
+      cameraStorageRpc: `plugin.${pluginId}.camera.${cameraId}.cameraStorage.rpc`,
+    };
+  }
+}