Merge branch 'main' into usertask-matching-prototype

Author: MaxiLein

docker-compose.research.yml

@@ -14,14 +14,14 @@ services:
       - proceed-network
 
   proceed_research_postgres_database:
-    image: postgres:latest
+    image: postgres:17.7
     container_name: proceed_research_postgres_database
     env_file: .env.research
     restart: always
     ports:
       - '5433:5432'
     volumes:
-      - proceed_research_postgres_db:/var/lib/postgresql
+      - proceed_research_postgres_db:/var/lib/postgresql/data
     networks:
       - proceed-network
 

docker-compose.yml

@@ -23,22 +23,24 @@ services:
       - proceed-standalone-network
 
   proceed_standalone_postgres_database:
-    image: postgres:latest
+    image: postgres:17.7
     container_name: proceed_standalone_postgres_database
     restart: unless-stopped
     environment:
       POSTGRES_DB: proceed_db
       POSTGRES_USER: proceed
       POSTGRES_PASSWORD: proceed
     volumes:
-      - proceed_standalone_postgres_db:/var/lib/postgresql
+      - proceed_standalone_postgres_db:/var/lib/postgresql/data
     networks:
       - proceed-standalone-network
 
   proceed_standalone_engine:
     image: proceed/engine:edge
     container_name: proceed_standalone_engine
     restart: unless-stopped
+    ports:
+      - '33029:33029'
     networks:
       - proceed-standalone-network
 

package.json

@@ -58,8 +58,10 @@
     "docker:build-ms-standalone": "docker build -t proceed/ms-server:standalone -f ./src/management-system-v2/Dockerfile-selfhost .",
     "test": "yarn test-engine",
     "test-engine": "cross-env USE_PROJECTS=\"capabilities helper-modules engine-unit-integration\" jest",
-    "test-ms": "cd src/management-system && yarn test:unit",
     "test-e2e": "cross-env USE_PROJECTS=\"engine-e2e\" jest src/engine/e2e_tests --runInBand --detectOpenHandles --forceExit",
+    "test-ms": "cd src/management-system && yarn test:unit",
+    "test-ms-e2e-prepare-server": "yarn dev-ms-db && yarn build-ms && yarn next start src/management-system-v2",
+    "test-ms-e2e-start-playwright": "PLAYWRIGHT_TEST_BASE_URL='http://localhost:3000' yarn playwright test --ui",
     "test-all": "yarn test-engine && yarn test-e2e",
     "jsdoc": "jsdoc -c ./jsdoc.config.json --pedantic",
     "android-prepare": "cd src/engine/universal && webpack --output-path ../native/android/app/src/main/assets --config webpack.universal.config.js",

src/engine/e2e_tests/process/deployment/deployment.e2e.test.js

@@ -3806,15 +3806,20 @@ describe('Test deploying a process', () => {
             {
               tokenId: expect.any(String),
               state: 'PAUSED',
-              currentFlowElementId: 'Flow_1t4tcmh',
+              currentFlowElementId: 'Activity_1m0u15u',
               currentFlowElementStartTime: expect.any(Number),
-              previousFlowElementId: 'Activity_1m0u15u',
+              previousFlowElementId: 'Flow_0n4ueli',
+              currentFlowNodeProgress: {
+                manual: false,
+                value: expect.any(Number),
+              },
+              currentFlowNodeState: 'ACTIVE',
               localStartTime: expect.any(Number),
               localExecutionTime: expect.any(Number),
               machineHops: 0,
               deciderStorageRounds: 0,
               deciderStorageTime: 0,
-              intermediateVariablesState: null,
+              intermediateVariablesState: expect.any(Object),
             },
           ]);
           expect(instanceInfo.log).toEqual([
@@ -3831,20 +3836,6 @@ describe('Test deploying a process', () => {
                 port: 33020,
               },
             },
-            {
-              tokenId: expect.any(String),
-              flowElementId: 'Activity_1m0u15u',
-              executionState: 'COMPLETED',
-              startTime: expect.any(Number),
-              endTime: expect.any(Number),
-              machine: {
-                id: 'machineId1',
-                ip: expect.any(String),
-                name: 'machine1',
-                port: 33020,
-              },
-              progress: { value: 100, manual: false },
-            },
           ]);
 
           expect(instanceInfo.adaptationLog).toEqual([]);

src/engine/native/node/native-script-execution/src/child-process/bpmn-errors.js

