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

package/src/camera/frameWorker.ts

@@ -0,0 +1,403 @@
+import { IS_DEV, Logger, sleep, Subscribed } from '@camera.ui/common';
+import { fork, spawn } from 'node:child_process';
+import { platform } from 'node:os';
+import { container } from 'tsyringe';
+import { PLUGIN_STATUS } from '../plugins/types.js';
+import { NamespaceManager } from '../rpc/namespaces.js';
+import { nodeDecoderPath, pythonDecoderPath, pythonPath } from '../utils/path.js';
+import { PythonInstaller } from '../utils/pythonInstaller.js';
+
+import type { Promisify, SubscriptionWrapper } from '@camera.ui/rpc-common';
+import type { ChildProcess } from 'node:child_process';
+import type { SocketService } from '../api/websocket/index.js';
+import type { WorkerRuntime } from '../api/websocket/types.js';
+import type { FrameWorkerInterface, WorkerToMainMessage } from '../decoder/types.js';
+import type { ProxyServer } from '../rpc/index.js';
+import type { FrameWorkerNamespaces } from '../rpc/namespaces.js';
+import type { ConfigService } from '../services/config/index.js';
+import type { CameraController } from './controller.js';
+
+export class FrameWorker extends Subscribed {
+  private readonly configService: ConfigService;
+  private readonly socketService: SocketService;
+  private readonly proxyServer: ProxyServer;
+  private readonly py: PythonInstaller;
+
+  private isClosed = false;
+  private isRestarting = false;
+  private process?: ChildProcess;
+  private retryTimeout?: NodeJS.Timeout;
+  private subscription?: SubscriptionWrapper;
+  private namespaces: FrameWorkerNamespaces;
+  private _status: PLUGIN_STATUS = PLUGIN_STATUS.UNKNOWN;
+
+  // Logging
+  private readonly logger: Logger;
+  private readonly processLogger: Logger;
+  private logBuffer = '';
+
+  public get name(): string {
+    return this.camera.name;
+  }
+
+  public get status(): PLUGIN_STATUS {
+    return this._status;
+  }
+
+  constructor(private readonly camera: CameraController) {
+    super();
+
+    this.configService = container.resolve('configService');
+    this.socketService = container.resolve('socketService');
+    this.proxyServer = container.resolve('proxy');
+
+    // Initialize loggers
+    this.processLogger = (camera.logger as Logger).createLogger({
+      disablePrefix: true,
+      disableTimestamps: true,
+      prefix: undefined,
+      suffix: undefined,
+    });
+
+    this.logger = (camera.logger as Logger).createLogger({
+      prefix: 'Frame Worker',
+      suffix: camera.name,
+      logStream: camera.logStream,
+    });
+
+    this.namespaces = NamespaceManager.frameWorkerNamespaces(camera.id);
+    this.py = new PythonInstaller(this.configService.HOME_PATH, this.logger);
+
+    this.setupEventListeners();
+  }
+
+  private setupEventListeners(): void {
+    this.camera.onPropertyChange(['name', 'frameWorkerSettings', 'sources']).subscribe(({ property }) => {
+      if (property === 'name') {
+        this.logger.suffix = this.camera.name;
+      }
+
+      this.restart();
+    });
+
+    this.camera.onConnected.subscribe((connected) => {
+      if (connected) {
+        this.start();
+      } else {
+        this.stop();
+      }
+    });
+  }
+
+  public async start(): Promise<void> {
+    if (this.status === PLUGIN_STATUS.STARTING || this.status === PLUGIN_STATUS.STARTED) {
+      return;
+    }
+
+    if (!this.camera.connected) {
+      this.logger.debug('Camera not connected, worker will not start');
+      return;
+    }
+
+    // Clear any existing retry timeout
+    this.isClosed = false;
+    this.isRestarting = false;
+    clearTimeout(this.retryTimeout);
+    this.retryTimeout = undefined;
+
+    try {
+      await this.startWorkerProcess();
+    } catch (error) {
+      this.setStatus(PLUGIN_STATUS.ERROR);
+      this.logger.error('Failed to start worker:', error);
+    }
+  }
+
+  public async stop(): Promise<void> {
+    if (this.status === PLUGIN_STATUS.STOPPED || this.status === PLUGIN_STATUS.STOPPING) {
+      return;
+    }
+
+    this.logger.debug('Stopping Frame Worker');
+    this.setStatus(PLUGIN_STATUS.STOPPING);
+    await this.terminateProcess();
+    this.clearProcessState();
+  }
+
+  public async close(): Promise<void> {
+    this.logger.trace('Closing Frame Worker');
+
+    this.isClosed = true;
+    this.isRestarting = false;
+    clearTimeout(this.retryTimeout);
+    this.retryTimeout = undefined;
+
+    await this.stop();
+    this.unsubscribe();
+    await this.cleanupResources();
+  }
+
+  public async restart(): Promise<void> {
+    this.logger.debug('Restarting Frame Worker...');
+    this.isRestarting = true;
+
+    await this.stop();
+    await sleep(2000);
+    await this.start();
+  }
+
+  public getPID(): number {
+    return this.process?.pid ?? -1;
+  }
+
+  public async frameWorkerProxy(): Promise<Promisify<FrameWorkerInterface>> {
+    return await this.proxyServer.proxy.createRPCProxy<FrameWorkerInterface>(this.namespaces.frameWorkerChildRpc);
+  }
+
+  private startWorkerProcess(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      try {
+        const selectedDecoder = this.camera.frameWorkerSettings.decoder;
+        const isPython = selectedDecoder === 'pillow';
+        const workerPath = isPython ? pythonDecoderPath : nodeDecoderPath;
+
+        this.logger.debug(`Starting Frame Worker (${selectedDecoder})`);
+        this.logger.trace('Worker path:', workerPath);
+        this.setStatus(PLUGIN_STATUS.STARTING);
+
+        // Setup message subscription
+        this.subscription = this.proxyServer.proxy.onServiceMessage<WorkerToMainMessage>(this.namespaces.frameWorkerChild, this.handleWorkerMessage.bind(this, resolve));
+
+        const env = this.buildWorkerEnv();
+        const processName = `camera.ui - Frame Worker (${selectedDecoder})`;
+
+        if (isPython) {
+          this.process = spawn(this.py.serverPythonPath, ['-u', workerPath, processName], {
+            env: {
+              ...env,
+              PYTHONUNBUFFERED: '1',
+              PYTHONPATH: this.createPythonPath(),
+            },
+          });
+        } else {
+          this.process = fork(workerPath, [processName], {
+            env: {
+              ...process.env,
+              ...env,
+            },
+            silent: true,
+            execArgv: IS_DEV ? ['--import=tsx'] : undefined,
+          });
+        }
+
+        this.setupProcessListeners(processName);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  private async terminateProcess(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      if (!this.process) {
+        this.setStatus(PLUGIN_STATUS.STOPPED);
+        resolve();
+        return;
+      }
+
+      const timeout = setTimeout(() => {
+        this.logger.warn('Worker did not terminate gracefully. Forcing closure.');
+        this.process?.kill('SIGKILL');
+        this.setStatus(PLUGIN_STATUS.STOPPED);
+        resolve();
+      }, 3000);
+
+      this.process.once('exit', () => {
+        clearTimeout(timeout);
+        this.setStatus(PLUGIN_STATUS.STOPPED);
+        this.logger.debug('Worker closed!');
+        resolve();
+      });
+
+      this.process.kill('SIGTERM');
+    });
+  }
+
+  private setupProcessListeners(processName: string): void {
+    if (!this.process) {
+      return;
+    }
+
+    this.process.once('spawn', () => {
+      this.logger.log(`Process started with PID: ${this.process?.pid}`);
+
+      const pid = this.process?.pid;
+      if (pid) {
+        this.configService.addProcess({
+          pid,
+          startTime: Date.now(),
+          command: this.camera.frameWorkerSettings.decoder === 'pillow' ? this.py.serverPythonPath : process.execPath,
+          args: [processName],
+          titles: [processName, 'camera.ui - Frame Worker'],
+        });
+      }
+    });
+
+    this.process.once('error', (error) => {
+      this.setStatus(PLUGIN_STATUS.ERROR);
+      this.logger.error('Process error:', error);
+    });
+
+    this.process.once('exit', (code, signal) => {
+      this.logger.trace(`Process exited with code: ${code} and signal: ${signal}`);
+      this.setStatus(PLUGIN_STATUS.STOPPED);
+      this.configService.removeProcessByPID(this.process?.pid);
+      this.handleProcessExit();
+    });
+
+    // Setup logging streams
+    this.process.stdout?.on('data', (data) => this.handleLogData(data));
+    this.process.stderr?.on('data', (data) => this.handleLogData(data));
+  }
+
+  private handleWorkerMessage(resolve: (value: void | PromiseLike<void>) => void, message: WorkerToMainMessage): void {
+    if (message.message === 'started') {
+      this.setStatus(PLUGIN_STATUS.STARTED);
+      this.logger.debug('Frame Worker ready');
+      resolve();
+    }
+  }
+
+  private handleProcessExit(): void {
+    this.logger.warn('Worker process exited!');
+    this.clearProcessState();
+    this.attemptRestart();
+  }
+
+  private attemptRestart(): void {
+    // Don't restart if worker is closed or in invalid status
+    if (this.isRestarting || this.isClosed || this.status === PLUGIN_STATUS.STOPPING || this.status === PLUGIN_STATUS.STARTING) {
+      return;
+    }
+
+    this.logger.debug('Attempting restart in 5s...');
+    clearTimeout(this.retryTimeout);
+
+    this.retryTimeout = setTimeout(async () => {
+      // Double check conditions again as they might have changed
+      if (this.isRestarting || this.isClosed || this.status === PLUGIN_STATUS.STOPPING || this.status === PLUGIN_STATUS.STARTING) {
+        return;
+      }
+
+      try {
+        this.logger.debug('Executing scheduled restart');
+        await this.restart();
+      } catch (error) {
+        this.logger.error('Failed to restart worker:', error);
+      }
+    }, 5000);
+  }
+
+  private async cleanupResources(): Promise<void> {
+    await this.proxyServer.proxy.disconnectRPCConnection(this.namespaces.frameWorkerChildRpc);
+    this.logBuffer = '';
+  }
+
+  private clearProcessState(): void {
+    this.camera.updateState('motion', { state: false, detections: [] });
+    this.camera.updateState('object', { detections: [] });
+
+    this.process?.removeAllListeners();
+    this.process?.stdout?.removeAllListeners();
+    this.process?.stderr?.removeAllListeners();
+    this.process = undefined;
+
+    this.subscription?.unsubscribe();
+    this.subscription = undefined;
+  }
+
+  private setStatus(newStatus: PLUGIN_STATUS): void {
+    if (this.status === newStatus) {
+      return;
+    }
+
+    this._status = newStatus;
+
+    const runtime: WorkerRuntime = {
+      [this.camera.name]: {
+        name: this.camera.name,
+        status: newStatus,
+      },
+    };
+
+    this.camera.updateFrameWorkerState(newStatus === PLUGIN_STATUS.STARTED);
+    this.socketService.io.of('/status').emit('frameworker-process-status', runtime);
+  }
+
+  private handleLogData(data: Buffer): void {
+    const rawData = data.toString();
+    this.logBuffer += rawData;
+
+    let endIndex: number;
+    while ((endIndex = this.logBuffer.indexOf(Logger.LOGGER_END)) !== -1) {
+      const logEntry = this.logBuffer.slice(0, endIndex);
+      this.writeProcessLog(logEntry);
+      this.logBuffer = this.logBuffer.slice(endIndex + Logger.LOGGER_END.length);
+    }
+
+    const remainingLines = this.logBuffer.split('\n');
+    this.logBuffer = remainingLines.pop() ?? '';
+    remainingLines.forEach((line) => this.writeProcessLog(line));
+  }
+
+  private writeProcessLog(content: string): void {
+    if (content.trim() && !content.includes('returning true from eof_received')) {
+      this.processLogger.log(content);
+      this.camera.writeLog(content);
+    }
+  }
+
+  private buildWorkerEnv(): Record<string, any> {
+    const source = this.getCameraSource();
+
+    return {
+      CAMERA_ID: this.camera.id,
+      CAMERA_NAME: this.camera.name,
+      CAMERA_SOURCE: source,
+      FFMPEG_PATH: this.configService.go2rtcConfig.ffmpeg.bin,
+      PROXY_USER: this.proxyServer.auth.server.user,
+      PROXY_PASSWORD: this.proxyServer.auth.server.password,
+      PROXY_ENDPOINTS: this.proxyServer.server.endpoints.join(','),
+      PROXY_CERT: this.configService.ssl.cert.toString('utf-8'),
+      PROXY_KEY: this.configService.ssl.key.toString('utf-8'),
+      PROXY_CA: this.configService.ssl.ca.toString('utf-8'),
+      FPS: this.camera.frameWorkerSettings.fps.toString(),
+      RESOLUTION: this.camera.frameWorkerSettings.resolution,
+      DECODER: this.camera.frameWorkerSettings.decoder,
+      LOGGER_LEVEL: this.configService.config.logger.level,
+      LOGGER_DISABLE_TIMESTAMPS: this.configService.config.logger.disableTimestamps ? '1' : '0',
+    };
+  }
+
+  private getCameraSource(): string {
+    const lowRes = this.camera.lowResolutionSource;
+    const midRes = this.camera.midResolutionSource;
+
+    if (!lowRes && !midRes) {
+      const streamSource = this.camera.streamSource;
+
+      if (!this.camera.isCloud) {
+        this.logger.warn('No low-resolution source found! Switching to stream source:', streamSource.name);
+        this.logger.warn('Please make sure to configure a low-resolution source for better performance!');
+      }
+
+      return streamSource.urls.rtsp.muted;
+    }
+    return (lowRes?.urls.rtsp.muted ?? midRes?.urls.rtsp.muted)!;
+  }
+
+  private createPythonPath(): string {
+    const separator = platform() === 'win32' ? ';' : ':';
+    return [this.py.serverPackagesPath, pythonPath].join(separator);
+  }
+}