@remix_labs/machine-starter 2.1957.0 → 2.1961.0-dev

package/common.js

@@ -1,18 +1,44 @@
 import { GROOVEBOX_BUILD } from "./groovebox_build.js";
 
-let terminate = function(f) {};
-if (globalThis.ThisIsNode) {
-    terminate = function(f) {
-        Process.on("exit", () => {
-            console.log("terminating machine worker");
-            f()
-        })
+let workers = {};
+let parents = {};
+
+function terminateAll() {
+    for (let [vmID, worker] of Object.entries(workers)) {
+        worker.terminate();
+    };
+    workers = {};
+    parents = {};
+}
+
+function terminateVM(vmID) {
+    let worker = workers[vmID];
+    if (worker) {
+        delete workers[vmID];
+        delete parents[vmID];
+        worker.terminate();
+        for (let [subID, parentID] of Object.entries(parents)) {
+            terminateVM(subID);
+        };
     }
+}
+
+if (globalThis.Process) {
+    Process.on("exit", () => {
+        console.log("terminating machine workers");
+        terminateAll()
+    })
 };
 
 let initialMask = 64 + 1024;   // default for web
+
 globalThis.MixSetMask = (m => {
     initialMask = m;
+    for (let [vmID, worker] of Object.entries(workers)) {
+        worker.postMessage({ "_rmx_type": "msg_vm_logMask",
+                             "mask": m
+                           })
+    }
 });
 
 function StartWASM(hub, baseURL, org, workspace, vmID, user, token, noOutputViaMQTT) {
@@ -31,16 +57,24 @@ function StartWASM2(hub, config) {
     return hub.newChannel().then(channel => {
         // injected by either index.js or node.js
         let worker = globalThis.GetMachineWASMWorker();
-        let localFFIs = {};
+        workers[config.vmID] = worker;
+        let localFFIkind = {};
+        let localFFIfuns = {};
         if (config.localFFIs) {
             for (const [k, v] of Object.entries(config.localFFIs)) {
+                localFFIfuns[k] = {...v};
                 if (v.isRaw && (v.canFail || v.useJsonDecoder)) {
                     console.error("A raw, local FFI must neither be failing nor use the JSON decoder: " + k);
                 } else {
-                    localFFIs[k] = {...v};
-                    delete localFFIs[k].run;
+                    localFFIkind[k] = {...v};
+                    delete localFFIkind[k].run;
                 }
-            }
+            };
+            let vm_kind = { isRaw:false, canFail:false, useJsonDecoder:false};
+            localFFIkind["$vm_start"] = vm_kind;
+            localFFIfuns["$vm_start"] = ffi_vm_start;
+            localFFIkind["$vm_stop"] = vm_kind;
+            localFFIfuns["$vm_stop"] = ffi_vm_stop;
         }
         let config_msg =
             { "_rmx_type": "msg_vm_configure",
@@ -54,24 +88,43 @@ function StartWASM2(hub, config) {
               "outputViaMQTT": !(config.noOutputViaMQTT),
               "machType": config.machType,
               "debugMask": initialMask,
-              "localFFIs": localFFIs,
+              "localFFIs": localFFIkind,
               "allowInsecureHttp": globalThis.GROOVEBOX_ALLOW_INSECURE_HTTP,
               "interceptFFI": config.interceptFFI,
               "interceptDynloadFFI": config.interceptDynloadFFI,
             };
         worker.postMessage(config_msg, [ channel.port ]);
-        terminate(() => worker.terminate());
-        globalThis.MixSetMask = (m => {
-            worker.postMessage({ "_rmx_type": "msg_vm_logMask",
-                                 "mask": m
-                               })
-        });
         if (config.localFFIs)
-            setupLocalFFIs(hub, config);  // don't await!
+            setupLocalFFIs(hub, config, localFFIfuns);  // don't await!
         return worker;
     })
 }
 
+async function ffi_vm_start(conn, args) {
+    let vm_id = "embedded." + nanoid();
+    let config = {};
+    for (const [k, v] of Object.entries(conn.config)) {
+        config[k] = v;
+    }
+    config["vmID"] = vm_id;
+    parents[vm_id] = conn.config.vmID;
+    let arg_config = args[0];
+    if (arg_config.interceptFFI !== undefined)
+        config["interceptFFI"] = arg_config.interceptFFI;
+    if (arg_config.interceptDynloadFFI !== undefined)
+        config["interceptDynloadFFI"] = arg_config.interceptDynloadFFI;
+    let worker = await StartWASM2(conn.hub, config);
+    return vm_id;
+}
+
+async function ffi_vm_stop(conn, args) {
+    let vm_id = args[0];
+    let worker = workers[vm_id];
+    if (!worker) throw new Error("no such VM: " + vm_id);
+    terminateVM(vm_id);
+    return null;
+}
+
 class Token {
     constructor(data, enabled, extras) {
         // data: must be an Uint8Array
@@ -187,13 +240,13 @@ function decode(val) {
     }
 }
 
-async function setupLocalFFIs(hub, config) {
+async function setupLocalFFIs(hub, config, localFFIs) {
+    let vmID = config.vmID;
     let channel = await hub.newChannel();
-    let comm = new FFIComm(hub, channel);
-    let localFFIs = config.localFFIs;
-    await channel.setLocalSubTopic("/local/ffi/call");
-    await channel.setLocalPubTopic("/local/ffi/return");
-    let sub = await channel.subscribe("/local/ffi/call");
+    let comm = new FFIComm(vmID, hub, channel);
+    await channel.setLocalSubTopic("/local/" + vmID);
+    await channel.setLocalPubTopic("/local/" + vmID);
+    let sub = await channel.subscribe("/local/" + vmID + "/ffi/call");
     while (true) {
         let msg = await sub.next();
         let name = msg.payload.name;
@@ -207,14 +260,15 @@ async function setupLocalFFIs(hub, config) {
                 { call_id: call_id,
                   hub: hub,
                   channel: channel,
+                  config: config,
                   state: config.state,
                 };
             let r = fun instanceof Function ? fun(connector, args) : fun.run(connector, args);
             if (r instanceof Promise) {
+                r.catch(_ => null);  // prevent "unhandled rejection"
                 await comm.later(call_id);
-                r.then(
-                    (value) => comm.returnOrFail(fun, call_id, value),
-                    (reason) => comm.error(call_id, reason.message, reason.stack));
+                let value = await r;
+                await comm.returnOrFail(fun, call_id, value);
             } else {
                 await comm.returnOrFail(fun, call_id, r);
             }
@@ -225,7 +279,8 @@ async function setupLocalFFIs(hub, config) {
 }
 
 class FFIComm {
-    constructor(hub, channel) {
+    constructor(vmID, hub, channel) {
+        this.vmID = vmID;
         this.hub = hub;
         this.channel = channel;
     }
@@ -234,7 +289,7 @@ class FFIComm {
             { call_id: call_id,
             };
         let response = this.hub.newLocalMessage("msg_ffi_later", "starter", r_payload);
-        return this.channel.publish("/local/ffi/return", response, false);
+        return this.channel.publish("/local/" + this.vmID + "/ffi/return", response, false);
     }
     return_(fun, call_id, result) {
         let r_payload =
@@ -242,7 +297,7 @@ class FFIComm {
               value: fun.useJsonDecoder ? result : encode(result)
             };
         let response = this.hub.newLocalMessage("msg_ffi_return", "starter", r_payload);
-        return this.channel.publish("/local/ffi/return", response, false);
+        return this.channel.publish("/local/" + this.vmID + "/ffi/return", response, false);
     }
     error(call_id, message, stack) {
         let r_payload =
@@ -251,7 +306,7 @@ class FFIComm {
               stack: stack === undefined ? [] : stack,
             };
         let response = this.hub.newLocalMessage("msg_ffi_error", "starter", r_payload);
-        this.channel.publish("/local/ffi/return", response, false);
+        this.channel.publish("/local/" + this.vmID + "/ffi/return", response, false);
     }
     returnOrFail(fun, call_id, result) {
         if (fun.canFail) {
@@ -281,4 +336,6 @@ class FFIComm {
 
 // use worker.terminate() to shut a worker down!
 
-export { StartWASM, StartWASM2, Token, Case, Opaque }
+export { StartWASM, StartWASM2, terminateAll, terminateVM,
+         Token, Case, Opaque
+       }

package/groovebox_build.js

@@ -1,2 +1,2 @@
-var GROOVEBOX_BUILD = "2069";
+var GROOVEBOX_BUILD = "2078";
 export { GROOVEBOX_BUILD }

package/index.js

@@ -17,4 +17,3 @@ function GetMachineWASMWorker() {
 globalThis.GetMachineWASMWorker = GetMachineWASMWorker;
 
 export * from './common.js';
-