@5minds/node-red-contrib-processcube 1.5.6 → 1.5.7-develop-10cfa5-m3qdjs6o

package/endevent-finished-listener.js

@@ -4,6 +4,19 @@ module.exports = function (RED) {
         var node = this;
         node.engine = RED.nodes.getNode(config.engine);
 
+        let subscription = null;
+
+        const eventEmitter = node.engine.eventEmitter;
+
+        eventEmitter.on('engine-client-dispose', () => {
+            node.engine.engineClient.events.removeSubscription(subscription, node.engine.identity);
+        });
+
+        eventEmitter.on('engine-client-changed', () => {
+            node.log('new engineClient received');
+            register();
+        });
+
         const register = async () => {
             const client = node.engine.engineClient;
 
@@ -11,10 +24,8 @@ module.exports = function (RED) {
                 node.error('No engine configured.');
                 return;
             }
-    
-            let currentIdentity = node.engine.identity;
 
-            let subscription = null;
+            let currentIdentity = node.engine.identity;
 
             try {
                 subscription = await client.events.onEndEventFinished(
@@ -23,24 +34,23 @@ module.exports = function (RED) {
                             payload: endEventFinished,
                         });
                     },
-                    { identity: currentIdentity },
+                    { identity: currentIdentity }
                 );
 
                 node.engine.registerOnIdentityChanged(async (identity) => {
                     client.events.removeSubscription(subscription, currentIdentity);
-                    
+
                     currentIdentity = identity;
 
                     subscription = await client.events.onEndEventFinished(
                         (endEventFinished) => {
                             node.send({
-                                payload: endEventFinished
+                                payload: endEventFinished,
                             });
                         },
-                        { identity: currentIdentity },
+                        { identity: currentIdentity }
                     );
                 });
-
             } catch (error) {
                 node.error(error);
             }

package/externaltask-event-listener.js

