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

package/src/plugins/runtime/node/storage.ts

@@ -0,0 +1,312 @@
+import { isEqual, mergeWith, structuredClone } from '@camera.ui/common/utils';
+import { rpc } from '@camera.ui/rpc-common';
+import objectPath from 'object-path';
+
+import { API_EVENT } from '../../../api.js';
+import { NamespaceManager } from '../../../rpc/namespaces.js';
+import { generateConfigFromSchemas, getValueByKey, isButtonType, isSubmitType, removeCallbacksFromSchemas } from '../../schema.js';
+
+import type { ClientInstance } from '@camera.ui/rpc-client';
+import type { DeviceStorage as DeviceStorageInterface, FormSubmitResponse, JsonSchema, SchemaConfig } from '@camera.ui/types';
+import type { RootDatabase } from 'lmdb';
+import type { PluginInfo } from '../../types.js';
+import type { PluginAPI } from './pluginApi.js';
+
+export class DeviceStorage<T extends Record<string, any> = Record<string, any>> implements DeviceStorageInterface<T> {
+  public schemas: JsonSchema[];
+  public values: T = {} as T;
+
+  #deviceId: string;
+  #instance: any;
+  #api: PluginAPI;
+  #proxy: ClientInstance;
+  #plugin: PluginInfo;
+  #pluginDb: RootDatabase<Record<string, any>, 'config'>;
+
+  #storageNamespace: string;
+  #isPluginStorage: boolean;
+
+  constructor(
+    api: PluginAPI,
+    proxy: ClientInstance,
+    plugin: PluginInfo,
+    pluginDb: RootDatabase<Record<string, any>, 'config'>,
+    instance: any,
+    deviceId: string,
+    schemas: JsonSchema[] = [],
+    isPluginStorage: boolean,
+  ) {
+    this.schemas = schemas;
+
+    this.#api = api;
+    this.#proxy = proxy;
+    this.#plugin = plugin;
+    this.#pluginDb = pluginDb;
+    this.#instance = instance;
+    this.#deviceId = deviceId;
+    this.#isPluginStorage = isPluginStorage;
+
+    const namespaces = {
+      ...NamespaceManager.pluginCameraNamespaces(this.#plugin.id, this.#deviceId),
+      ...NamespaceManager.pluginNamespaces(this.#plugin.id),
+    };
+
+    this.#storageNamespace = !this.#isPluginStorage ? namespaces.cameraStorageRpc : namespaces.pluginStorageRpc;
+    this.#api.once(API_EVENT.SHUTDOWN, this.#close.bind(this));
+  }
+
+  public getValue<T = string>(key: string): Promise<T> | undefined;
+  public getValue<T = string>(key: string, defaultValue: T): Promise<T>;
+  @rpc({ public: true })
+  public getValue<T = string>(key: string, defaultValue?: T): Promise<T> | undefined {
+    const schema = this.schemas.find((schema) => schema.key === key);
+    const configValue = objectPath.get(this.values, key);
+    return (schema as any)?.onGet?.call(this.#instance) ?? configValue ?? (schema as any)?.defaultValue ?? defaultValue;
+  }
+
+  @rpc({ public: true })
+  public async setValue<T = string>(key: string, newValue: T): Promise<void> {
+    const schema = this.schemas.find((schema) => schema.key === key);
+
+    if (schema) {
+      const oldValue = objectPath.get(this.values, key);
+      objectPath.set(this.values, key, newValue);
+      await (schema as any).onSet?.call(this.#instance, newValue, oldValue);
+
+      if (this.#containsStorableSchema(schema)) {
+        await this.save();
+      }
+    }
+  }
+
+  @rpc({ public: true })
+  public async submitValue(key: string, newValue: any): Promise<FormSubmitResponse | void> {
+    const schema = this.schemas.find((schema) => schema.key === key);
+
+    if (schema?.type === 'submit') {
+      // objectPath.set(this.values, bracketsToDot(configPath), newValue);
+      return schema.onClick.call(this.#instance, newValue);
+
+      // if (this.#containsStorableSchema(schema)) {
+      //   await this.save();
+      // }
+    }
+  }
+
+  @rpc({ public: true })
+  public hasValue(key: string): boolean {
+    const configValue = objectPath.get(this.values, key);
+    return configValue !== undefined;
+  }
+
+  @rpc({ public: true })
+  public async getConfig(): Promise<SchemaConfig> {
+    await this.#resolveOnGetFunctions(this.schemas);
+    const filteredSchema = removeCallbacksFromSchemas(this.schemas);
+    const schemaConfig: SchemaConfig = { schema: filteredSchema, config: this.values };
+    return schemaConfig;
+  }
+
+  @rpc({ public: true })
+  public async setConfig(newConfig: T): Promise<void> {
+    const oldConfig = structuredClone(this.values);
+
+    this.values = mergeWith(this.values, newConfig, (source: any, target: any) => {
+      if (Array.isArray(source)) {
+        return target;
+      }
+    });
+
+    await this.#triggerOnSetForChanges(oldConfig, this.values);
+    await this.save();
+  }
+
+  @rpc({ public: true })
+  public async addSchema(schema: JsonSchema): Promise<void> {
+    let shouldSave = false;
+
+    const schemaExist = this.hasSchema(schema.key);
+    if (schemaExist) {
+      // this.schemas = this.schemas.map((s) => (s.key === schema.key ? schema : s));
+      throw new Error(`Schema with key ${schema.key} already exists`);
+    } else {
+      this.schemas.push(schema);
+    }
+
+    await this.#resolveOnGetFunctions(schema);
+
+    if (this.#containsStorableSchema(schema)) {
+      shouldSave = true;
+    }
+
+    if (shouldSave) {
+      await this.save();
+    }
+  }
+
+  @rpc({ public: true })
+  public async removeSchema(key: string): Promise<void> {
+    const schema = this.schemas.find((schema) => schema.key === key);
+    this.schemas = this.schemas.filter((schema) => schema.key !== key);
+    objectPath.del(this.values, key);
+
+    if (schema && this.#containsStorableSchema(schema)) {
+      await this.save();
+    }
+  }
+
+  @rpc({ public: true })
+  public async changeSchema(key: string, newSchema: Partial<JsonSchema>): Promise<void> {
+    newSchema.key = key;
+    const schema = this.schemas.find((schema) => schema.key === newSchema.key);
+
+    if (schema) {
+      mergeWith(schema, newSchema, (source: any, target: any) => {
+        if (Array.isArray(source)) {
+          return target;
+        }
+      });
+
+      await this.#resolveOnGetFunctions(schema);
+
+      if (this.#containsStorableSchema(schema)) {
+        await this.save();
+      }
+    }
+  }
+
+  @rpc({ public: true })
+  public getSchema<T>(key: string): T | undefined {
+    return this.schemas.find((schema) => schema.key === key) as T | undefined;
+  }
+
+  /**
+   * Check if a schema exists by its config path/key.
+   *
+   * @param path - The path to the schema to check.
+   * @returns True if the schema exists, false otherwise.
+   */
+  @rpc({ public: true })
+  public hasSchema(key: string): boolean {
+    const schema = this.schemas.find((schema) => schema.key === key);
+    return !!schema;
+  }
+
+  @rpc({ public: true })
+  public async destroy(): Promise<void> {
+    this.#api.removeListener(API_EVENT.SHUTDOWN, this.#close.bind(this));
+    const config = this.#pluginDb.get('config') ?? {};
+    delete config[this.#deviceId];
+    this.values = {} as T;
+    await this.#pluginDb.put('config', config);
+  }
+
+  public async save(): Promise<void> {
+    const config = this.#pluginDb.get('config') ?? {};
+    const storableConfig = this.schemas.length ? this.#filterStorableValues(this.schemas) : this.values;
+    config[this.#deviceId] = storableConfig;
+    await this.#pluginDb.put('config', config);
+  }
+
+  // Internal method
+  public updateSchema(instance: any, schemas: JsonSchema[] = []): void {
+    this.#instance = instance;
+    this.schemas = schemas;
+    this.#initializeStorage();
+  }
+
+  // Internal method
+  public async registerStorage(): Promise<void> {
+    await this.#proxy.registerRPCHandler(this.#storageNamespace, this);
+  }
+
+  // Internal method
+  public async unregisterStorage(): Promise<void> {
+    await this.#proxy.unregisterRPCHandler(this.#storageNamespace);
+  }
+
+  async #resolveOnGetFunctions(schemas: JsonSchema | JsonSchema[]): Promise<void> {
+    if (!Array.isArray(schemas)) {
+      schemas = [schemas];
+    }
+
+    for (const schema of schemas) {
+      if (!isButtonType(schema) && !isSubmitType(schema) && typeof schema.onGet === 'function') {
+        const schemaValue = await this.getValue(schema.key);
+        if (schemaValue !== undefined && schemaValue !== null) {
+          objectPath.set(this.values, schema.key, schemaValue);
+        }
+      }
+    }
+  }
+
+  async #triggerOnSetForChanges(oldConfig: Record<string, any>, newConfig: Record<string, any>): Promise<void> {
+    const promises: Promise<void>[] = [];
+
+    for (const configKey in newConfig) {
+      const oldValue = getValueByKey(oldConfig, configKey);
+      const newValue = newConfig[configKey];
+
+      if (!isEqual(oldValue, newValue, true)) {
+        const schema = this.schemas.find((schema) => schema.key === configKey);
+        if (schema && !isSubmitType(schema) && typeof schema.onSet === 'function') {
+          promises.push(schema.onSet.call(this.#instance, newValue, oldValue));
+        }
+      }
+    }
+
+    await Promise.all(promises);
+  }
+
+  #filterStorableValues(schemas: JsonSchema[], result: Record<string, any> = {}): Record<string, any> {
+    for (const schema of schemas) {
+      if (isButtonType(schema) || isSubmitType(schema)) {
+        continue;
+      }
+
+      if (schema.store) {
+        const configValue = getValueByKey(this.values, schema.key);
+        objectPath.set(result, schema.key, configValue);
+      }
+    }
+
+    return result;
+  }
+
+  #containsStorableSchema(schema: JsonSchema): boolean {
+    if (schema.type === 'button' || schema.type === 'submit') {
+      return false;
+    }
+
+    if ('store' in schema && schema.store) {
+      return true;
+    }
+
+    return false;
+  }
+
+  async #initializeStorage(): Promise<void> {
+    const config = this.#pluginDb.get('config') ?? {};
+    const deviceConfig = config[this.#deviceId] ?? {};
+    const schemaConfig = generateConfigFromSchemas(this.schemas);
+
+    this.values = mergeWith(schemaConfig, deviceConfig, (source: any, target: any) => {
+      if (Array.isArray(source)) {
+        return target;
+      }
+
+      if (target === undefined) {
+        return source;
+      }
+    });
+  }
+
+  async #close(): Promise<void> {
+    try {
+      await this.save();
+      await this.unregisterStorage();
+    } catch {
+      //
+    }
+  }
+}

package/src/plugins/runtime/node/storageController.ts

@@ -0,0 +1,91 @@
+import { DeviceStorage } from './storage.js';
+
+import type { ClientInstance } from '@camera.ui/rpc-client';
+import type { JsonSchema, StorageController as StorageControllerInterface } from '@camera.ui/types';
+import type { RootDatabase } from 'lmdb';
+import type { PluginInfo } from '../../types.js';
+import type { PluginAPI } from './pluginApi.js';
+
+export class StorageController implements StorageControllerInterface {
+  #api: PluginAPI;
+  #proxy: ClientInstance;
+  #plugin: PluginInfo;
+  #pluginDb: RootDatabase<Record<string, any>, 'config'>;
+  #storages = new Map<string, DeviceStorage<any>>();
+
+  constructor(api: PluginAPI, proxy: ClientInstance, plugin: PluginInfo, pluginDb: RootDatabase<Record<string, any>, 'config'>) {
+    this.#api = api;
+    this.#proxy = proxy;
+    this.#plugin = plugin;
+    this.#pluginDb = pluginDb;
+  }
+
+  public createCameraStorage<T extends Record<string, any> = Record<string, any>>(instance: any, cameraId: string, schemas: JsonSchema[] = []): DeviceStorage<T> {
+    let cameraStorage = this.#storages.get(cameraId);
+
+    if (!cameraStorage) {
+      cameraStorage = new DeviceStorage<T>(this.#api, this.#proxy, this.#plugin, this.#pluginDb, instance, cameraId, schemas, false);
+      this.#storages.set(cameraId, cameraStorage);
+    } else {
+      cameraStorage.updateSchema(instance, schemas);
+    }
+
+    return cameraStorage as DeviceStorage<T>;
+  }
+
+  public createPluginStorage<T extends Record<string, any> = Record<string, any>>(instance: any, schemas: JsonSchema[] = []): DeviceStorage<T> {
+    let pluginStorage = this.#storages.get('storage');
+
+    if (!pluginStorage) {
+      pluginStorage = new DeviceStorage<T>(this.#api, this.#proxy, this.#plugin, this.#pluginDb, instance, 'storage', schemas, true);
+      this.#storages.set('storage', pluginStorage);
+    } else {
+      pluginStorage.updateSchema(instance, schemas);
+    }
+
+    return pluginStorage as DeviceStorage<T>;
+  }
+
+  public getCameraStorage<T extends Record<string, any> = Record<string, any>>(deviceId: string): DeviceStorage<T> | undefined {
+    return this.#storages.get(deviceId) as DeviceStorage<T> | undefined;
+  }
+
+  public getPluginStorage<T extends Record<string, any> = Record<string, any>>(): DeviceStorage<T> | undefined {
+    return this.#storages.get('storage') as DeviceStorage<T> | undefined;
+  }
+
+  // Internal method
+  public async createStorage(type: 'camera', deviceId: string): Promise<DeviceStorage<any>>;
+  public async createStorage(type: 'plugin'): Promise<DeviceStorage<any>>;
+  public async createStorage(type: 'camera' | 'plugin', deviceId?: string): Promise<DeviceStorage<any>> {
+    let storage: DeviceStorage<any> | undefined;
+
+    if (type === 'camera') {
+      if (!deviceId) {
+        throw new Error('ID is required for storage creation');
+      }
+
+      storage = this.createCameraStorage(undefined, deviceId);
+    } else {
+      storage = this.createPluginStorage(deviceId);
+    }
+
+    await storage.registerStorage();
+    return storage;
+  }
+
+  // Internal method
+  public async removeStorage(type: 'camera', deviceId: string): Promise<void>;
+  public async removeStorage(type: 'plugin'): Promise<void>;
+  public async removeStorage(type: 'camera' | 'plugin', deviceId?: string): Promise<void> {
+    const id = type === 'camera' ? deviceId : 'storage';
+    if (!id) {
+      throw new Error('ID is required for storage removal');
+    }
+
+    const deviceStorage = this.#storages.get(id);
+    await deviceStorage?.destroy();
+    await deviceStorage?.unregisterStorage();
+    this.#storages.delete(id);
+  }
+}

package/src/plugins/runtime/python/child.py

@@ -0,0 +1,248 @@
+import asyncio
+import json
+import os
+import sys
+from contextlib import suppress
+from pathlib import Path
+from typing import Any, Literal, Optional, Union, cast
+
+import setproctitle
+from lmdbm import Lmdb
+
+from _camera_ui_tools.camera_ui_common import (
+    LoggerOptions,
+    LoggerService,
+    SignalHandler,
+    TaskSet,
+)
+from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
+from _camera_ui_tools.camera_ui_rpc_client.utils.subscriptions import SubscriptionWrapper
+from _camera_ui_tools.camera_ui_types import Camera
+from _camera_ui_tools.camera_ui_types import CameraDevice as CameraDeviceInterface
+from plugins.runtime.python.namespaces import NamespaceManager
+from plugins.runtime.python.plugin import Plugin
+from plugins.runtime.python.plugin_api import PluginAPI
+from plugins.runtime.python.proxy.camera_device import CameraDeviceProxy
+from plugins.runtime.python.proxy.core_manager import CoreManagerProxy
+from plugins.runtime.python.proxy.device_manager import DeviceManagerProxy
+from plugins.runtime.python.typings import (
+    API_EVENT,
+    PLUGIN_COMMAND,
+    PLUGIN_STATUS,
+    PluginInfo,
+    ProcessLoadMessage,
+    ProcessMessage,
+    ProcessResponse,
+)
+
+process_name = sys.argv[2] if len(sys.argv) > 2 else sys.argv[1] if len(sys.argv) > 1 else "Plugin"
+setproctitle.setproctitle(f"camera.ui - {process_name}")
+
+
+class JsonLmdb(Lmdb[Literal["config"], dict[str, Any]]):
+    def _pre_key(self, key: Literal["config"]) -> bytes:
+        return key.encode("utf-8")
+
+    def _post_key(self, key: bytes) -> Literal["config"]:
+        _key: Any = key.decode("utf-8")
+        return _key
+
+    def _pre_value(self, value: dict[str, Any]) -> bytes:
+        return json.dumps(value).encode("utf-8")
+
+    def _post_value(self, value: bytes) -> dict[str, Any]:
+        return json.loads(value.decode("utf-8"))
+
+
+class PluginChild(ClientInstance):
+    def __init__(self) -> None:
+        super().__init__(
+            "plugin",
+            {
+                "endpoints": [endpoint for endpoint in os.environ["PROXY_ENDPOINTS"].split(",")],
+                "auth": {
+                    "user": os.environ["PROXY_USER"],
+                    "password": os.environ["PROXY_PASSWORD"],
+                },
+                "tls": {
+                    "cert": os.environ["PROXY_CERT"],
+                    "key": os.environ["PROXY_KEY"],
+                    "ca": os.environ["PROXY_CA"],
+                },
+                "metadata": {
+                    "id": NamespaceManager.plugin_namespaces(os.environ["PLUGIN_ID"])["pluginChild"],
+                    "name": os.environ["PLUGIN_NAME"],
+                },
+                "connect": {
+                    "wait_for_server": True,
+                },
+                "reconnect": {
+                    "enabled": True,
+                },
+                "bundled_connection": False,
+            },
+        )
+
+        for key in ["PROXY_USER", "PROXY_PASSWORD", "PROXY_ENDPOINTS", "PROXY_CERT", "PROXY_KEY", "PROXY_CA"]:
+            if key in os.environ:
+                del os.environ[key]
+
+        self.display_name = process_name
+
+        logger_options: LoggerOptions = {
+            "prefix": self.display_name,
+            "disable_timestamps": os.environ.get("LOGGER_DISABLE_TIMESTAMPS") == "1",
+            "debug_enabled": os.environ.get("LOGGER_LEVEL") in ["debug", "trace"],
+            "trace_enabled": os.environ.get("LOGGER_LEVEL") == "trace",
+        }
+
+        self.logger = LoggerService(logger_options)
+
+        self.api: Optional[PluginAPI] = None
+        self.plugin: Optional[Plugin] = None
+        self.plugin_db: Optional[Lmdb[Literal["config"], dict[str, Any]]] = None
+
+        self.subscription: Optional[SubscriptionWrapper] = None
+        self.tasks: TaskSet = TaskSet(f"{self.display_name} PluginChild")
+
+        self.stopped = False
+
+        self.signal_handler = SignalHandler(
+            {
+                "display_name": "[Signal]",
+                "timeout_duration": 3,
+                "logger": self.logger,
+                "close_function": self.stop_plugin,
+            }
+        )
+
+    async def run(self) -> None:
+        try:
+            self.signal_handler.setup_handlers()
+            await self.start()
+            await self.signal_handler.shutdown_event.wait()
+        except asyncio.CancelledError:
+            pass
+        finally:
+            await self.stop_plugin()
+
+    async def on_start(self) -> None:
+        self.subscription = await self.on_server_message(self.on_message)
+        await self.send_message({"type": PLUGIN_STATUS.READY.value})
+
+    async def on_before_stop(self) -> None:
+        await self.stop_plugin()
+
+    async def on_stop(self) -> None:
+        pass
+
+    async def start_plugin(self, data: ProcessLoadMessage) -> None:
+        try:
+            storage_path = data["storage"]["storagePath"]
+            plugin_info = data["plugin"]
+            cameras = data["cameras"]
+
+            self.plugin_db = await self.configure_plugin_db(storage_path)
+
+            self.api = PluginAPI(
+                self,
+                plugin_info,
+                storage_path,
+                self.logger,
+                self.plugin_db,
+            )
+
+            self.plugin = Plugin(self, self.api, plugin_info, self.logger)
+
+            core_manager = cast(CoreManagerProxy, self.api.core_manager)
+            device_manager = cast(DeviceManagerProxy, self.api.device_manager)
+
+            await device_manager.init()
+            await core_manager.init()
+            await self.plugin.load()
+            await self.configure_cameras(self.api, plugin_info, cameras)
+
+            await self.send_message({"type": PLUGIN_STATUS.STARTED.value})
+
+            await asyncio.sleep(0.1)
+
+            self.api.emit("finishLaunching")
+        except Exception as e:
+            await self.send_message({"type": PLUGIN_STATUS.ERROR.value, "error": str(e)})
+
+    async def stop_plugin(self) -> None:
+        if self.stopped:
+            return
+
+        self.stopped = True
+
+        if self.api:
+            self.api.emit(API_EVENT.SHUTDOWN.value)
+            await asyncio.sleep(0.5)
+            self.api.cancel()
+
+        if self.plugin_db:
+            with suppress(Exception):
+                self.plugin_db.close()
+
+        if self.subscription:
+            await self.subscription.unsubscribe()
+            self.subscription = None
+
+        await self.stop()
+
+    async def send_message(self, message: ProcessResponse) -> None:
+        await self.send_to_server(message)
+
+    async def on_message(self, message: ProcessMessage) -> None:
+        if self.stopped:
+            return
+
+        if "type" in message:
+            if message["type"] == PLUGIN_COMMAND.START.value:
+                if not message["data"]:
+                    await self.send_message({"type": PLUGIN_STATUS.ERROR.value, "error": "No data provided"})
+                    return
+
+                await self.start_plugin(message["data"])
+            elif message["type"] == PLUGIN_COMMAND.STOP.value:
+                await self.stop_plugin()
+
+    async def configure_plugin_db(self, storage_path: str) -> Lmdb[Literal["config"], dict[str, Any]]:
+        db_path = Path(storage_path) / "volume"
+        Path(db_path).mkdir(parents=True, exist_ok=True)
+
+        plugin_db: Lmdb[Literal["config"], dict[str, Any]] = JsonLmdb.open(file=str(db_path), flag="c")
+        config = cast(Union[dict[str, Any], None], plugin_db.get("config"))
+
+        if config is None:
+            plugin_db.update({"config": {}})
+
+        return plugin_db
+
+    async def configure_cameras(self, api: PluginAPI, plugin_info: PluginInfo, cameras: list[Camera]) -> None:
+        cameras_devices: list[CameraDeviceProxy] = []
+
+        for camera in cameras:
+            camera_logger = self.logger.create_logger({"suffix": camera["name"], "logger_id": camera["_id"]})
+            cameras_devices.append(
+                CameraDeviceProxy(
+                    self,
+                    api,
+                    camera,
+                    plugin_info,
+                    camera_logger,
+                )
+            )
+
+        if self.api:
+            device_manager = cast(DeviceManagerProxy, self.api.device_manager)
+            await device_manager.configure_cameras(cameras_devices)
+
+        if self.plugin:
+            await self.plugin.configureCameras(cast(list[CameraDeviceInterface], cameras_devices))
+
+
+if __name__ == "__main__":
+    plugin_child = PluginChild()
+    asyncio.run(plugin_child.run())