@scrypted/server 0.123.32 → 0.123.34

package/src/plugin/plugin-remote-worker.ts

@@ -21,7 +21,7 @@ import { createClusterForkWorker } from './runtime/cluster-fork-worker';
 import { NodeThreadWorker } from './runtime/node-thread-worker';
 import { prepareZip } from './runtime/node-worker-common';
 import { getBuiltinRuntimeHosts } from './runtime/runtime-host';
-import { RuntimeWorker } from './runtime/runtime-worker';
+import { RuntimeWorker, RuntimeWorkerOptions } from './runtime/runtime-worker';
 import type { ClusterForkService } from '../services/cluster-fork';
 import type { PluginComponent } from '../services/plugin';
 import { ClusterManagerImpl } from '../scrypted-cluster-main';
@@ -216,10 +216,23 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 let nativeWorker: child_process.ChildProcess | worker_threads.Worker;
                 let clusterWorkerId: Promise<string>;
 
+                const runtimeWorkerOptions: RuntimeWorkerOptions = {
+                    packageJson,
+                    env: undefined,
+                    pluginDebug: undefined,
+                    zipFile,
+                    unzippedPath,
+                    zipHash,
+                };
+
                 // if running in a cluster, fork to a matching cluster worker only if necessary.
                 if (needsClusterForkWorker(options)) {
                     ({ runtimeWorker, forkPeer, clusterWorkerId } = createClusterForkWorker(
-                        api.getComponent('cluster-fork'), zipHash, () => zipAPI.getZip(), options, packageJson, scrypted.connectRPCObject)
+                        runtimeWorkerOptions,
+                        options,
+                        api.getComponent('cluster-fork'),
+                        () => zipAPI.getZip(),
+                        scrypted.connectRPCObject)
                     );
                 }
                 else {
@@ -228,14 +241,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                         const runtime = builtins.get(options.runtime);
                         if (!runtime)
                             throw new Error('unknown runtime ' + options.runtime);
-                        runtimeWorker = runtime(mainFilename, pluginId, {
-                            packageJson,
-                            env: undefined,
-                            pluginDebug: undefined,
-                            zipFile,
-                            unzippedPath,
-                            zipHash,
-                        }, undefined);
+                        runtimeWorker = runtime(mainFilename, runtimeWorkerOptions, undefined);
 
                         if (runtimeWorker instanceof ChildProcessWorker) {
                             nativeWorker = runtimeWorker.childProcess;

package/src/plugin/runtime/child-process-worker.ts

@@ -4,14 +4,16 @@ import { RpcMessage, RpcPeer } from "../../rpc";
 import { RuntimeWorker, RuntimeWorkerOptions } from "./runtime-worker";
 
 export abstract class ChildProcessWorker extends EventEmitter implements RuntimeWorker {
+    public pluginId: string;
     protected worker: child_process.ChildProcess;
 
     get childProcess() {
         return this.worker;
     }
 
-    constructor(public pluginId: string, options: RuntimeWorkerOptions) {
+    constructor(options: RuntimeWorkerOptions) {
         super();
+        this.pluginId = options.packageJson.name;
     }
 
     setupWorker() {

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

@@ -5,15 +5,20 @@ import { RpcPeer } from "../../rpc";
 import { PeerLiveness } from "../../scrypted-cluster-main";
 import type { ClusterForkService } from "../../services/cluster-fork";
 import { writeWorkerGenerator } from "../plugin-console";
-import type { RuntimeWorker } from "./runtime-worker";
+import type { RuntimeWorker, RuntimeWorkerOptions } from "./runtime-worker";
 
 export function createClusterForkWorker(
+    runtimeWorkerOptions: RuntimeWorkerOptions,
+    options: Partial<ClusterFork>,
     forkComponentPromise: Promise<ClusterForkService>,
-    zipHash: string,
     getZip: () => Promise<Buffer>,
-    options: Partial<ClusterFork>,
-    packageJson: any,
     connectRPCObject: (o: any) => Promise<any>) {
+
+    // these are specific to the cluster worker host
+    // and will be set there.
+    delete runtimeWorkerOptions.zipFile;
+    delete runtimeWorkerOptions.unzippedPath;
+
     const waitKilled = new Deferred<void>();
     waitKilled.promise.finally(() => events.emit('exit'));
     const events = new EventEmitter();
@@ -38,21 +43,22 @@ export function createClusterForkWorker(
     });
 
     const peerLiveness = new PeerLiveness(waitKilled.promise);
-    const clusterForkResultPromise = forkComponentPromise.then(forkComponent => forkComponent.fork(peerLiveness, {
+    const clusterForkResultPromise = forkComponentPromise.then(forkComponent => forkComponent.fork(runtimeWorkerOptions, {
         runtime: options.runtime || 'node',
         id: options.id,
         ...options,
-    }, packageJson, zipHash, getZip));
-    clusterForkResultPromise.catch(() => {});
+    }, peerLiveness,
+        getZip));
+    clusterForkResultPromise.catch(() => { });
 
     const clusterWorkerId = clusterForkResultPromise.then(clusterForkResult => clusterForkResult.clusterWorkerId);
-    clusterWorkerId.catch(() => {});
+    clusterWorkerId.catch(() => { });
 
     const forkPeer = (async () => {
         const clusterForkResult = await clusterForkResultPromise;
         waitKilled.promise.finally(() => {
             runtimeWorker.pid = undefined;
-            clusterForkResult.kill().catch(() => {});
+            clusterForkResult.kill().catch(() => { });
         });
         clusterForkResult.waitKilled().catch(() => { })
             .finally(() => {
@@ -79,7 +85,7 @@ export function createClusterForkWorker(
             return peer;
         }
         catch (e) {
-            clusterForkResult.kill();
+            clusterForkResult.kill().catch(() => {});
             throw e;
         }
     })();

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

@@ -11,8 +11,8 @@ export class CustomRuntimeWorker extends ChildProcessWorker {
     serializer: ReturnType<typeof createRpcDuplexSerializer>;
     fork: boolean;
 
-    constructor(pluginId: string, options: RuntimeWorkerOptions, runtime: ScryptedRuntime) {
-        super(pluginId, options);
+    constructor(options: RuntimeWorkerOptions, runtime: ScryptedRuntime) {
+        super(options);
 
         const pluginDevice = runtime.findPluginDevice(this.pluginId);
         const scryptedRuntimeArguments: ScryptedRuntimeArguments = pluginDevice.state.scryptedRuntimeArguments?.value;
@@ -27,7 +27,7 @@ export class CustomRuntimeWorker extends ChildProcessWorker {
             // stdin, stdout, stderr, peer in, peer out
             stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
             env: Object.assign({}, process.env, env, {
-                SCRYYPTED_PLUGIN_ID: pluginId,
+                SCRYYPTED_PLUGIN_ID: this.pluginId,
                 SCRYPTED_DEBUG_PORT: pluginDebug?.inspectPort?.toString(),
                 SCRYPTED_UNZIPPED_PATH: options.unzippedPath,
                 SCRYPTED_ZIP_FILE: options.zipFile,

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/scrypted-cluster-main.ts

@@ -15,7 +15,7 @@ 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 type { 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';
@@ -76,6 +76,7 @@ export interface RunningClusterWorker extends ClusterWorkerProperties {
     id: string;
     peer: RpcPeer;
     forks: Set<ClusterForkOptions>;
+    address: string;
 }
 
 export class PeerLiveness {
@@ -86,7 +87,7 @@ export class PeerLiveness {
     }
 }
 
-export class ClusterForkResult extends PeerLiveness {
+export class ClusterForkResult extends PeerLiveness implements ClusterForkResultInterface {
     [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = ['kill'];
     clusterWorkerId?: string;
 
@@ -103,9 +104,17 @@ export class ClusterForkResult extends PeerLiveness {
     }
 }
 
-export type ClusterForkParam = (peerLiveness: PeerLiveness, runtime: string, packageJson: any, zipHash: string, getZip: () => Promise<Buffer>) => Promise<ClusterForkResult>;
+export interface ClusterForkResultInterface {
+    clusterWorkerId?: string;
+    getResult(): Promise<any>;
+    kill(): Promise<void>;
+    waitKilled(): Promise<void>;
+}
+
+export type ClusterForkParam = (runtime: string, options: RuntimeWorkerOptions, peerLiveness: PeerLiveness, getZip: () => Promise<Buffer>) => Promise<ClusterForkResultInterface>;
 
 export function startClusterClient(mainFilename: string) {
+    console.log('Cluster client starting.');
     const originalClusterAddress = process.env.SCRYPTED_CLUSTER_ADDRESS;
     const labels = getClusterLabels();
 
@@ -131,6 +140,7 @@ export function startClusterClient(mainFilename: string) {
                 await once(rawSocket, 'connect');
             }
             catch (e) {
+                console.warn('Cluster server not available.', host, port, e);
                 continue;
             }
 
@@ -143,6 +153,7 @@ export function startClusterClient(mainFilename: string) {
                 await once(socket, 'secureConnect');
             }
             catch (e) {
+                console.warn('Cluster server tls failed.', host, port, e);
                 continue;
             }
 
@@ -179,12 +190,7 @@ export function startClusterClient(mainFilename: string) {
                 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();
@@ -192,23 +198,22 @@ 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()));
 
@@ -311,6 +316,7 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
                     // generate a random uuid.
                     id,
                     peer,
+                    address: socket.remoteAddress,
                     forks: new Set(),
                 };
                 runtime.clusterWorkers.set(id, worker);

package/src/scrypted-server-main.ts

@@ -1,6 +1,6 @@
 import bodyParser from 'body-parser';
 import cookieParser from 'cookie-parser';
-import crypto from 'crypto';
+import crypto, { scrypt } from 'crypto';
 import { once } from 'events';
 import express, { Request } from 'express';
 import fs from 'fs';
@@ -45,10 +45,11 @@ installSourceMapSupport({
 });
 
 let workerInspectPort: number = undefined;
+let workerInspectAddress: string = undefined;
 
 async function doconnect(): Promise<net.Socket> {
     return new Promise((resolve, reject) => {
-        const target = net.connect(workerInspectPort, '127.0.0.1');
+        const target = net.connect(workerInspectPort, workerInspectAddress);
         target.once('error', reject)
         target.once('connect', () => resolve(target))
     })
@@ -100,6 +101,7 @@ app.use(bodyParser.raw({ type: 'application/*', limit: 100000000 }) as any)
 async function start(mainFilename: string, options?: {
     onRuntimeCreated?: (runtime: ScryptedRuntime) => Promise<void>,
 }) {
+    console.log('Scrypted server starting.');
     const volumeDir = getScryptedVolume();
     await fs.promises.mkdir(volumeDir, {
         recursive: true
@@ -464,11 +466,20 @@ async function start(mainFilename: string, options?: {
         waitDebug.catch(() => { });
 
         workerInspectPort = Math.round(Math.random() * 10000) + 30000;
+        workerInspectAddress = '127.0.0.1';
         try {
-            await scrypted.installPlugin(plugin, {
+            const host = await scrypted.installPlugin(plugin, {
                 waitDebug,
                 inspectPort: workerInspectPort,
             });
+
+            const clusterWorkerId = await host.clusterWorkerId;
+            if (clusterWorkerId) {
+                const clusterWorker = scrypted.clusterWorkers.get(clusterWorkerId);
+                if (clusterWorker) {
+                    workerInspectAddress = clusterWorker.address;
+                }
+            }
         }
         catch (e) {
             res.header('Content-Type', 'text/plain');
@@ -479,6 +490,7 @@ async function start(mainFilename: string, options?: {
 
         res.send({
             workerInspectPort,
+            workerInspectAddress,
         });
     });
 
@@ -726,6 +738,7 @@ async function start(mainFilename: string, options?: {
 
     const clusterMode = getScryptedClusterMode();
     if (clusterMode?.[0] === 'server') {
+        console.log('Cluster server starting.');
         const clusterServer = createClusterServer(scrypted, keyPair);
         await listenServerPort('SCRYPTED_CLUSTER_SERVER', clusterMode[2], clusterServer);
     }

package/src/services/cluster-fork.ts

@@ -1,11 +1,40 @@
 import { matchesClusterLabels } from "../cluster/cluster-labels";
+import type { RuntimeWorkerOptions } from "../plugin/runtime/runtime-worker";
+import { RpcPeer } from "../rpc";
 import type { ScryptedRuntime } from "../runtime";
-import type { ClusterForkOptions, ClusterForkParam, PeerLiveness, RunningClusterWorker } from "../scrypted-cluster-main";
+import type { ClusterForkOptions, ClusterForkParam, ClusterForkResultInterface, PeerLiveness, RunningClusterWorker } from "../scrypted-cluster-main";
+
+class WrappedForkResult implements ClusterForkResultInterface {
+    [RpcPeer.PROPERTY_PROXY_PROPERTIES] = {
+        clusterWorkerId: undefined as string,
+    };
+
+    constructor(public clusterWorkerId: string, public forkResult: Promise<ClusterForkResultInterface>) {
+        this[RpcPeer.PROPERTY_PROXY_PROPERTIES].clusterWorkerId = clusterWorkerId;
+    }
+
+    async kill() {
+        const fr = await this.forkResult.catch(() => {});
+        if (!fr)
+            return;
+        await fr.kill();
+    }
+
+    async getResult() {
+        const fr = await this.forkResult;
+        return fr.getResult();
+    }
+
+    async waitKilled() {
+        const fr = await this.forkResult;
+        await fr.waitKilled();
+    }
+}
 
 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),
@@ -34,16 +63,21 @@ export class ClusterForkService {
         }
 
         const fork: ClusterForkParam = await worker.peer.getParam('fork');
-        const forkResult = await fork(peerLiveness, options.runtime, packageJson, zipHash, getZip);
-        options.id ||= this.runtime.findPluginDevice(packageJson.name)?._id;
+        const forkResultPromise = 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);
+
+        forkResultPromise.then(forkResult => {
+            forkResult.clusterWorkerId = worker.id;
+            forkResult.waitKilled().catch(() => { }).finally(() => {
+                worker.forks.delete(options);
+            })
         });
 
-        forkResult.clusterWorkerId = worker.id;
-        return forkResult;
-    }
+        const ret: ClusterForkResultInterface = new WrappedForkResult(worker.id, forkResultPromise);
+        return ret;
+    };
 
     async getClusterWorkers() {
         const ret: any = {};