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

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

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

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

@@ -1,248 +0,0 @@
-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())