@scrypted/server 0.123.31 → 0.123.33

package/src/plugin/runtime/node-fork-worker.ts

@@ -28,8 +28,8 @@ export function isNodePluginChildProcess() {
 
 export class NodeForkWorker extends ChildProcessWorker {
 
-    constructor(mainFilename: string, pluginId: string, options: RuntimeWorkerOptions) {
-        super(pluginId, options);
+    constructor(mainFilename: string, options: RuntimeWorkerOptions) {
+        super(options);
 
         const { env, pluginDebug } = options;
 

package/src/plugin/runtime/python-worker.ts

@@ -41,8 +41,8 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
         return this._stderr;
     }
 
-    constructor(pluginId: string, options: RuntimeWorkerOptions) {
-        super(pluginId, options);
+    constructor(options: RuntimeWorkerOptions) {
+        super(options);
 
         const { env, pluginDebug } = options;
         const args: string[] = [
@@ -148,7 +148,7 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
         };
 
         const pyVersion = require('py/package.json').version;
-        const pyPath = path.join(getPluginVolume(pluginId), 'py');
+        const pyPath = path.join(getPluginVolume(this.pluginId), 'py');
         const portableInstallPath = path.join(pyPath, pyVersion);
 
         const py = new PortablePython(pluginPythonVersion, portableInstallPath, portablePythonOptions);

package/src/plugin/runtime/runtime-host.ts

@@ -4,14 +4,14 @@ import { NodeForkWorker } from "./node-fork-worker";
 import { PythonRuntimeWorker } from "./python-worker";
 import type { RuntimeWorker, RuntimeWorkerOptions } from "./runtime-worker";
 
-export type RuntimeHost = (mainFilename: string, pluginId: string, options: RuntimeWorkerOptions, runtime: ScryptedRuntime) => RuntimeWorker;
+export type RuntimeHost = (mainFilename: string, options: RuntimeWorkerOptions, runtime: ScryptedRuntime) => RuntimeWorker;
 
 export function getBuiltinRuntimeHosts() {
     const pluginHosts = new Map<string, RuntimeHost>();
 
-    pluginHosts.set('custom', (_, pluginId, options, runtime) => new CustomRuntimeWorker(pluginId, options, runtime));
-    pluginHosts.set('python', (_, pluginId, options) => new PythonRuntimeWorker(pluginId, options));
-    pluginHosts.set('node', (mainFilename, pluginId, options) => new NodeForkWorker(mainFilename, pluginId, options));
+    pluginHosts.set('custom', (_, options, runtime) => new CustomRuntimeWorker(options, runtime));
+    pluginHosts.set('python', (_, options) => new PythonRuntimeWorker(options));
+    pluginHosts.set('node', (mainFilename, options) => new NodeForkWorker(mainFilename, options));
 
     return pluginHosts;
 }

package/src/plugin/system.ts

@@ -1,7 +1,6 @@
 import { EventListener, EventListenerOptions, EventListenerRegister, Logger, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptor, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty, ScryptedNativeId, SystemDeviceState, SystemManager } from "@scrypted/types";
 import { EventRegistry } from "../event-registry";
 import { PrimitiveProxyHandler, RpcPeer } from '../rpc';
-// import type { PluginComponent } from "../services/plugin";
 import { getInterfaceMethods, getInterfaceProperties, getPropertyInterfaces, isValidInterfaceMethod, propertyInterfaces } from "./descriptor";
 import { PluginAPI } from "./plugin-api";
 

package/src/runtime.ts

@@ -37,7 +37,7 @@ import { getIpAddress, SCRYPTED_INSECURE_PORT, SCRYPTED_SECURE_PORT } from './se
 import { AddressSettings } from './services/addresses';
 import { Alerts } from './services/alerts';
 import { Backup } from './services/backup';
-import { ClusterFork } from './services/cluster-fork';
+import { ClusterForkService } from './services/cluster-fork';
 import { CORSControl } from './services/cors';
 import { Info } from './services/info';
 import { getNpmPackageInfo, PluginComponent } from './services/plugin';
@@ -45,7 +45,7 @@ import { ServiceControl } from './services/service-control';
 import { UsersService } from './services/users';
 import { getState, ScryptedStateManager, setState } from './state';
 import { isClusterAddress } from './cluster/cluster-setup';
-import { ClusterWorker } from './scrypted-cluster-main';
+import { RunningClusterWorker } from './scrypted-cluster-main';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
@@ -63,7 +63,7 @@ interface HttpPluginData {
 export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     clusterId = crypto.randomBytes(3).toString('hex');
     clusterSecret = process.env.SCRYPTED_CLUSTER_SECRET || crypto.randomBytes(16).toString('hex');
-    clusterWorkers = new Map<string, ClusterWorker>();
+    clusterWorkers = new Map<string, RunningClusterWorker>();
     plugins: { [id: string]: PluginHost } = {};
     pluginDevices: { [id: string]: PluginDevice } = {};
     devices: { [id: string]: DeviceProxyPair } = {};
@@ -89,7 +89,7 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     corsControl = new CORSControl(this);
     addressSettings = new AddressSettings(this);
     usersService = new UsersService(this);
-    clusterFork = new ClusterFork(this);
+    clusterFork = new ClusterForkService(this);
     info = new Info();
     backup = new Backup(this);
     pluginHosts = getBuiltinRuntimeHosts();

package/src/scrypted-cluster-main.ts

@@ -1,4 +1,4 @@
-import type { ForkOptions } from '@scrypted/types';
+import type { ClusterManager, ClusterWorker, ForkOptions } from '@scrypted/types';
 import crypto from 'crypto';
 import { once } from 'events';
 import net from 'net';
@@ -11,13 +11,15 @@ import { computeClusterObjectHash } from './cluster/cluster-hash';
 import { getClusterLabels } from './cluster/cluster-labels';
 import { getScryptedClusterMode, InitializeCluster, setupCluster } from './cluster/cluster-setup';
 import type { ClusterObject } from './cluster/connect-rpc-object';
+import type { PluginAPI } from './plugin/plugin-api';
 import { getPluginVolume, getScryptedVolume } from './plugin/plugin-volume';
 import { prepareZip } from './plugin/runtime/node-worker-common';
 import { getBuiltinRuntimeHosts } from './plugin/runtime/runtime-host';
-import { RuntimeWorker } from './plugin/runtime/runtime-worker';
+import type { RuntimeWorker, RuntimeWorkerOptions } from './plugin/runtime/runtime-worker';
 import { RpcPeer } from './rpc';
 import { createRpcDuplexSerializer } from './rpc-serializer';
 import type { ScryptedRuntime } from './runtime';
+import type { ClusterForkService } from './services/cluster-fork';
 import { sleep } from './sleep';
 
 installSourceMapSupport({
@@ -64,13 +66,13 @@ export interface ClusterForkOptions {
     clusterWorkerId?: ForkOptions['clusterWorkerId'];
 }
 
-type ConnectForkWorker = (auth: ClusterObject, properties: ClusterWorkerProperties) => Promise<{ clusterId: string }>;
+type ConnectForkWorker = (auth: ClusterObject, properties: ClusterWorkerProperties) => Promise<{ clusterId: string, clusterWorkerId: string }>;
 
 export interface ClusterWorkerProperties {
     labels: string[];
 }
 
-export interface ClusterWorker extends ClusterWorkerProperties {
+export interface RunningClusterWorker extends ClusterWorkerProperties {
     id: string;
     peer: RpcPeer;
     forks: Set<ClusterForkOptions>;
@@ -101,9 +103,10 @@ export class ClusterForkResult extends PeerLiveness {
     }
 }
 
-export type ClusterForkParam = (peerLiveness: PeerLiveness, runtime: string, packageJson: any, zipHash: string, getZip: () => Promise<Buffer>) => Promise<ClusterForkResult>;
+export type ClusterForkParam = (runtime: string, options: RuntimeWorkerOptions, peerLiveness: PeerLiveness, getZip: () => Promise<Buffer>) => Promise<ClusterForkResult>;
 
 export function startClusterClient(mainFilename: string) {
+    console.log('Cluster client starting.');
     const originalClusterAddress = process.env.SCRYPTED_CLUSTER_ADDRESS;
     const labels = getClusterLabels();
 
@@ -157,12 +160,11 @@ export function startClusterClient(mainFilename: string) {
             });
 
             try {
-
                 const connectForkWorker: ConnectForkWorker = await peer.getParam('connectForkWorker');
                 const auth: ClusterObject = {
                     address: socket.localAddress,
                     port: socket.localPort,
-                    id: process.env.SCRYPTED_CLUSTER_ID || os.hostname(),
+                    id: process.env.SCRYPTED_CLUSTER_CLIENT_NAME || os.hostname(),
                     proxyId: undefined,
                     sourceKey: undefined,
                     sha256: undefined,
@@ -173,16 +175,12 @@ export function startClusterClient(mainFilename: string) {
                     labels,
                 };
 
-                const { clusterId } = await connectForkWorker(auth, properties);
+                const { clusterId, clusterWorkerId } = await connectForkWorker(auth, properties);
+                process.env.SCRYPTED_CLUSTER_WORKER_ID = clusterWorkerId;
                 const clusterPeerSetup = setupCluster(peer);
                 await clusterPeerSetup.initializeCluster({ clusterId, clusterSecret });
 
-                const clusterForkParam: ClusterForkParam = async (
-                    peerLiveness: PeerLiveness,
-                    runtime: string,
-                    packageJson: any,
-                    zipHash: string,
-                    getZip: () => Promise<Buffer>) => {
+                const clusterForkParam: ClusterForkParam = async (runtime, runtimeWorkerOptions, peerLiveness, getZip) => {
                     let runtimeWorker: RuntimeWorker;
 
                     const builtins = getBuiltinRuntimeHosts();
@@ -190,23 +188,24 @@ export function startClusterClient(mainFilename: string) {
                     if (!rt)
                         throw new Error('unknown runtime ' + runtime);
 
-                    const pluginId: string = packageJson.name;
-                    const { zipFile, unzippedPath } = await prepareZip(getPluginVolume(pluginId), zipHash, getZip);
+                    const pluginId: string = runtimeWorkerOptions.packageJson.name;
+                    const { zipFile, unzippedPath } = await prepareZip(getPluginVolume(pluginId), runtimeWorkerOptions.zipHash, getZip);
 
                     const volume = getScryptedVolume();
                     const pluginVolume = getPluginVolume(pluginId);
 
-                    runtimeWorker = rt(mainFilename, pluginId, {
-                        packageJson,
-                        env: {
-                            SCRYPTED_VOLUME: volume,
-                            SCRYPTED_PLUGIN_VOLUME: pluginVolume,
-                        },
-                        pluginDebug: undefined,
-                        zipFile,
-                        unzippedPath,
-                        zipHash,
-                    }, undefined);
+                    runtimeWorkerOptions.zipFile = zipFile;
+                    runtimeWorkerOptions.unzippedPath = unzippedPath;
+
+                    runtimeWorkerOptions.env = {
+                        ...runtimeWorkerOptions.env,
+                        SCRYPTED_VOLUME: volume,
+                        SCRYPTED_PLUGIN_VOLUME: pluginVolume,
+                    };
+
+                    runtimeWorker = rt(mainFilename, runtimeWorkerOptions, undefined);
+                    runtimeWorker.stdout.on('data', data => console.log(data.toString()));
+                    runtimeWorker.stderr.on('data', data => console.error(data.toString()));
 
                     const threadPeer = new RpcPeer('main', 'thread', (message, reject, serializationContext) => runtimeWorker.send(message, reject, serializationContext));
                     runtimeWorker.setupRpcPeer(threadPeer);
@@ -288,6 +287,7 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
         const peer = preparePeer(socket, 'server');
 
         const connectForkWorker: ConnectForkWorker = async (auth: ClusterObject, properties: ClusterWorkerProperties) => {
+            const id = crypto.randomUUID();
             try {
                 const sha256 = computeClusterObjectHash(auth, runtime.clusterSecret);
                 if (sha256 !== auth.sha256)
@@ -301,8 +301,7 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
                     if (auth.port !== socket.remotePort || !socket.remoteAddress.endsWith(auth.address))
                         throw new Error('cluster object address mismatch');
                 }
-                const id = crypto.randomUUID();
-                const worker: ClusterWorker = {
+                const worker: RunningClusterWorker = {
                     ...properties,
                     // generate a random uuid.
                     id,
@@ -325,6 +324,7 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
 
             return {
                 clusterId: runtime.clusterId,
+                clusterWorkerId: id,
             }
         }
         peer.params['connectForkWorker'] = connectForkWorker;
@@ -332,3 +332,28 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
 
     return server;
 }
+
+export class ClusterManagerImpl implements ClusterManager {
+    private  clusterServicePromise: Promise<ClusterForkService>;
+
+    constructor(private api: PluginAPI) {
+    }
+
+    getClusterWorkerId(): string {
+        return process.env.SCRYPTED_CLUSTER_WORKER_ID;
+    }
+
+    getClusterMode(): 'server' | 'client' | undefined {
+        return getScryptedClusterMode()[0];
+    }
+
+    async getClusterWorkers(): Promise<Record<string, ClusterWorker>> {
+        const clusterFork = await this.getClusterService();
+        return clusterFork.getClusterWorkers();
+    }
+
+    private getClusterService() {
+        this.clusterServicePromise ||= this.api.getComponent('cluster-fork');
+        return this.clusterServicePromise;
+    }
+}

package/src/scrypted-server-main.ts

@@ -100,6 +100,7 @@ app.use(bodyParser.raw({ type: 'application/*', limit: 100000000 }) as any)
 async function start(mainFilename: string, options?: {
     onRuntimeCreated?: (runtime: ScryptedRuntime) => Promise<void>,
 }) {
+    console.log('Cluster server starting.');
     const volumeDir = getScryptedVolume();
     await fs.promises.mkdir(volumeDir, {
         recursive: true

package/src/services/cluster-fork.ts

@@ -1,12 +1,13 @@
-import type { ScryptedRuntime } from "../runtime";
+import { ClusterWorker } from "@scrypted/types";
 import { matchesClusterLabels } from "../cluster/cluster-labels";
-import { ClusterForkOptions, ClusterForkParam, ClusterWorker, PeerLiveness } from "../scrypted-cluster-main";
-import { RpcPeer } from "../rpc";
+import type { ScryptedRuntime } from "../runtime";
+import type { ClusterForkOptions, ClusterForkParam, PeerLiveness, RunningClusterWorker } from "../scrypted-cluster-main";
+import type { RuntimeWorkerOptions } from "../plugin/runtime/runtime-worker";
 
-export class ClusterFork {
+export class ClusterForkService {
     constructor(public runtime: ScryptedRuntime) { }
 
-    async fork(peerLiveness: PeerLiveness, options: ClusterForkOptions, packageJson: any, zipHash: string, getZip: () => Promise<Buffer>) {
+    async fork(runtimeWorkerOptions: RuntimeWorkerOptions, options: ClusterForkOptions, peerLiveness: PeerLiveness, getZip: () => Promise<Buffer>) {
         const matchingWorkers = [...this.runtime.clusterWorkers.entries()].map(([id, worker]) => ({
             worker,
             matches: matchesClusterLabels(options, worker.labels),
@@ -18,7 +19,7 @@ export class ClusterFork {
             });
         matchingWorkers.sort((a, b) => b.worker.labels.length - a.worker.labels.length);
 
-        let worker: ClusterWorker;
+        let worker: RunningClusterWorker;
 
         // try to keep fork id affinity to single worker if present. this presents the opportunity for
         // IPC.
@@ -35,7 +36,8 @@ export class ClusterFork {
         }
 
         const fork: ClusterForkParam = await worker.peer.getParam('fork');
-        const forkResult = await fork(peerLiveness, options.runtime, packageJson, zipHash, getZip);
+        const forkResult = await fork(options.runtime, runtimeWorkerOptions, peerLiveness, getZip);
+        options.id ||= this.runtime.findPluginDevice(runtimeWorkerOptions.packageJson.name)?._id;
         worker.forks.add(options);
         forkResult.waitKilled().catch(() => { }).finally(() => {
             worker.forks.delete(options);
@@ -43,7 +45,7 @@ export class ClusterFork {
 
         forkResult.clusterWorkerId = worker.id;
         return forkResult;
-    }
+    };
 
     async getClusterWorkers() {
         const ret: any = {};