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

package/src/api/database/checks.ts

@@ -0,0 +1,268 @@
+import { isProcessRunning } from '@camera.ui/common';
+import { ffmpegPath } from '@camera.ui/ffmpeg';
+import fkill from 'fkill';
+import { open } from 'lmdb';
+import { exec } from 'node:child_process';
+import { constants, existsSync } from 'node:fs';
+import { access, unlink } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { promisify } from 'node:util';
+import psList from 'ps-list';
+import { container } from 'tsyringe';
+
+import type { ConfigService } from '../../services/config/index.js';
+
+export interface PathExistenceResult {
+  path: string;
+  exists: boolean;
+}
+
+export interface FFmpegExistenceResult {
+  path: string;
+  exists: boolean;
+  hasPermissions: boolean;
+  error?: Error;
+}
+
+export interface PathPermissionsResult {
+  path: string;
+  hasPermissions: boolean;
+  error?: Error;
+}
+
+export interface CleanedUpFilesResult {
+  path: string;
+  wasCleaned: boolean;
+  error?: Error;
+}
+
+export interface DatabaseCorruptionResult {
+  dbPath: string;
+  isCorrupt: boolean;
+  error?: Error;
+}
+
+export interface PortAvailabilityResult {
+  port: number;
+  isAvailable: boolean;
+}
+
+export interface OrphanedProcessesResult {
+  processInfo: ProcInfo;
+  killed?: boolean;
+  wasOrphaned?: boolean;
+  error?: Error;
+}
+
+export interface PathPermission {
+  path: string;
+  mode: number;
+}
+
+export interface ProcInfo {
+  pid: number;
+  startTime: number;
+  command: string;
+  args: string[];
+  titles?: string[];
+  uniqueId?: string;
+}
+
+const execAsync = promisify(exec);
+
+async function defaultFFmpegPath(): Promise<string | undefined> {
+  try {
+    const command = process.platform === 'win32' ? 'where ffmpeg' : 'which ffmpeg';
+    const { stdout } = await execAsync(command);
+    const ffmpegPath = stdout.trim();
+    return ffmpegPath;
+  } catch {
+    //
+  }
+}
+
+async function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once('error', (err: NodeJS.ErrnoException) => {
+      server.close();
+      resolve(err.code !== 'EADDRINUSE');
+    });
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port);
+  });
+}
+
+async function isOwnProcess(processInfo: ProcInfo): Promise<boolean> {
+  const processes = await psList();
+  const proc = processes.find((p) => p.pid === processInfo.pid);
+
+  if (!proc) {
+    return false;
+  }
+
+  const isCommandMatch = Boolean(proc.name === processInfo.command || proc.cmd?.includes(processInfo.command));
+  const areArgsMatch = processInfo.args.every((arg) => proc.cmd?.includes(arg));
+  const idMatch = Boolean(processInfo.uniqueId ? proc.cmd?.includes(processInfo.uniqueId) : false);
+  const titleMatch = Boolean(processInfo.titles ? processInfo.titles.some((title) => proc.name?.includes(title) || proc.cmd?.includes(title)) : false);
+
+  if (idMatch || titleMatch || (isCommandMatch && areArgsMatch)) {
+    return true;
+  }
+
+  return false;
+}
+
+export async function checkPathsExist(pathsToCheck: string[]): Promise<PathExistenceResult[]> {
+  const results: PathExistenceResult[] = [];
+
+  for (const path of pathsToCheck) {
+    const exists = existsSync(path);
+    results.push({ path, exists });
+  }
+
+  return results;
+}
+
+export async function checkPathPermissions(pathsWithPermissionsToCheck: PathPermission[]): Promise<PathPermissionsResult[]> {
+  const results: PathPermissionsResult[] = [];
+
+  for (const { path, mode } of pathsWithPermissionsToCheck) {
+    try {
+      await access(path, mode);
+      results.push({ path, hasPermissions: true });
+    } catch (err) {
+      results.push({ path, hasPermissions: false, error: err as Error });
+    }
+  }
+
+  return results;
+}
+
+export async function cleanUpFiles(filesToClean: string[]): Promise<CleanedUpFilesResult[]> {
+  const cleanedFiles: CleanedUpFilesResult[] = [];
+
+  for (const file of filesToClean) {
+    try {
+      await access(file, constants.W_OK);
+      await unlink(file);
+
+      cleanedFiles.push({ path: file, wasCleaned: true });
+    } catch (err) {
+      cleanedFiles.push({ path: file, wasCleaned: false, error: err as Error });
+    }
+  }
+
+  return cleanedFiles;
+}
+
+export async function checkDatabaseCorruption(dbPath: string): Promise<DatabaseCorruptionResult> {
+  try {
+    const db = open({
+      path: dbPath,
+      readOnly: true,
+    });
+
+    await db.get('test_key');
+    await db.close();
+
+    return { dbPath, isCorrupt: false };
+  } catch (err) {
+    return { dbPath, isCorrupt: true, error: err as Error };
+  }
+}
+
+export async function checkPortAvailability(portsToCheck: number[]): Promise<PortAvailabilityResult[]> {
+  const results: PortAvailabilityResult[] = [];
+
+  for (const port of portsToCheck) {
+    const isAvailable = await isPortAvailable(port);
+    results.push({ port, isAvailable });
+  }
+
+  return results;
+}
+
+export async function checkFfmpegBinary(ffmpegPaths: string[]): Promise<PathExistenceResult[]> {
+  const results: PathExistenceResult[] = [];
+
+  for (const ffmpegPath of ffmpegPaths) {
+    try {
+      await access(ffmpegPath, constants.X_OK);
+      results.push({ exists: true, path: ffmpegPath });
+    } catch {
+      results.push({ exists: false, path: ffmpegPath });
+    }
+  }
+
+  return results;
+}
+
+export async function checkOrphanedProcesses(processInfos: ProcInfo[]): Promise<OrphanedProcessesResult[]> {
+  const configService = container.resolve<ConfigService>('configService');
+  const results: OrphanedProcessesResult[] = [];
+
+  for (const processInfo of processInfos) {
+    try {
+      const isRunning = isProcessRunning(processInfo.pid);
+      if (isRunning) {
+        const isOwnProc = await isOwnProcess(processInfo);
+        if (isOwnProc) {
+          const info: OrphanedProcessesResult = {
+            processInfo,
+            wasOrphaned: true,
+          };
+
+          try {
+            await fkill(processInfo.pid, { force: true });
+            info.killed = true;
+          } catch (error) {
+            info.killed = false;
+            info.error = error as Error;
+          }
+
+          results.push(info);
+        } else {
+          results.push({ processInfo, wasOrphaned: false });
+          configService.removeProcessByPID(processInfo.pid);
+        }
+      } else {
+        results.push({ processInfo, wasOrphaned: false });
+        configService.removeProcessByPID(processInfo.pid);
+      }
+    } catch (err) {
+      results.push({ processInfo, error: err as Error });
+    }
+  }
+
+  return results;
+}
+
+export async function checkInstalledFFmpegs(): Promise<FFmpegExistenceResult[]> {
+  const configService = container.resolve<ConfigService>('configService');
+  const results: FFmpegExistenceResult[] = [];
+
+  const osFFmpegPath = await defaultFFmpegPath();
+  const ffmpegPaths = new Set<string>([configService.go2rtcConfig.ffmpeg.binary, ffmpegPath(), osFFmpegPath].filter(Boolean) as string[]);
+
+  for (const ffmpegPath of ffmpegPaths) {
+    const exists = existsSync(ffmpegPath);
+
+    if (!exists) {
+      results.push({ path: ffmpegPath, exists, hasPermissions: false });
+      continue;
+    }
+
+    try {
+      await access(ffmpegPath, constants.X_OK);
+      results.push({ exists, path: ffmpegPath, hasPermissions: true });
+    } catch (error) {
+      results.push({ exists, path: ffmpegPath, hasPermissions: false, error: error as Error });
+    }
+  }
+
+  return results;
+}

