@halsystems/red-bacnet 2.2.0 → 2.2.2-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [2.2.2-alpha.0]
+### Added
+- `CoalescedJobQueue` added `onStart` and `onStop` hooks
+- auto sync to `red-bacnet-public` repo
+
+### Fixed
+- `discover device` fixed `#IAmHandler` memory leak issue
+- `CICD` Fixed broken pipeline due to package registry caching / propagation issue
+
+## [2.2.1]
+### Fixed
+- Fixed unhandled promise rejections in BACnet `jobs` that could hang the job queue or crash Node-RED; errors are now reported instead.
+
 ## [2.2.0]
 ### Changed
 - Matched v2.2.0-alpha.2 release

package/common/core/constant.js

@@ -31,7 +31,5 @@ module.exports = {
 
     // job error
     ERR_CONSTRUCT_ABSTRACT_JOB: 'Cannot construct abstract Job class',
-    ERR_ONSTART_NOT_IMPLEMENTED: 'OnStart method is not implemented.',
-    ERR_ONSTOP_NOT_IMPLEMENTED: 'OnStop method is not implemented.',
     ERR_EXECUTE_NOT_IMPLEMENTED: 'Execute method is not implemented.',
 }

package/common/job/core.js

@@ -3,8 +3,7 @@ require('./_alias.js');
 
 const { print } = require('@root/common/core/util.js');
 const {
-    ERR_CONSTRUCT_ABSTRACT_JOB, ERR_ONSTART_NOT_IMPLEMENTED,
-    ERR_ONSTOP_NOT_IMPLEMENTED, ERR_EXECUTE_NOT_IMPLEMENTED
+    ERR_CONSTRUCT_ABSTRACT_JOB, ERR_EXECUTE_NOT_IMPLEMENTED
 } = require('@root/common/core/constant.js')
 
 /**
@@ -51,10 +50,8 @@ class BaseJob {
      *
      * @async
      * @returns {Promise<void>}
-     * @throws {Error} If not implemented by subclass.
      */
     async onStart() {
-        throw new Error(ERR_ONSTART_NOT_IMPLEMENTED);
     }
 
     /**
@@ -79,10 +76,8 @@ class BaseJob {
      *
      * @async
      * @returns {Promise<void>}
-     * @throws {Error} If not implemented by subclass.
      */
     async onStop() {
-        throw new Error(ERR_ONSTOP_NOT_IMPLEMENTED);
     }
 }
 
@@ -160,9 +155,12 @@ class CoalescedJobQueue {
 
                 const job = this.queue.splice(jobIndex, 1)[0];
                 try {
+                    await job.task.onStart();
                     await job.task.execute();
                 } catch (error) {
                     console.error(`Error executing job ${job.id}:`, error);
+                } finally {
+                    await job.task.onStop();
                 }
             }
             await new Promise(resolve => setTimeout(resolve, this.delay));

package/common/job/discover_device.js

