Upgrade workers

.github/workflows/deploy-pages.yaml

@@ -18,12 +18,11 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2.3.1
       - name: Install and Build 🔧
-        # Ensure public files are available when hosted as a web application
+        # Last step ensures public files are available when hosting the web application
         run: |
-          rm -rf dist/ 
-          cp -r public/ dist
           yarn install
-          yarn build
+          yarn build:app
+          cp -r public/* dist
       - name: Deploy 🚀
         uses: JamesIves/github-pages-deploy-action@4.1.5
         with:

.github/workflows/publish.yaml

@@ -14,7 +14,7 @@ jobs:
       - name: Install and Build 🔧
         run: |
           yarn install
-          yarn build
+          yarn build:library
       - name: Publish @dodona/papyros to NPM
         uses: JS-DevTools/npm-publish@v1
         with:

.gitignore

@@ -28,3 +28,5 @@ yarn-error.log*
 
 # script outputs
 translationIssues.txt
+
+src/workers/python/python_package/

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dodona/papyros",
-  "version": "0.1.90",
+  "version": "0.1.925-tar",
   "private": false,
   "homepage": ".",
   "devDependencies": {
@@ -33,9 +33,10 @@
     "ts-jest": "^27.0.7",
     "ts-loader": "^9.2.6",
     "typescript": "^4.1.2",
-    "webpack": "^5.64.0",
-    "webpack-cli": "^4.9.1",
-    "webpack-dev-server": "^4.6.0",
+    "url-loader": "^4.1.1",
+    "webpack": "^5.70.0",
+    "webpack-cli": "^4.9.2",
+    "webpack-dev-server": "^4.7.4",
     "worker-loader": "^3.0.8"
   },
   "dependencies": {
@@ -53,13 +54,17 @@
     "@codemirror/search": "^0.19.3",
     "@codemirror/state": "^0.19.6",
     "comlink": "^4.3.1",
+    "comsync": "^0.0.7",
     "escape-html": "^1.0.3",
     "i18n-js": "^3.8.0",
-    "sync-message": "^0.0.8"
+    "pyodide-worker-runner": "^0.0.8",
+    "sync-message": "^0.0.9"
   },
   "scripts": {
-    "start": "webpack serve --mode development",
-    "build": "webpack build --mode production",
+    "start": "yarn setup && webpack serve --mode development",
+    "setup": "bash scripts/setup.sh",
+    "build:app": "bash scripts/build_package.sh development",
+    "build:library": "bash scripts/build_package.sh production",
     "test": "echo No tests defined yet",
     "lint": "eslint  --ext '.js' --ext '.ts' src",
     "validate:translations": "node scripts/ValidateTranslations.js"

scripts/build_package.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+rm -rf dist
+bash ./scripts/setup.sh
+webpack build --mode=$1

scripts/setup.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+cd src/workers/python
+python3.9 build_package.py
+
+

src/App.ts

@@ -5,6 +5,8 @@ import {
 import { Papyros } from "./Papyros";
 import { InputMode } from "./InputManager";
 import { getElement } from "./util/Util";
+import { papyrosLog, LogType } from "./util/Logging";
+import { BackendManager } from "./BackendManager";
 
 
 async function startPapyros(): Promise<void> {
@@ -28,11 +30,12 @@ async function startPapyros(): Promise<void> {
         }
     });
     // Try to configure synchronous input mechanism
-    if (!await papyros.configureInput(location.href, DEFAULT_SERVICE_WORKER, false)) {
+    if (!await papyros.configureInput(location.href, DEFAULT_SERVICE_WORKER)) {
         getElement(MAIN_APP_ID).innerHTML =
             "Your browser is unsupported.\n" +
             "Please use a modern version of Chrome, Safari, Firefox, ...";
     } else { // Start actual application
+        papyrosLog(LogType.Debug, "Using channel: ", BackendManager.channel);
         papyros.launch();
     }
 }

src/Backend.ts

@@ -1,7 +1,7 @@
-import { PapyrosEvent } from "./PapyrosEvent";
-import { Channel, readMessage, uuidv4 } from "sync-message";
-import { parseData } from "./util/Util";
 import { CompletionContext, CompletionResult } from "@codemirror/autocomplete";
+import { BackendEvent, BackendEventType } from "./BackendEvent";
+import { papyrosLog, LogType } from "./util/Logging";
+import { syncExpose, SyncExtras } from "comsync";
 
 /**
  * Interface to represent the CodeMirror CompletionContext in a worker
@@ -37,80 +37,61 @@ export interface WorkerAutocompleteContext {
     } | null;
 }
 
-export abstract class Backend {
-    protected onEvent: (e: PapyrosEvent) => any;
-    protected runId: number;
-
+export abstract class Backend<Extras extends SyncExtras=SyncExtras> {
+    protected extras: Extras;
+    protected onEvent: (e: BackendEvent) => any;
     /**
-     *  Constructor is limited as it is meant to be used as a WebWorker
-     *  These are then exposed via Comlink. Proper initialization occurs
-     *  in the launch method when the worker is started
+     * Constructor is limited as it is meant to be used as a WebWorker
+     * Proper initialization occurs in the launch method when the worker is started
+     * Synchronously exposing methods should be done here
      */
     constructor() {
+        this.extras = {} as Extras;
         // eslint-disable-next-line @typescript-eslint/no-empty-function
         this.onEvent = () => { };
-        this.runId = 0;
+        this.runCode = this.syncExpose()(this.runCode.bind(this));
+    }
+
+    /**
+     * @return {any} The function to expose methods for Comsync to allow interrupting
+     */
+    protected syncExpose(): any {
+        return syncExpose;
     }
 
     /**
      * Initialize the backend by doing all setup-related work
-     * @param {function(PapyrosEvent):void} onEvent Callback for when events occur
-     * @param {Channel} channel for communication with the main thread
+     * @param {function(BackendEvent):void} onEvent Callback for when events occur
      * @return {Promise<void>} Promise of launching
      */
     launch(
-        onEvent: (e: PapyrosEvent) => void,
-        channel: Channel
+        onEvent: (e: BackendEvent) => void
     ): Promise<void> {
-        // Input messages are handled in a special way
-        // In order to link input requests to their responses
-        // An ID is required to make the connection
-        // The message must be read in the worker to not stall the main thread
-        const onInput = (e: PapyrosEvent): string => {
-            const inputData = parseData(e.data, e.contentType);
-            const messageId = uuidv4();
-            inputData.messageId = messageId;
-            e.data = JSON.stringify(inputData);
-            e.contentType = "text/json";
+        this.onEvent = (e: BackendEvent) => {
             onEvent(e);
-            return readMessage(channel, messageId);
-        };
-        this.onEvent = (e: PapyrosEvent) => {
-            e.runId = this.runId;
-            if (e.type === "input") {
-                return onInput(e);
-            } else {
-                return onEvent(e);
+            if (e.type === BackendEventType.Sleep) {
+                return this.extras.syncSleep(e.data);
+            } else if (e.type === BackendEventType.Input) {
+                return this.extras.readMessage();
             }
         };
         return Promise.resolve();
     }
 
-    /**
-     * Internal helper method that actually executes the code
-     * Results or Errors must be passed by using the onEvent-callback
-     * @param code The code to run
-     */
-    protected abstract _runCodeInternal(code: string): Promise<any>;
-
     /**
      * Executes the given code
+     * @param {Extras} extras Helper properties to run code
      * @param {string} code The code to run
-     * @param {string} runId The uuid for this execution
      * @return {Promise<void>} Promise of execution
      */
-    async runCode(code: string, runId: number): Promise<any> {
-        this.runId = runId;
-        return await this._runCodeInternal(code);
-    }
+    abstract runCode(extras: Extras, code: string): Promise<void>;
 
     /**
      * Converts the context to a cloneable object containing useful properties
      * to generate autocompletion suggestions with
      * Class instances are not passable to workers, so we extract the useful information
      * @param {CompletionContext} context Current context to autocomplete for
      * @param {RegExp} expr Expression to match the previous token with
-     * default a word with an optional dot to represent property access
      * @return {WorkerAutocompleteContext} Completion context that can be passed as a message
      */
     static convertCompletionContext(context: CompletionContext, expr = /\w*(\.)?/):
@@ -120,14 +101,16 @@ export abstract class Backend {
             return [line.number, (range.head - line.from)];
         })[0];
         const beforeMatch = context.matchBefore(expr);
-        return {
+        const ret = {
             explicit: context.explicit,
             before: beforeMatch,
             pos: context.pos,
             column: column,
             line: lineNr,
             text: context.state.doc.toString()
         };
+        papyrosLog(LogType.Debug, "Worker completion context:", ret);
+        return ret;
     }
 
     /**

src/BackendEvent.ts

@@ -0,0 +1,38 @@
+/**
+ * Enum representing all possible types for supported events
+ */
+export enum BackendEventType {
+    Start = "start",
+    End = "end",
+    Input = "input",
+    Output = "output",
+    Sleep = "sleep",
+    Error = "error",
+    Interrupt = "interrupt"
+}
+/**
+ * All possible types for ease of iteration
+ */
+export const BACKEND_EVENT_TYPES = [
+    BackendEventType.Start, BackendEventType.End,
+    BackendEventType.Input, BackendEventType.Output,
+    BackendEventType.Sleep, BackendEventType.Error,
+    BackendEventType.Interrupt
+];
+/**
+ * Interface for events used for communication between threads
+ */
+export interface BackendEvent {
+    /**
+     * The type of action generating this event
+     */
+    type: BackendEventType;
+    /**
+     * The actual data stored in this event
+     */
+    data: any;
+    /**
+     * The format used for the data to help with parsing
+     */
+    contentType?: string;
+}