smoldot 1.0.5 → 1.0.7

package/dist/cjs/internals/client.js

@@ -68,6 +68,7 @@ function start(options, wasmModule, platformBindings) {
         currentTaskName: null,
         connections: new Map(),
         addChainResults: [],
+        onExecutorShutdownOrWasmPanic: () => { },
         chains: new Map(),
     };
     // Callback called during the execution of the instance.
@@ -97,6 +98,15 @@ function start(options, wasmModule, platformBindings) {
                 }
                 state.chains.clear();
                 state.currentTaskName = null;
+                const cb = state.onExecutorShutdownOrWasmPanic;
+                state.onExecutorShutdownOrWasmPanic = () => { };
+                cb();
+                break;
+            }
+            case "executor-shutdown": {
+                const cb = state.onExecutorShutdownOrWasmPanic;
+                state.onExecutorShutdownOrWasmPanic = () => { };
+                cb();
                 break;
             }
             case "log": {
@@ -342,7 +352,7 @@ function start(options, wasmModule, platformBindings) {
                 throw state.instance.error;
             if (state.instance.status !== "ready")
                 throw new Error(); // Internal error. Never supposed to happen.
-            state.instance.instance.startShutdown();
+            state.instance.instance.shutdownExecutor();
             state.instance = { status: "destroyed", error: new public_types_js_1.AlreadyDestroyedError() };
             state.connections.forEach((connec) => connec.reset());
             state.connections.clear();
@@ -358,6 +368,8 @@ function start(options, wasmModule, platformBindings) {
             }
             state.chains.clear();
             state.currentTaskName = null;
+            // Wait for the `executor-shutdown` event to be generated.
+            yield new Promise((resolve) => state.onExecutorShutdownOrWasmPanic = resolve);
         })
     };
 }

package/dist/cjs/internals/local-instance.d.ts