@@ -22,6 +22,7 @@ module.exports = {
         knownDevices = new Set();
         discoverList = [];
         discoveredDevices = [];
+        #boundIAmHandler;
 
         /**
          * Construct a DiscoverDeviceJob.
@@ -46,62 +47,50 @@ module.exports = {
             this.highLimit = highLimit
             this.whoIsTimeout = whoIsTimeout
             this.name = name
+            this.#boundIAmHandler = this.#iAmHandler.bind(this)
         }
 
         async onStart() {
-            this.client.on(EVENT_I_AM, this.#iAmHandler.bind(this))
+            this.client.on(EVENT_I_AM, this.#boundIAmHandler)
         }
         async onStop() {
-            this.client.removeListener(EVENT_I_AM, this.#iAmHandler.bind(this))
+            this.client.removeListener(EVENT_I_AM, this.#boundIAmHandler)
         }
 
         async execute() {
-            // discover device job will be reuse
-            this.knownDevices.clear()
+            this.knownDevices.clear();
             this.discoverList = [];
             this.discoveredDevices = [];
 
-            this.#updateProgress(0)
-
-            return new Promise((resolve, reject) => {
-                try {
-                    this.client.whoIs({ net: this.network, lowLimit: this.lowLimit, highLimit: this.highLimit })
-
-                    setTimeout(() => {
-                        this.#updateProgress(10)
-
-                        this.#readDevices().then(() => {
-                            let validatedDevices = [];
-                            for (let i = 0; i < this.discoveredDevices.length; i++) {
-                                const device = this.discoveredDevices[i];
-                                const { error, value: result } = bacnetDeviceSchema.validate(device);
-
-                                if (error) {
-                                    this.eventEmitter.emit(EVENT_ERROR, errMsg(
-                                        this.name, `BACnet device schema validation error (${device.deviceId})`, error
-                                    ))
-                                    this.eventEmitter.emit(EVENT_ERROR, errMsg(
-                                        this.name, `${ERR_SCHEMA_VALIDATION} (${device.deviceId})`, error
-                                    ))
-                                    continue;
-                                }
-                                validatedDevices.push(result);
-                            }
+            this.#updateProgress(0);
+            try {
+                this.client.whoIs({ net: this.network, lowLimit: this.lowLimit, highLimit: this.highLimit });
+
+                await new Promise((resolve) => setTimeout(resolve, this.whoIsTimeout));
+
+                this.#updateProgress(10);
+                await this.#readDevices();
+
+                const validatedDevices = [];
+                for (const device of this.discoveredDevices) {
+                    const { error, value: result } = bacnetDeviceSchema.validate(device);
 
-                            this.msg.payload = validatedDevices;
-                            this.eventEmitter.emit(EVENT_OUTPUT, this.msg);
-                            this.#updateProgress(100)
-                            resolve();
-                        }).catch(error => {
-                            this.#updateProgress(100)
-                            reject(error);
-                        });
-                    }, this.whoIsTimeout);
-                } catch (err) {
-                    this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, ERR_GENERIC, getErrMsg(err)))
-                    resolve();
+                    if (error) {
+                        this.eventEmitter.emit(EVENT_ERROR, errMsg(
+                            this.name, `${ERR_SCHEMA_VALIDATION} (${device.deviceId})`, error
+                        ));
+                        continue;
+                    }
+                    validatedDevices.push(result);
                 }
-            });
+
+                this.msg.payload = validatedDevices;
+                this.eventEmitter.emit(EVENT_OUTPUT, this.msg);
+            } catch (err) {
+                this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, ERR_GENERIC, getErrMsg(err)));
+            } finally {
+                this.#updateProgress(100);
+            }
         }
 
         /**

package/common/job/discover_point.js

@@ -73,73 +73,60 @@ module.exports = {
         }
 
         async execute() {
-            this.#updateProgress('discovering')
+            this.#updateProgress('discovering');
+            try {
+                // validate devices
+                if (!Array.isArray(this.inputDevices)) {
+                    this.eventEmitter.emit(EVENT_ERROR, errMsg(
+                        this.name, ERR_INVALID_DATA_TYPE,
+                        {
+                            devices: this?.inputDevices,
+                            expected: 'array',
+                            example: EG_BACNET_DEVICES
+                        })
+                    );
+                    return;
+                }
+
+                const deviceNameSet = new Set();
+                for (const device of this.inputDevices) {
+                    const { error, value: result } = bacnetDeviceSchema.validate(
+                        device,
+                        { stripUnknown: true }
+                    );
 
-            return new Promise((resolve) => {
-                try {
-                    // validate devices
-                    if (!Array.isArray(this.inputDevices)) {
+                    if (error) {
                         this.eventEmitter.emit(EVENT_ERROR, errMsg(
-                            this.name, ERR_INVALID_DATA_TYPE,
-                            {
-                                devices: this?.inputDevices,
-                                expected: 'array',
-                                example: EG_BACNET_DEVICES
-                            })
-                        )
-                        this.#updateProgress('completed')
-                        resolve();
-                        return
+                            this.name, ERR_SCHEMA_VALIDATION, error
+                        ));
+                        continue;
                     }
 
-                    let deviceNameSet = new Set();
-                    for (let i = 0; i < this.inputDevices.length; i++) {
-                        const device = this.inputDevices[i];
-                        const { error, value: result } = bacnetDeviceSchema.validate(
-                            device,
-                            { stripUnknown: true }
-                        );
-                        // if device id is null, set to 4194303
-                        if (result.deviceId == null)
-                            result.deviceId = 4194303;
-
-                        if (error) {
-                            this.eventEmitter.emit(EVENT_ERROR, errMsg(
-                                this.name, ERR_SCHEMA_VALIDATION, error
-                            ))
-                            continue
-                        }
+                    // if device id is null, set to 4194303
+                    if (result.deviceId == null)
+                        result.deviceId = 4194303;
 
-                        // ensure no duplicate device name
-                        if (deviceNameSet.has(result.deviceName)) {
-                            this.eventEmitter.emit(EVENT_ERROR, errMsg(
-                                this.name, ERR_IGNORE_DUPLICATED_DEVICE_NAME, result
-                            ))
-                            continue
-                        }
-                        deviceNameSet.add(result.deviceName);
-
-                        // add device to list
-                        this.devices.push(result);
-                    }
-
-                    // If no valid devices, complete immediately
-                    if (this.devices.length === 0) {
-                        this.#updateProgress('completed')
-                        resolve();
-                        return
+                    // ensure no duplicate device name
+                    if (deviceNameSet.has(result.deviceName)) {
+                        this.eventEmitter.emit(EVENT_ERROR, errMsg(
+                            this.name, ERR_IGNORE_DUPLICATED_DEVICE_NAME, result
+                        ));
+                        continue;
                     }
+                    deviceNameSet.add(result.deviceName);
 
-                    // read all device points
-                    this.#readAllDevicePoints().then(() => {
-                        this.#updateProgress('completed')
-                        resolve();
-                    });
-                } catch (err) {
-                    this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, ERR_GENERIC, getErrMsg(err)))
-                    resolve();
+                    this.devices.push(result);
                 }
-            })
+
+                // If no valid devices, nothing to do
+                if (this.devices.length === 0) return;
+
+                await this.#readAllDevicePoints();
+            } catch (err) {
+                this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, ERR_GENERIC, getErrMsg(err)));
+            } finally {
+                this.#updateProgress('completed');
+            }
         }
 
         async #readAllDevicePoints() {

package/common/job/global_queue_manager.js

@@ -72,7 +72,7 @@ module.exports = {
     getQueue() {
         if (!globalQueue) {
             stopping = false;
-            globalQueue = new CoalescedJobQueue(100, true, 5);
+            globalQueue = new CoalescedJobQueue(50, true, 5);
         }
 
         if (!globalQueue.isRunning && !stopping) {

package/common/job/read_point.js

@@ -39,28 +39,18 @@ module.exports = {
         }
 
         async execute() {
-            this.#updateProgress(0)
-
-            return new Promise((resolve) => {
-                try {
-                    if (!this.#validateData()) {
-                        this.#updateProgress(100)
-                        resolve()
-                        return
-                    }
-
-                    this.#updateProgress(10)
-
-                    this.#readPoints().then(() => {
-                        this.#exportPoints();
-                        this.#updateProgress(100)
-                        resolve();
-                    });
-                } catch (err) {
-                    this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, ERR_GENERIC, getErrMsg(err)))
-                    resolve();
-                }
-            })
+            this.#updateProgress(0);
+            try {
+                if (!this.#validateData()) return;
+
+                this.#updateProgress(10);
+                await this.#readPoints();
+                this.#exportPoints();
+            } catch (err) {
+                this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, ERR_GENERIC, getErrMsg(err)));
+            } finally {
+                this.#updateProgress(100);
+            }
         }
 
         #validateData() {
@@ -284,8 +274,9 @@ module.exports = {
                 }
 
                 // add to result
+                const num = typeof value === 'number' ? value : null;
                 this.pointsList[`${p.deviceName}${this.devicePointSeparator}${p.pointName}`] = {
-                    value: facetObj.precision != null ? +value.toFixed(facetObj.precision) : value,
+                    value: (num != null && facetObj.precision != null) ? +value.toFixed(facetObj.precision) : value,
                     fvalue: fvalue,
                 }
                 if (err)

package/common/job/write_point.js

@@ -43,27 +43,17 @@ module.exports = {
         }
 
         async execute() {
-            this.#updateProgress(0)
-
-            return new Promise((resolve) => {
-                try {
-                    if (!this.#validateData()) {
-                        this.#updateProgress(100)
-                        resolve()
-                        return
-                    }
-
-                    this.#updateProgress(10)
-
-                    this.#writePoints().then(() => {
-                        this.#updateProgress(100)
-                        resolve();
-                    });
-                } catch (err) {
-                    this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, ERR_GENERIC, getErrMsg(err)))
-                    resolve();
-                }
-            })
+            this.#updateProgress(0);
+            try {
+                if (!this.#validateData()) return;
+
+                this.#updateProgress(10);
+                await this.#writePoints();
+            } catch (err) {
+                this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, ERR_GENERIC, getErrMsg(err)));
+            } finally {
+                this.#updateProgress(100);
+            }
         }
 
         #validateData() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halsystems/red-bacnet",
-  "version": "2.2.0",
+  "version": "2.2.2-alpha.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"

package/red-bacnet/discover_device.js

@@ -9,7 +9,7 @@ const { DiscoverDeviceJob } = require('@root/common/job/discover_device.js')
 const { getQueue } = require('@root/common/job/global_queue_manager.js')
 const { generateUniqueJobId } = require('@root/common/func.js')
 const {
-    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT, EVENT_CLOSE
+    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT
 } = require('@root/common/core/constant.js')
 
 
@@ -37,18 +37,6 @@ module.exports = function (RED) {
 
             // configure job queue - use global queue
             this.job = getQueue();
-
-            // init task
-            this.task = new DiscoverDeviceJob(
-                this.client,
-                this.#eventEmitter,
-                null,
-                this.network,
-                this.lowLimit,
-                this.highLimit,
-                this.whoIsTimeout,
-            );
-            this.task.onStart();
         }
 
         #subscribeListeners() {
@@ -57,11 +45,6 @@ module.exports = function (RED) {
             */
             // @ts-ignore
             this.on(EVENT_INPUT, async function (msg) {
-                /*
-                BACnet iAm handler is causing memory leak due to unable to detach after use
-                as a result, workaround is introduce before strategy to reuse discoverDeviceJob instead
-                of creating new one every time onInput is triggered
-                */
                 const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : this.jobId;
 
                 if (this.job.queue.map(item => item.id).includes(jobId)) {
@@ -70,14 +53,19 @@ module.exports = function (RED) {
                     return;
                 }
 
-                this.task.network = (msg.network === undefined) ? this.network : msg.network;
-                this.task.lowLimit = (msg.lowLimit === undefined) ? this.lowLimit : msg.lowLimit;
-                this.task.highLimit = (msg.highLimit === undefined) ? this.highLimit : msg.highLimit;
-                this.task.msg = msg;
+                const task = new DiscoverDeviceJob(
+                    this.client,
+                    this.#eventEmitter,
+                    msg,
+                    this.network,
+                    this.lowLimit,
+                    this.highLimit,
+                    this.whoIsTimeout,
+                );
 
                 this.job.addJob({
                     id: jobId,
-                    task: this.task,
+                    task: task,
                     priority: Number.isFinite(msg.priority) ? msg.priority : 5,
                 });
 
@@ -85,11 +73,6 @@ module.exports = function (RED) {
                 this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
             });
 
-            // @ts-ignore
-            this.on(EVENT_CLOSE, () => {
-                this.task.onStop();
-            })
-
             this.#eventEmitter.on(EVENT_OUTPUT, (msg) => {
                 // @ts-ignore
                 this.send(msg);