package/src/api/database/constants.ts

@@ -0,0 +1,8 @@
+export const CAMERAS_ID = 'cameras';
+export const DATABASE_ID = 'database';
+export const PLUGINS_ID = 'plugins';
+export const USER_PLUGINS_ID = 'user-plugins';
+export const SETTINGS_ID = 'settings';
+export const USERS_ID = 'users';
+export const SYSTEM_ID = 'system';
+export const TOKENS_ID = 'tokens';

package/src/api/database/index.ts

@@ -0,0 +1,262 @@
+import { createSourceName, sleep } from '@camera.ui/common/utils';
+import { open } from 'lmdb';
+import { createHmac, randomBytes, randomUUID } from 'node:crypto';
+import semver from 'semver';
+import { container } from 'tsyringe';
+
+import { API_EVENT } from '../../api.js';
+import { CAMERAS_ID, DATABASE_ID, PLUGINS_ID, SETTINGS_ID, SYSTEM_ID, TOKENS_ID, USERS_ID } from './constants.js';
+import { DatabaseMigrationTable } from './migration.js';
+import { SelfCheck } from './selfcheck.js';
+
+import type { Database as DB, RootDatabase as RootDB } from 'lmdb';
+import type { CameraUiAPI } from '../../api.js';
+import type { ConfigService } from '../../services/config/index.js';
+import type { LoggerService } from '../../services/logger/index.js';
+import type { DBAuth, DBCamera, DBPlugin, DBSettings, DBSystem, DBUser } from './types.js';
+
+export class Database {
+  static readonly VERSION = '2.0.0';
+
+  public authDB: RootDB<DBAuth, 'auth'>;
+  public camerasDB: DB<DBCamera[], 'cameras'>;
+  public pluginsDB: DB<DBPlugin[], 'plugins'>;
+  public settingsDB: DB<DBSettings, 'settings'>;
+  public usersDB: DB<DBUser[], 'users'>;
+  public systemDB: DB<DBSystem, 'system'>;
+
+  private lowdb: RootDB;
+  private databaseMigration: DatabaseMigrationTable;
+  private selfCheck: SelfCheck;
+
+  private configService: ConfigService;
+  private logger: LoggerService;
+  private api: CameraUiAPI;
+
+  constructor() {
+    container.registerInstance('dbs', this);
+
+    this.configService = container.resolve<ConfigService>('configService');
+    this.logger = container.resolve<LoggerService>('logger');
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.authDB = open({
+      path: this.configService.TOKENS_PATH,
+      name: TOKENS_ID,
+    });
+
+    this.lowdb = open({
+      path: this.configService.DATABASE_PATH,
+      name: DATABASE_ID,
+    });
+
+    this.camerasDB = this.lowdb.openDB({
+      name: CAMERAS_ID,
+    });
+
+    this.pluginsDB = this.lowdb.openDB({
+      name: PLUGINS_ID,
+    });
+
+    this.settingsDB = this.lowdb.openDB({
+      name: SETTINGS_ID,
+    });
+
+    this.usersDB = this.lowdb.openDB({
+      name: USERS_ID,
+    });
+
+    this.systemDB = this.lowdb.openDB({
+      name: SYSTEM_ID,
+    });
+
+    this.selfCheck = new SelfCheck();
+    this.databaseMigration = new DatabaseMigrationTable(this.authDB, this.camerasDB, this.pluginsDB, this.settingsDB, this.usersDB, this.systemDB);
+
+    this.logger.debug('Databases opened!');
+
+    this.api.setMaxListeners(this.api.getMaxListeners() + 1);
+    this.api.once(API_EVENT.SHUTDOWN, this.close.bind(this));
+  }
+
+  public async initialize(): Promise<void> {
+    this.logger.debug('Initializing database...');
+
+    await this.checkOldVersion();
+    await this.selfCheck.run();
+    await this.ensureDatabases();
+    await this.prepareDatabases();
+    await this.ensureMaster();
+    await this.databaseMigration.migrate();
+    this.updateConfig();
+
+    this.logger.debug('Database initialized!');
+  }
+
+  public async close(): Promise<void> {
+    await Promise.allSettled([this.authDB.close(), this.lowdb.close()]);
+    this.logger.debug('Databases closed!');
+  }
+
+  public async updateCameras(): Promise<void> {
+    const cameras = this.camerasDB.get('cameras') ?? [];
+
+    for (const camera of cameras) {
+      const go2rtcSources = Object.keys(this.configService.go2rtcConfig.streams ?? {});
+
+      for (const source of camera.sources) {
+        const sourceName = createSourceName(camera.name, source.name);
+        if (go2rtcSources.includes(sourceName)) {
+          let go2rtcUrls = this.configService.go2rtcConfig.streams?.[sourceName] ?? [];
+          go2rtcUrls = Array.isArray(go2rtcUrls) ? go2rtcUrls : [go2rtcUrls];
+          source.urls = go2rtcUrls.filter((url) => !url.includes('#cameraui'));
+        }
+      }
+    }
+
+    await this.camerasDB.put('cameras', cameras);
+  }
+
+  private async checkOldVersion(): Promise<void> {
+    const settingsDB = this.settingsDB.get('settings');
+    const oldVersion = settingsDB?.version ?? Database.VERSION;
+
+    if (semver.lt(oldVersion, '2.0.0')) {
+      this.logger.attention('Database version is too old! camera.ui will reset the database and restart!');
+
+      this.configService.reset();
+
+      await this.settingsDB.put('settings', {
+        version: Database.VERSION,
+      });
+
+      await sleep(1000);
+
+      process.exit(0);
+    }
+  }
+
+  private async ensureDatabases(): Promise<void> {
+    const authDB = this.authDB.get('auth');
+    if (!authDB) {
+      await this.authDB.put('auth', {
+        tokens: [],
+        clients: [],
+      });
+    }
+
+    const camerasDB = this.camerasDB.get('cameras');
+    if (!camerasDB) {
+      await this.camerasDB.put('cameras', []);
+    }
+
+    const usersDB = this.usersDB.get('users');
+    if (!usersDB) {
+      await this.usersDB.put('users', []);
+    }
+
+    const pluginsDB = this.pluginsDB.get('plugins');
+    if (!pluginsDB) {
+      await this.pluginsDB.put('plugins', []);
+    }
+
+    const settingsDB = this.settingsDB.get('settings');
+    if (!settingsDB) {
+      await this.settingsDB.put('settings', {
+        version: Database.VERSION,
+      });
+    }
+
+    const systemDB = this.systemDB.get('system');
+    if (!systemDB) {
+      await this.systemDB.put('system', {
+        serverAddresses: [],
+        remoteAccess: {
+          mode: 'disabled',
+          cloudflare: {},
+          customDomain: {},
+        },
+      });
+    }
+  }
+
+  private async prepareDatabases(): Promise<void> {
+    const systemDB = this.systemDB.get('system');
+    const serverAddresses = systemDB?.serverAddresses ?? [];
+    await this.configService.updateGo2RtcWebRtcFilter(serverAddresses, undefined);
+  }
+
+  private async ensureMaster(): Promise<void> {
+    const users = this.usersDB.get('users') ?? [];
+    let master = users.find((user) => user.role === 'master');
+
+    if (!master) {
+      this.logger.attention('No master found! Creating new master...');
+      master = this.generateMaster();
+      users.push(master);
+      await this.usersDB.put('users', users);
+    }
+  }
+
+  private generateMaster(): DBUser {
+    const salt = randomBytes(16).toString('base64');
+    const hash = createHmac('sha512', salt).update('admin').digest('base64');
+
+    return {
+      _id: randomUUID(),
+      avatar: 'logo-256.png',
+      username: 'admin',
+      password: salt + '$' + hash,
+      sessionTimer: 14400,
+      role: 'master',
+      rememberMe: false,
+      firstLogin: true,
+      singleSession: false,
+      preferences: {
+        camview: {
+          views: [],
+        },
+        cameras: {},
+      },
+    };
+  }
+
+  private updateConfig(): void {
+    const cameras = this.camerasDB.get('cameras') ?? [];
+
+    this.configService.go2rtcConfig.streams ??= {};
+
+    for (const camera of cameras) {
+      const go2rtcSources = Object.keys(this.configService.go2rtcConfig.streams || {});
+
+      for (const source of camera.sources) {
+        source.urls = source.urls.map((url) => {
+          if (url.startsWith('cui://')) {
+            url = `cui://127.0.0.1:${this.configService.config.port}/api/cameras/streams/${camera._id}/${source.name}`;
+          }
+          return url;
+        });
+
+        const sourceName = createSourceName(camera.name, source.name);
+        const ffmpegUrl = `ffmpeg:${sourceName}#cameraui#audio=pcma#audio=opus#audio=aac`;
+        const baseUrls = [...source.urls, ffmpegUrl];
+
+        if (!go2rtcSources.includes(sourceName)) {
+          this.configService.go2rtcConfig.streams[sourceName] = baseUrls;
+        } else {
+          let go2rtcUrls = this.configService.go2rtcConfig.streams[sourceName] ?? [];
+          go2rtcUrls = Array.isArray(go2rtcUrls) ? go2rtcUrls : [go2rtcUrls];
+
+          const hasFFmpegUrl = go2rtcUrls.some((url) => url.startsWith('ffmpeg:') && url.includes('#cameraui'));
+          if (!hasFFmpegUrl && source.role !== 'snapshot') {
+            go2rtcUrls.push(ffmpegUrl);
+          }
+
+          this.configService.go2rtcConfig.streams[sourceName] = go2rtcUrls;
+        }
+      }
+    }
+
+    // update manually go2rtc config file, because go2rtc is not running yet
+    this.configService.writeGo2RtcConfigFile();
+  }
+}

