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

package/src/plugins/worker.ts

@@ -1,250 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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`,
-    };
-  }
-}