@@ -51,6 +51,8 @@ export type Event = {
 } | {
     ty: "wasm-panic";
     message: string;
+} | {
+    ty: "executor-shutdown";
 } | {
     ty: "new-connection";
     connectionId: number;
@@ -95,12 +97,14 @@ export interface Instance {
     addChain: (chainSpec: string, databaseContent: string, potentialRelayChains: number[], disableJsonRpc: boolean) => void;
     removeChain: (chainId: number) => void;
     /**
-     * Starts the instance shutdown process in the background. After this function returns, no
-     * more event is generated and all further function calls might throw or have no effect.
+     * Notifies the background executor that it should stop. Once it has effectively stopped,
+     * a `executor-shutdown` event will be generated.
+     * Note that the instance can technically still be used, and all the functions still work, but
+     * in practice nothing is being run in the background and as such it won't do much.
      * Existing connections are *not* closed. It is the responsibility of the API user to close
      * all connections.
      */
-    startShutdown: () => void;
+    shutdownExecutor: () => void;
     connectionOpened: (connectionId: number, info: {
         type: 'single-stream';
         handshake: 'multistream-select-noise-yamux';

package/dist/cjs/internals/local-instance.js

@@ -44,6 +44,7 @@ function startLocalInstance(config, wasmModule, eventCallback) {
             advanceExecutionPromise: null,
             stdoutBuffer: "",
             stderrBuffer: "",
+            onShutdownExecutorOrWasmPanic: () => { }
         };
         const smoldotJsBindings = {
             // Must exit with an error. A human-readable message can be found in the WebAssembly
@@ -55,6 +56,8 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                 len >>>= 0;
                 const message = buffer.utf8BytesToString(new Uint8Array(instance.exports.memory.buffer), ptr, len);
                 eventCallback({ ty: "wasm-panic", message });
+                state.onShutdownExecutorOrWasmPanic();
+                state.onShutdownExecutorOrWasmPanic = () => { };
                 throw new Error();
             },
             buffer_size: (bufferIndex) => {
@@ -287,6 +290,8 @@ function startLocalInstance(config, wasmModule, eventCallback) {
             proc_exit: (retCode) => {
                 state.instance = null;
                 eventCallback({ ty: "wasm-panic", message: `proc_exit called: ${retCode}` });
+                state.onShutdownExecutorOrWasmPanic();
+                state.onShutdownExecutorOrWasmPanic = () => { };
                 throw new Error();
             },
             // Return the number of environment variables and the total size of all environment
@@ -339,6 +344,9 @@ function startLocalInstance(config, wasmModule, eventCallback) {
         // Smoldot requires an initial call to the `init` function in order to do its internal
         // configuration.
         state.instance.exports.init(config.maxLogLevel);
+        // Promise that is notified when the `shutdownExecutor` function is called or when a Wasm
+        // panic happens.
+        const shutdownExecutorOrWasmPanicPromise = new Promise((resolve) => state.onShutdownExecutorOrWasmPanic = () => resolve("stop"));
         (() => __awaiter(this, void 0, void 0, function* () {
             const cpuRateLimit = config.cpuRateLimit;
             // In order to avoid calling `setTimeout` too often, we accumulate sleep up until
@@ -346,13 +354,10 @@ function startLocalInstance(config, wasmModule, eventCallback) {
             let missingSleep = 0;
             let now = config.performanceNow();
             while (true) {
-                const whenReadyAgain = new Promise((resolve) => state.advanceExecutionPromise = resolve);
+                const whenReadyAgain = new Promise((resolve) => state.advanceExecutionPromise = () => resolve("ready"));
                 if (!state.instance)
                     break;
-                const outcome = state.instance.exports.advance_execution();
-                if (outcome === 0) {
-                    break;
-                }
+                state.instance.exports.advance_execution();
                 const afterExec = config.performanceNow();
                 const elapsed = afterExec - now;
                 now = afterExec;
@@ -369,9 +374,12 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                     // really care for such extreme values.
                     if (missingSleep > 2147483646) // Doc says `> 2147483647`, but I don't really trust their pedanticism so let's be safe
                         missingSleep = 2147483646;
-                    yield new Promise((resolve) => setTimeout(resolve, missingSleep));
+                    const sleepFinished = new Promise((resolve) => setTimeout(() => resolve("timeout"), missingSleep));
+                    if ((yield Promise.race([sleepFinished, shutdownExecutorOrWasmPanicPromise])) === "stop")
+                        break;
                 }
-                yield whenReadyAgain;
+                if ((yield Promise.race([whenReadyAgain, shutdownExecutorOrWasmPanicPromise])) === "stop")
+                    break;
                 const afterWait = config.performanceNow();
                 // `afterWait - now` is equal to how long we've waited for the `setTimeout` callback to
                 // trigger. While in principle `afterWait - now` should be roughly equal to
@@ -386,6 +394,9 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                     missingSleep = -10000;
                 now = afterWait;
             }
+            if (!state.instance)
+                return;
+            eventCallback({ ty: "executor-shutdown" });
         }))();
         return {
             request: (request, chainId) => {
@@ -447,12 +458,12 @@ function startLocalInstance(config, wasmModule, eventCallback) {
                     return;
                 state.instance.exports.remove_chain(chainId);
             },
-            startShutdown: () => {
+            shutdownExecutor: () => {
                 if (!state.instance)
                     return;
-                const instance = state.instance;
-                state.instance = null;
-                instance.exports.start_shutdown();
+                const cb = state.onShutdownExecutorOrWasmPanic;
+                state.onShutdownExecutorOrWasmPanic = () => { };
+                cb();
             },
             connectionOpened: (connectionId, info) => {
                 if (!state.instance)

package/dist/cjs/internals/remote-instance.js

@@ -75,9 +75,8 @@ function connectToInstanceServer(config) {
             const message = messageEvent.data;
             // Update some local state.
             switch (message.ty) {
-                case "wasm-panic": {
-                    state.jsonRpcResponses.clear();
-                    state.connections.clear();
+                case "wasm-panic":
+                case "executor-shutdown": {
                     portToServer.close();
                     initialPort.close();
                     break;
@@ -171,7 +170,7 @@ function connectToInstanceServer(config) {
                 portToServer.postMessage(msg);
                 return item;
             },
-            startShutdown() {
+            shutdownExecutor() {
                 const msg = { ty: "shutdown" };
                 portToServer.postMessage(msg);
             },
@@ -231,12 +230,13 @@ function startInstanceServer(config, initPortToClient) {
                     }
                     break;
                 }
+                case "executor-shutdown":
                 case "wasm-panic": {
-                    state.instance = null;
-                    state.connections.clear();
-                    state.acceptedJsonRpcResponses.clear();
-                    if (state.onShutdown)
-                        state.onShutdown();
+                    if (state.onExecutorShutdownOrWasmPanic) {
+                        const cb = state.onExecutorShutdownOrWasmPanic;
+                        delete state.onExecutorShutdownOrWasmPanic;
+                        cb();
+                    }
                     break;
                 }
                 case "json-rpc-responses-non-empty": {
@@ -244,8 +244,6 @@ function startInstanceServer(config, initPortToClient) {
                     // from within the events callback itself.
                     // TODO: do better than setTimeout?
                     setTimeout(() => {
-                        if (!state.instance)
-                            return;
                         const numAccepted = state.acceptedJsonRpcResponses.get(event.chainId);
                         if (numAccepted == 0)
                             return;
@@ -274,6 +272,9 @@ function startInstanceServer(config, initPortToClient) {
             const ev = event;
             portToClient.postMessage(ev);
         };
+        // We create the `Promise` ahead of time in order to potentially catch potential `wasm-panic`
+        // events as early as during initialization.
+        const execFinishedPromise = new Promise((resolve) => state.onExecutorShutdownOrWasmPanic = resolve);
         state.instance = yield instance.startLocalInstance(Object.assign({ forbidTcp,
             forbidWs,
             forbidNonLocalWs,
@@ -283,8 +284,6 @@ function startInstanceServer(config, initPortToClient) {
             maxLogLevel }, config), wasmModule, eventsCallback);
         portToClient.onmessage = (messageEvent) => {
             const message = messageEvent.data;
-            if (!state.instance)
-                return;
             switch (message.ty) {
                 case "add-chain": {
                     state.instance.addChain(message.chainSpec, message.databaseContent, message.potentialRelayChains, message.disableJsonRpc);
@@ -311,10 +310,7 @@ function startInstanceServer(config, initPortToClient) {
                     break;
                 }
                 case "shutdown": {
-                    if (state.onShutdown)
-                        state.onShutdown();
-                    state.instance.startShutdown();
-                    portToClient.close();
+                    state.instance.shutdownExecutor();
                     break;
                 }
                 case "connection-reset": {
@@ -372,10 +368,7 @@ function startInstanceServer(config, initPortToClient) {
                 }
             }
         };
-        // The instance might already have crashed. Handle this situation.
-        if (!state.instance)
-            return Promise.resolve();
-        return new Promise((resolve) => state.onShutdown = resolve);
+        return execFinishedPromise;
     });
 }
 exports.startInstanceServer = startInstanceServer;