@@ -4,6 +4,19 @@ module.exports = function (RED) {
         var node = this;
         node.engine = RED.nodes.getNode(config.engine);
 
+        let subscription;
+
+        const eventEmitter = node.engine.eventEmitter;
+
+        eventEmitter.on('engine-client-dispose', () => {
+            node.engine.engineClient.notification.removeSubscription(subscription, node.engine.identity);
+        });
+
+        eventEmitter.on('engine-client-changed', () => {
+            node.log('new engineClient received');
+            register();
+        });
+
         const register = async () => {
             let currentIdentity = node.engine.identity;
 
@@ -14,8 +27,6 @@ module.exports = function (RED) {
                 return;
             }
 
-            let subscription;
-
             function externalTaskCallback() {
                 return (externalTaskNotification) => {
                     if (config.externaltask != '' && config.externaltask != externalTaskNotification.flowNodeId) return;

package/externaltask-input.html

@@ -58,11 +58,26 @@
 Waiting for external tasks that correspond to the `Topic` configured in
 the connected ProcessCube Engine for processing.
 
+## Configs
+
+: name (string) : The name of the node
+: engine (string) : The ProcessCube Engine to connect to
+: topic (string) : The topic of the external task
+: workerConfig (object) : The configuration for the worker
+
+### workerConfig
+
+- workerId (string): The id of the worker
+- lockDuration (number): The duration in milliseconds the external task is locked for execution
+- maxTasks (number): The maximum number of tasks that can be fetched at once
+- longpollingTimeout (number): The duration in milliseconds the external task is locked for execution
+- payloadFilter (Req-Expression): The filter for the payload of the external task
+
 ## Outputs
 
 : payload (string) : The payload the external task was started with.
 : task (object) : The external task object
-: flowNodeInstanceId : The unique identifier of the external task, which is needed to complete the task
+: flowNodeInstanceId (string) : The unique identifier of the external task, which is needed to complete the task
 
 ### Details
 

package/externaltask-input.js

@@ -32,132 +32,152 @@ module.exports = function (RED) {
             eventEmitter = flowContext.get('emitter');
         }
 
-        const etwCallback = async (payload, externalTask) => {
-            const saveHandleCallback = (data, callback) => {
-                try {
-                    callback(data);
-                } catch (error) {
-                    node.error(`Error in callback 'saveHandleCallback': ${error.message}`);
-                }
-            };
+        const engineEventEmitter = node.engine.eventEmitter;
 
-            return await new Promise((resolve, reject) => {
-                const handleFinishTask = (msg) => {
-                    let result = RED.util.encodeObject(msg.payload);
+        engineEventEmitter.on('engine-client-dispose', () => {
+            node.engine.engineClient.externalTasks.removeSubscription(subscription, node.engine.identity);
+        });
 
-                    node.log(
-                        `handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* ${externalTask.processInstanceId} with result ${result} on msg._msgid ${msg._msgid}.`
-                    );
+        engineEventEmitter.on('engine-client-changed', () => {
+            node.log('new engineClient received');
+            register();
+        });
 
-                    if (externalTask.flowNodeInstanceId) {
-                        delete started_external_tasks[externalTask.flowNodeInstanceId];
+        const register = async () => {
+            const etwCallback = async (payload, externalTask) => {
+                const saveHandleCallback = (data, callback) => {
+                    try {
+                        callback(data);
+                    } catch (error) {
+                        node.error(`Error in callback 'saveHandleCallback': ${error.message}`);
                     }
+                };
 
-                    showStatus(node, Object.keys(started_external_tasks).length);
+                return await new Promise((resolve, reject) => {
+                    const handleFinishTask = (msg) => {
+                        let result = RED.util.encodeObject(msg.payload);
 
-                    //resolve(result);
-                    saveHandleCallback(result, resolve);
-                };
+                        node.log(
+                            `handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* ${externalTask.processInstanceId} with result ${result} on msg._msgid ${msg._msgid}.`
+                        );
 
-                const handleErrorTask = (msg) => {
-                    node.log(
-                        `handle error event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' on *msg._msgid* '${msg._msgid}'.`
-                    );
+                        if (externalTask.flowNodeInstanceId) {
+                            delete started_external_tasks[externalTask.flowNodeInstanceId];
+                        }
 
-                    if (externalTask.flowNodeInstanceId) {
-                        delete started_external_tasks[externalTask.flowNodeInstanceId];
-                    }
+                        showStatus(node, Object.keys(started_external_tasks).length);
 
-                    showStatus(node, Object.keys(started_external_tasks).length);
+                        //resolve(result);
+                        saveHandleCallback(result, resolve);
+                    };
 
-                    // TODO: with reject, the default error handling is proceed
-                    // SEE: https://github.com/5minds/ProcessCube.Engine.Client.ts/blob/develop/src/ExternalTaskWorker.ts#L180
-                    // reject(result);
-                    //resolve(msg);
-                    saveHandleCallback(msg, resolve);
-                };
+                    const handleErrorTask = (msg) => {
+                        node.log(
+                            `handle error event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' on *msg._msgid* '${msg._msgid}'.`
+                        );
 
-                eventEmitter.once(`handle-${externalTask.flowNodeInstanceId}`, (msg, isError = false) => {
-                    node.log(
-                        `handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}' and *isError* '${isError}'`
-                    );
+                        if (externalTask.flowNodeInstanceId) {
+                            delete started_external_tasks[externalTask.flowNodeInstanceId];
+                        }
 
-                    if (isError) {
-                        handleErrorTask(msg);
-                    } else {
-                        handleFinishTask(msg);
-                    }
-                });
+                        showStatus(node, Object.keys(started_external_tasks).length);
 
-                started_external_tasks[externalTask.flowNodeInstanceId] = externalTask;
+                        // TODO: with reject, the default error handling is proceed
+                        // SEE: https://github.com/5minds/ProcessCube.Engine.Client.ts/blob/develop/src/ExternalTaskWorker.ts#L180
+                        // reject(result);
+                        //resolve(msg);
+                        saveHandleCallback(msg, resolve);
+                    };
 
-                showStatus(node, Object.keys(started_external_tasks).length);
+                    eventEmitter.once(`handle-${externalTask.flowNodeInstanceId}`, (msg, isError = false) => {
+                        node.log(
+                            `handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}' and *isError* '${isError}'`
+                        );
 
-                let msg = {
-                    _msgid: RED.util.generateId(),
-                    task: RED.util.encodeObject(externalTask),
-                    payload: payload,
-                    flowNodeInstanceId: externalTask.flowNodeInstanceId,
-                    processInstanceId: externalTask.processInstanceId
-                };
+                        if (isError) {
+                            handleErrorTask(msg);
+                        } else {
+                            handleFinishTask(msg);
+                        }
+                    });
 
-                node.log(
-                    `Received *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}'`
-                );
+                    started_external_tasks[externalTask.flowNodeInstanceId] = externalTask;
 
-                node.send(msg);
-            });
-        };
+                    showStatus(node, Object.keys(started_external_tasks).length);
 
-        client.externalTasks
-            .subscribeToExternalTaskTopic(config.topic, etwCallback, RED.util.evaluateNodeProperty(config.workerConfig, 'json', node))
-            .then(async (externalTaskWorker) => {
-                node.status({ fill: 'blue', shape: 'ring', text: 'subcribed' });
+                    let msg = {
+                        _msgid: RED.util.generateId(),
+                        task: RED.util.encodeObject(externalTask),
+                        payload: payload,
+                        flowNodeInstanceId: externalTask.flowNodeInstanceId,
+                        processInstanceId: externalTask.processInstanceId,
+                    };
 
-                externalTaskWorker.identity = engine.identity;
-                engine.registerOnIdentityChanged((identity) => {
-                    externalTaskWorker.identity = identity;
-                });
+                    node.log(
+                        `Received *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}'`
+                    );
 
-                // export type WorkerErrorHandler = (errorType: 'fetchAndLock' | 'extendLock' | 'processExternalTask' | 'finishExternalTask', error: Error, externalTask?: ExternalTask<any>) => void;
-                externalTaskWorker.onWorkerError((errorType, error, externalTask) => {
-                    switch (errorType) {
-                        case 'extendLock':
-                        case 'finishExternalTask':
-                        case 'processExternalTask':
-                            node.error(
-                                `Worker error ${errorType} for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}': ${error.message}`
-                            );
-
-                            if (externalTask) {
-                                delete started_external_tasks[externalTask.flowNodeInstanceId];
-                            }
-
-                            showStatus(node, Object.keys(started_external_tasks).length);
-                            break;
-                        default:
-                            node.error(`Worker error ${errorType}: ${error.message}`);
-                            break;
-                    }
+                    node.send(msg);
                 });
+            };
 
-                try {
-                    externalTaskWorker.start();
-                } catch (error) {
-                    node.error(`Worker start 'externalTaskWorker.start' failed: ${error.message}`);
-                }
+            let options = RED.util.evaluateNodeProperty(config.workerConfig, 'json', node);
+
+            client.externalTasks
+                .subscribeToExternalTaskTopic(config.topic, etwCallback, options)
+                .then(async (externalTaskWorker) => {
+                    node.status({ fill: 'blue', shape: 'ring', text: 'subcribed' });
+
+                    externalTaskWorker.identity = engine.identity;
+                    engine.registerOnIdentityChanged((identity) => {
+                        externalTaskWorker.identity = identity;
+                    });
+
+                    // export type WorkerErrorHandler = (errorType: 'fetchAndLock' | 'extendLock' | 'processExternalTask' | 'finishExternalTask', error: Error, externalTask?: ExternalTask<any>) => void;
+                    externalTaskWorker.onWorkerError((errorType, error, externalTask) => {
+                        switch (errorType) {
+                            case 'extendLock':
+                            case 'finishExternalTask':
+                            case 'processExternalTask':
+                                node.error(
+                                    `Worker error ${errorType} for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}': ${error.message}`
+                                );
+
+                                if (externalTask) {
+                                    delete started_external_tasks[externalTask.flowNodeInstanceId];
+                                }
+
+                                showStatus(node, Object.keys(started_external_tasks).length);
+                                break;
+                            default:
+                                // reduce noise error logs
+                                // node.error(`Worker error ${errorType}: ${error.message}`);
+                                break;
+                        }
+                    });
 
-                node.on('close', () => {
                     try {
-                        externalTaskWorker.stop();
-                    } catch {
-                        node.error('Client close failed');
+                        externalTaskWorker.start();
+                    } catch (error) {
+                        node.error(`Worker start 'externalTaskWorker.start' failed: ${error.message}`);
                     }
+
+                    node.on('close', () => {
+                        try {
+                            externalTaskWorker.stop();
+                        } catch {
+                            node.error('Client close failed');
+                        }
+                    });
+                })
+                .catch((error) => {
+                    node.error(`Error in subscribeToExternalTaskTopic: ${error.message}`);
                 });
-            })
-            .catch((error) => {
-                node.error(`Error in subscribeToExternalTaskTopic: ${error.message}`);
-            });
+        };
+
+        if (node.engine) {
+            register();
+        }
     }
 
     RED.nodes.registerType('externaltask-input', ExternalTaskInput);

package/nodered/flows.json

@@ -71,6 +71,22 @@
         "info": "",
         "env": []
     },
+    {
+        "id": "76c047e0d8770a20",
+        "type": "tab",
+        "label": "Other Events",
+        "disabled": false,
+        "info": "",
+        "env": []
+    },
+    {
+        "id": "2766c40d84283368",
+        "type": "tab",
+        "label": "Placeholder",
+        "disabled": false,
+        "info": "",
+        "env": []
+    },
     {
         "id": "4c59118134081e05",
         "type": "group",
@@ -481,6 +497,7 @@
             "color": "#a4a4a4"
         },
         "nodes": [
+
             "2fadb4c4667ecaf2",
             "93331783b7ef3fc5",
             "bc26f9821540f097",
@@ -1485,7 +1502,7 @@
         "g": "a71a168415778e2c",
         "name": "",
         "engine": "42e6796dddd9d4db",
-        "query": "{\"includeXml\":false}",
+        "query": "{\"includeXml\":false,\"processDefinitionId\":\"External-Task-Sample_Definition\"}",
         "query_type": "json",
         "x": 320,
         "y": 140,
@@ -2094,5 +2111,95 @@
         "x": 760,
         "y": 60,
         "wires": []
+    },
+    {
+        "id": "930624edc6169c55",
+        "type": "process-event-listener",
+        "z": "76c047e0d8770a20",
+        "g": "865723b71ced9418",
+        "name": "",
+        "engine": "42e6796dddd9d4db",
+        "processmodel": "External-Task-Sample_Process",
+        "eventtype": "starting",
+        "query": "{}",
+        "query_type": "json",
+        "x": 160,
+        "y": 140,
+        "wires": [
+            [
+                "2f2ec1cc0213eab5"
+            ]
+        ]
+    },
+    {
+        "id": "2f2ec1cc0213eab5",
+        "type": "debug",
+        "z": "76c047e0d8770a20",
+        "g": "865723b71ced9418",
+        "name": "debug 34",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "false",
+        "statusVal": "",
+        "statusType": "auto",
+        "x": 430,
+        "y": 140,
+        "wires": []
+    },
+    {
+        "id": "bde205e77cd20558",
+        "type": "comment",
+        "z": "76c047e0d8770a20",
+        "g": "865723b71ced9418",
+        "name": "Hört auf die Events der Processe",
+        "info": "",
+        "x": 190,
+        "y": 80,
+        "wires": []
+    },
+    {
+        "id": "03ac7bc273197c45",
+        "type": "process-terminate",
+        "z": "2766c40d84283368",
+        "g": "9081b057a931f0cf",
+        "name": "",
+        "engine": "42e6796dddd9d4db",
+        "x": 170,
+        "y": 140,
+        "wires": [
+            [
+                "bb734a85d4b37728"
+            ]
+        ]
+    },
+    {
+        "id": "bb734a85d4b37728",
+        "type": "debug",
+        "z": "2766c40d84283368",
+        "g": "9081b057a931f0cf",
+        "name": "debug 35",
+        "active": true,
+        "tosidebar": true,
+        "console": false,
+        "tostatus": false,
+        "complete": "false",
+        "statusVal": "",
+        "statusType": "auto",
+        "x": 370,
+        "y": 140,
+        "wires": []
+    },
+    {
+        "id": "3d03550f7d93bfd3",
+        "type": "comment",
+        "z": "2766c40d84283368",
+        "g": "9081b057a931f0cf",
+        "name": "Event for Terminating a Process",
+        "info": "",
+        "x": 210,
+        "y": 80,
+        "wires": []
     }
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@5minds/node-red-contrib-processcube",
-    "version": "1.5.6",
+    "version": "1.5.7-develop-10cfa5-m3qdjs6o",
     "license": "MIT",
     "description": "Node-RED nodes for ProcessCube",
     "scripts": {

package/process-event-listener.js

@@ -4,6 +4,19 @@ module.exports = function (RED) {
         var node = this;
         node.engine = RED.nodes.getNode(config.engine);
 
+        let subscription;
+
+        const eventEmitter = node.engine.eventEmitter;
+
+        engineEventEmitter.on('engine-client-dispose', () => {
+            node.engine.engineClient.notification.removeSubscription(subscription, node.engine.identity);
+        });
+
+        eventEmitter.on('engine-client-changed', () => {
+            node.log('new engineClient received');
+            register();
+        });
+
         const register = async () => {
             const client = node.engine.engineClient;
 
@@ -14,7 +27,6 @@ module.exports = function (RED) {
 
             let currentIdentity = node.engine.identity;
 
-            let subscription;
             const query = RED.util.evaluateNodeProperty(config.query, config.query_type, node);
 
             async function subscribe(eventType) {
@@ -24,7 +36,8 @@ module.exports = function (RED) {
                             async (processNotification) => {
                                 if (
                                     config.processmodel != '' &&
-                                    config.processmodel != processNotification.processModelId) {
+                                    config.processmodel != processNotification.processModelId
+                                ) {
                                     return;
                                 }
 
@@ -65,7 +78,8 @@ module.exports = function (RED) {
                             async (processNotification) => {
                                 if (
                                     config.processmodel != '' &&
-                                    config.processmodel != processNotification.processModelId) {
+                                    config.processmodel != processNotification.processModelId
+                                ) {
                                     return;
                                 }
 
@@ -433,7 +447,6 @@ module.exports = function (RED) {
                     },
                     { identity: currentIdentity }
                 );
-
             });
 
             node.on('close', () => {

package/process-terminate.html

@@ -29,9 +29,10 @@
 <script type="text/markdown" data-help-name="process-terminate">
 Terminate an instance of a process model in the ProcessCube.
 
-## Inputs
+## Configs
 
-: payload (string): The id of the processinstance that is going to be terminated.
+: name (string): name of the node
+: engine (string): the engine to connect to
 
 ## Outputs
 

package/processcube-engine-config.js

@@ -1,3 +1,4 @@
+const EventEmitter = require('node:events');
 const engine_client = require('@5minds/processcube_engine_client');
 const jwt = require('jwt-decode');
 const oidc = require('openid-client');
@@ -12,7 +13,8 @@ module.exports = function (RED) {
         this.credentials.clientId = RED.util.evaluateNodeProperty(n.clientId, n.clientIdType, node);
         this.credentials.clientSecret = RED.util.evaluateNodeProperty(n.clientSecret, n.clientSecretType, node);
 
-        // known issue: kann bei falschem timing zu laufzeitfehlern führen (absprache MM)
+        node.eventEmitter = new EventEmitter();
+
         // set the engine url
         const stopRefreshing = periodicallyRefreshEngineClient(this, n, 10000);
 
@@ -41,23 +43,29 @@ module.exports = function (RED) {
             function refreshUrl() {
                 const newUrl = RED.util.evaluateNodeProperty(n.url, n.urlType, node);
 
-                if (node.url == newUrl) {
+                if (node.url === newUrl) {
                     return;
                 }
 
                 node.url = newUrl;
                 if (node.credentials.clientId && node.credentials.clientSecret) {
-                    if (this.engineClient) {
-                        this.engineClient.dispose();
+                    if (node.engineClient) {
+                        node.eventEmitter.emit('engine-client-dispose');
+                        node.engineClient.dispose();
                     }
                     node.engineClient = new engine_client.EngineClient(node.url, () =>
                         getFreshIdentity(node.url, node)
                     );
+
+                    node.eventEmitter.emit('engine-client-changed');
                 } else {
-                    if (this.engineClient) {
-                        this.engineClient.dispose();
+                    if (node.engineClient) {
+                        node.eventEmitter.emit('engine-client-dispose');
+                        node.engineClient.dispose();
                     }
                     node.engineClient = new engine_client.EngineClient(node.url);
+
+                    node.eventEmitter.emit('engine-client-changed');
                 }
             }