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

package/src/camera/frameWorker.ts

@@ -1,403 +0,0 @@
-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);
-  }
-}