qsharp-lang 0.1.0-dev.1

package/dist/worker-proxy.js

@@ -0,0 +1,226 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { log } from "./log.js";
+/*
+The WorkerProxy works by queuing up requests to send over to the Worker, only
+ever having one in flight at a time. By queuing on the caller side, this allows
+for cancellation (it checks if a request is cancelled before sending to the worker).
+
+The queue contains an entry for each request with the data to send, the promise
+to resolve, the event handler, and the cancellation token. When a request completes
+the next one (if present) is fetched from the queue. If it is marked as cancelled,
+it is resolved immediately, else it is marked as the current request and the command
+sent to the worker. As events occurs on the current request the event handler is
+invoked. When the response is received this is used to resolve the promise and
+complete the request.
+*/
+/**
+ * Function to create the proxy for a type. To be used from the main thread.
+ *
+ * @param postMessage A function to post messages to the worker
+ * @param terminator A function to call to tear down the worker thread
+ * @param methods A map of method names to be proxied and some metadata @see MethodMap
+ * @returns The proxy object. The caller should then set the onMsgFromWorker
+ * property to a callback that will receive messages from the worker.
+ */
+export function createProxy(postMessage, terminator, methods) {
+    const queue = [];
+    const eventTarget = new EventTarget();
+    let curr;
+    let state = "idle";
+    function setState(newState) {
+        if (state === newState)
+            return;
+        state = newState;
+        if (proxy.onstatechange)
+            proxy.onstatechange(state);
+    }
+    function queueRequest(msg, requestEventTarget, cancellationToken) {
+        return new Promise((resolve, reject) => {
+            queue.push({
+                type: msg.type,
+                args: msg.args,
+                resolve,
+                reject,
+                requestEventTarget,
+                cancellationToken,
+            });
+            // If nothing was running when this got added, kick off processing
+            if (queue.length === 1)
+                doNextRequest();
+        });
+    }
+    function doNextRequest() {
+        if (curr)
+            return;
+        while ((curr = queue.shift())) {
+            // eslint-disable-line no-cond-assign
+            if (curr.cancellationToken?.isCancellationRequested) {
+                curr.reject("cancelled");
+                continue;
+            }
+            else {
+                break;
+            }
+        }
+        if (!curr) {
+            // Nothing else queued, signal that we're now idle and exit.
+            log.debug("Proxy: Worker queue is empty");
+            setState("idle");
+            return;
+        }
+        const msg = { type: curr.type, args: curr.args };
+        if (methods[curr.type] === "requestWithProgress") {
+            setState("busy");
+        }
+        log.debug("Proxy: Posting message to worker: %o", msg);
+        postMessage(msg);
+    }
+    function onMsgFromWorker(msg) {
+        if (log.getLogLevel() >= 4)
+            log.debug("Proxy: Received message from worker: %s", JSON.stringify(msg));
+        if (msg.messageType === "event") {
+            // For telemetry events, just log and exit. There is nothing else waiting to consume them.
+            if (msg.type === "telemetry-event") {
+                const detail = msg.detail;
+                log.logTelemetry(detail);
+                return;
+            }
+            const event = new Event(msg.type);
+            event.detail = msg.detail;
+            log.debug("Proxy: Posting event: %o", msg);
+            // Post to a currently attached event target if there's a "requestWithProgress"
+            // in progress
+            curr?.requestEventTarget?.dispatchEvent(event);
+            // Also post to the general event target
+            eventTarget.dispatchEvent(event);
+        }
+        else if (msg.messageType === "response") {
+            if (!curr) {
+                log.error("Proxy: No active request when message received: %o", msg);
+                return;
+            }
+            const result = {
+                success: msg.result.success,
+                data: msg.result.success ? msg.result.result : msg.result.error,
+            };
+            if (result.success) {
+                curr.resolve(result.data);
+                curr = undefined;
+                doNextRequest();
+            }
+            else {
+                curr.reject(result.data);
+                curr = undefined;
+                doNextRequest();
+            }
+            return;
+        }
+    }
+    // Create the proxy object to be returned
+    const proxy = {};
+    // Assign each method with the desired proxying behavior
+    for (const methodName of Object.keys(methods)) {
+        // @ts-expect-error - tricky to derive the type of the actual method here
+        proxy[methodName] = (...args) => {
+            let requestEventTarget = undefined;
+            switch (methods[methodName]) {
+                case "addEventListener":
+                    {
+                        // @ts-expect-error - can't get the typing of the rest parameters quite right
+                        eventTarget.addEventListener(...args);
+                    }
+                    break;
+                case "removeEventListener":
+                    {
+                        // @ts-expect-error - can't get the typing of the rest parameters quite right
+                        eventTarget.removeEventListener(...args);
+                    }
+                    break;
+                case "requestWithProgress": {
+                    // For progress methods, the last argument is the event target
+                    requestEventTarget = args[args.length - 1];
+                    args = args.slice(0, args.length - 1);
+                }
+                // fallthrough
+                case "request": {
+                    return queueRequest({ type: methodName, args }, requestEventTarget);
+                }
+            }
+        };
+    }
+    proxy.onstatechange = null;
+    proxy.terminate = () => {
+        // Kill the worker without a chance to shutdown. May be needed if it is not responding.
+        log.info("Proxy: Terminating the worker");
+        if (curr) {
+            log.debug("Proxy: Terminating running worker item of type: %s", curr.type);
+            curr.reject("terminated");
+        }
+        // Reject any outstanding items
+        while (queue.length) {
+            const item = queue.shift();
+            log.debug("Proxy: Terminating outstanding work item of type: %s", item?.type);
+            item?.reject("terminated");
+        }
+        terminator();
+    };
+    proxy.onMsgFromWorker = onMsgFromWorker;
+    return proxy;
+}
+/**
+ * Function to wrap a service in a dispatcher. To be used in the worker thread.
+ *
+ * @param service The service to be wrapped
+ * @param methods A map of method names. Should match the list passed into @see createProxy.
+ * @param eventNames The list of event names that the service can emit
+ * @param postMessage A function to post messages back to the main thread
+ * @returns A function that takes a message and invokes the corresponding
+ * method on the service. The caller should then set this method as a message handler.
+ */
+export function createDispatcher(postMessage, service, methods, eventNames) {
+    log.debug("Worker: Constructing WorkerEventHandler");
+    function logAndPost(msg) {
+        log.debug("Worker: Sending %s message from worker: %o", msg.messageType, msg);
+        postMessage(msg);
+    }
+    const eventTarget = new EventTarget();
+    eventNames.forEach((eventName) => {
+        // Subscribe to all known events and forward them as messages to the main thread.
+        eventTarget.addEventListener(eventName, (ev) => {
+            logAndPost({
+                messageType: "event",
+                type: ev.type,
+                detail: ev.detail,
+            });
+        });
+        // If there's an addEventListener on the object itself, forward those events as well.
+        if (service.addEventListener) {
+            service.addEventListener(eventName, (ev) => {
+                logAndPost({
+                    messageType: "event",
+                    type: ev.type,
+                    detail: ev.detail,
+                });
+            });
+        }
+    });
+    return function invokeMethod(req) {
+        // Pass the eventTarget to the methods marked as taking progress
+        return service[req.type]
+            .call(service, ...req.args, methods[req.type] === "requestWithProgress" ? eventTarget : undefined)
+            .then((result) => logAndPost({
+            messageType: "response",
+            type: req.type,
+            result: { success: true, result },
+        }))
+            .catch((err) => logAndPost({
+            // If this happens then the wasm code likely threw an exception/panicked rather than
+            // completing gracefully and fullfilling the promise. Communicate to the client
+            // that there was an error and it should reject the current request
+            messageType: "response",
+            type: req.type,
+            result: { success: false, error: err },
+        }));
+    };
+}