@@ -19,15 +19,25 @@ module.exports = {
   `,
       );
   },
-  /** @param {string} script */
-  wrapScriptWithErrorHandling: function (script) {
-    return `try {
+  /**
+   * @param {string} script
+   * @param {string} [finallyCode]
+   * */
+  wrapScriptWithErrorHandling: function (script, finallyCode) {
+    let code = `try {
     ${script}
   } catch(e){
     if(${errorClasses.map((error) => 'e instanceof ' + error).join(' || ')})
       throw JSON.stringify(e);
     else throw e;
-  }
-  `;
+  }`;
+
+    if (finallyCode) {
+      code += `finally {
+        ${finallyCode}
+      }`;
+    }
+
+    return code;
   },
 };

src/engine/native/node/native-script-execution/src/child-process/http-server.js

@@ -19,14 +19,17 @@ let listeningOn = {
 };
 
 /** @param {import('.').ScriptTaskSetupData} setupData */
-module.exports = function setupNetworkServer({ context }) {
+module.exports = function setupNetworkServer({ context, waitUntilResumed }) {
   let listenerAdded = false;
+  /** @param {any} message */
   async function ipcMessageHandler(message) {
     try {
       // TODO: check structure of message
 
       if (message.type !== 'http-request') return;
 
+      await waitUntilResumed();
+
       const method = message.request.method.toLowerCase();
       const listeners = listeningOn[method];
 
@@ -237,8 +240,8 @@ module.exports = function setupNetworkServer({ context }) {
       delete: new Map(),
       get: new Map(),
     };
-    ${_networkServerCall.toString()}; globalThis['_networkServerCall'] = _networkServerCall;
-    ${_processRequest.toString()}; globalThis['_processRequest'] = _processRequest;
+    ${_networkServerCall.toString()};
+    ${_processRequest.toString()};
     ${_registerListener.toString()}
     ${_Response.toString()}
     ${_oneOffListener.toString()}
@@ -247,6 +250,17 @@ module.exports = function setupNetworkServer({ context }) {
     const $removeRoute = $2;
     const $removeIPCListener = $3;
     const $sendResponse = $4;
+
+    const _networkServer = new Proxy(
+      {},
+      {
+        get: function (_, method) {
+          return (...args) => _networkServerCall(method, args);
+        },
+      },
+    );
+
+    globalThis["networkServer"] = _networkServer;
     `,
     [
       new ivm.Reference((method, path) => {

src/engine/native/node/native-script-execution/src/child-process/index.js

@@ -25,37 +25,6 @@ if (
     'Expected the following args processId, processInstanceId, tokenId, scriptString, token',
   );
 
-/* -------------------------------------------------------------------------------------------------
- * Basic isolated vm setup
- * -----------------------------------------------------------------------------------------------*/
-
-const isolate = new ivm.Isolate({ memoryLimit: 128 });
-const context = isolate.createContextSync();
-
-context.global.setSync('global', context.global.derefInto());
-
-context.global.setSync('_stdout_log', function (...args) {
-  console.log(...args);
-});
-
-const wait = new ivm.Reference((ms) => new Promise((res) => setTimeout(res, ms)));
-
-context.evalClosureSync(
-  function wait(ms) {
-    $0.applySyncPromise(null, [ms], {});
-  }.toString() + `globalThis["wait"] = wait;`,
-  [wait],
-);
-
-context.evalClosureSync(
-  async function waitAsync(ms) {
-    await $0.apply(null, [ms], {
-      result: { promise: true },
-    });
-  }.toString() + `globalThis["waitAsync"] = waitAsync;`,
-  [wait],
-);
-
 /* -------------------------------------------------------------------------------------------------
  * Function for communication with universal part
  * -----------------------------------------------------------------------------------------------*/
@@ -107,6 +76,19 @@ async function callToExecutor(endpoint, body) {
   }
 }
 
+/* -------------------------------------------------------------------------------------------------
+ * Basic isolated vm setup
+ * -----------------------------------------------------------------------------------------------*/
+
+const isolate = new ivm.Isolate({ memoryLimit: 128 });
+const context = isolate.createContextSync();
+
+context.global.setSync('global', context.global.derefInto());
+
+context.global.setSync('_stdout_log', function (...args) {
+  console.log(...args);
+});
+
 /* -------------------------------------------------------------------------------------------------
  * Setup PROCEED's api for script task
  *
@@ -125,6 +107,7 @@ async function callToExecutor(endpoint, body) {
  *  processId: string,
  *  processInstanceId: string,
  *  tokenId: string
+ *  waitUntilResumed: () => Promise<void>
  * }} ScriptTaskSetupData
  */
 
@@ -135,8 +118,34 @@ const setupData = {
   processId,
   processInstanceId,
   tokenId,
+  waitUntilResumed: () => Promise.resolve(),
 };
 
+const setupPauseAndResumeLayer = require('./pause-resume-layer');
+const { waitUntilResumed, unmountPauseResumeListener } = setupPauseAndResumeLayer(setupData);
+setupData.waitUntilResumed = waitUntilResumed;
+
+const wait = new ivm.Reference(async (ms) => {
+  await new Promise((res) => setTimeout(res, ms));
+  await waitUntilResumed();
+});
+
+context.evalClosureSync(
+  function wait(ms) {
+    $0.applySyncPromise(null, [ms], {});
+  }.toString() + `globalThis["wait"] = wait;`,
+  [wait],
+);
+
+context.evalClosureSync(
+  async function waitAsync(ms) {
+    await $0.apply(null, [ms], {
+      result: { promise: true },
+    });
+  }.toString() + `globalThis["waitAsync"] = waitAsync;`,
+  [wait],
+);
+
 const setupSimpleFunctionCalls = require('./simple-function-calls');
 setupSimpleFunctionCalls(setupData);
 
@@ -156,11 +165,14 @@ setupNetworkServer(setupData);
  * Execute script
  * -----------------------------------------------------------------------------------------------*/
 
+/** @param {string} script */
 function wrapScriptInAsyncFunction(script) {
   return `async function main() { ${script} }; main();`;
 }
 
-const isolateCode = wrapScriptInAsyncFunction(wrapScriptWithErrorHandling(scriptString));
+const isolateCode = wrapScriptInAsyncFunction(
+  wrapScriptWithErrorHandling(scriptString, unmountPauseResumeListener),
+);
 
 // After .eval is done, there may still be code running inside the isolate, that the .eval returns
 // means just that the code the user wrote returned a value, the process will remain open until the

src/engine/native/node/native-script-execution/src/child-process/pause-resume-layer.js

@@ -0,0 +1,60 @@
+// @ts-check
+
+const ivm = require('isolated-vm');
+
+const pauseMessageType = 'pause-execution';
+const resumeMessageType = 'resume-execution';
+
+/** @param {Omit<import('.').ScriptTaskSetupData, "waitUntilResumed">} setupData */
+module.exports = function setupPauseAndResumeLayer({ context }) {
+  /** @typedef {{
+   *    promise: Promise<void>;
+   *    resolve: () => void;
+   *    reject: () => void;
+   * }} PausePromise */
+
+  /** @type { PausePromise | undefined } */
+  let executionPausedPromise = undefined;
+
+  /** @param {any} message */
+  function ipcMessageHandler(message) {
+    try {
+      // TODO: check structure of message
+
+      if (message.type === pauseMessageType) {
+        /** @type { PausePromise } */
+        const pausePromise = {};
+        pausePromise.promise = new Promise((res, rej) => {
+          pausePromise.resolve = res;
+          pausePromise.reject = rej;
+        });
+
+        executionPausedPromise = pausePromise;
+      } else if (message.type === resumeMessageType && executionPausedPromise) {
+        executionPausedPromise.resolve();
+        executionPausedPromise = undefined;
+      }
+    } catch (e) {
+      console.error('Error pausing/resuming execution', e);
+    }
+  }
+  process.on('message', ipcMessageHandler);
+
+  context.evalClosure("globalThis['_unmountPauseListener'] = function() { $0.apply(null, []) }", [
+    new ivm.Reference(() => {
+      // If this listener isn't removed, the childProcess will not end after the evaluation of
+      // the script task is done
+
+      process.removeListener('message', ipcMessageHandler);
+    }),
+  ]);
+
+  return {
+    async waitUntilResumed() {
+      if (executionPausedPromise) {
+        await executionPausedPromise.promise;
+      }
+    },
+    unmountPauseResumeListener: '\n_unmountPauseListener();',
+  };
+};

src/engine/native/node/native-script-execution/src/child-process/service-calls.js

@@ -9,19 +9,14 @@ module.exports = function setupServiceCalls({
   processId,
   processInstanceId,
   tokenId,
+  waitUntilResumed,
 }) {
   /** @param {string} serviceName */
   function _getService(serviceName) {
     return new Proxy(
       {},
       {
         get: function (_, method) {
-          // network-server is a bit more complex so it requires it's own implementation
-          // _networkServerCall is defined in ./http-server.js
-          if (serviceName === 'network-server') {
-            return (...args) => _networkServerCall(method, args);
-          }
-
           return (...args) => _callToService(serviceName, method, args);
         },
       },
@@ -72,6 +67,7 @@ module.exports = function setupServiceCalls({
   ${_parseResult.toString()};
   ${_callToService.toString()};
   ${_getService.toString()}; globalThis["getService"] = _getService;
+  globalThis["networkRequest"] = getService("network-requests");
   `,
     [
       new ivm.Reference(
@@ -81,6 +77,7 @@ module.exports = function setupServiceCalls({
          * @param {string} args stringified array of args
          */
         async function (serviceName, method, args) {
+          await waitUntilResumed();
           const result = await callToExecutor('call', {
             functionName: `getService.${serviceName}.${method}`,
             args: [processId, processInstanceId, tokenId, ...JSON.parse(args)],