package/src/api/database/migration.ts

@@ -0,0 +1,62 @@
+import semver from 'semver';
+import { container } from 'tsyringe';
+
+import { Database } from './index.js';
+
+import type { Database as DB, RootDatabase as RootDB } from 'lmdb';
+import type { ConfigService } from '../../services/config/index.js';
+import type { LoggerService } from '../../services/logger/index.js';
+import type { DBAuth, DBCamera, DBPlugin, DBSettings, DBSystem, DBUser } from './types.js';
+
+export class DatabaseMigrationTable {
+  private logger: LoggerService;
+  private configService: ConfigService;
+
+  constructor(
+    private authDB: RootDB<DBAuth, 'auth'>,
+    private camerasDB: DB<DBCamera[], 'cameras'>,
+    private pluginsDB: DB<DBPlugin[], 'plugins'>,
+    private settingsDB: DB<DBSettings, 'settings'>,
+    private usersDB: DB<DBUser[], 'users'>,
+    private systemDB: DB<DBSystem, 'system'>,
+  ) {
+    this.logger = container.resolve<LoggerService>('logger');
+    this.configService = container.resolve<ConfigService>('configService');
+  }
+
+  public async migrate(): Promise<void> {
+    const settingsDb = this.settingsDB.get('settings')!;
+
+    const oldVersion = settingsDb.version;
+    const newVersion = Database.VERSION;
+
+    if (semver.eq(oldVersion, newVersion)) {
+      this.logger.log('Database is up to date. Version:', newVersion);
+      return;
+    }
+
+    if (semver.gt(oldVersion, newVersion)) {
+      this.logger.log(`Database version ${oldVersion} is greater than the current version ${newVersion}, skipping migration.`);
+      return;
+    }
+
+    this.logger.attention(`Database migration from ${oldVersion} to ${newVersion}`);
+
+    const migrations = this.getMigrations();
+    for (const migration of migrations) {
+      if (semver.gt(migration.version, oldVersion) && semver.lte(migration.version, newVersion)) {
+        this.logger.trace(`Applying migration to version ${migration.version}`);
+        await migration.up();
+      }
+    }
+
+    settingsDb.version = newVersion;
+    await this.settingsDB.put('settings', settingsDb);
+
+    this.logger.log('Database migration completed');
+  }
+
+  private getMigrations(): { version: string; up: () => Promise<void> }[] {
+    return [];
+  }
+}