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

package/CHANGELOG.md

@@ -1,9 +1,17 @@
 # Changelog
 
+## [2.2.0]
+### Changed
+- `ConcurrentTask` changed to `ConcorrentTasksWithNetworkAwareness` round robin distributing task according to IP address to reduce congestion on a particular network
+
+## [2.1.1]
+### Changed
+- Reinstated `globalBroadcastAddress` filter in transport
+
 ## [2.1.0]
 ### Changed
 - Matched v2.1.0-alpha.0 release
-- Removed `broadcastAddress` filter list from transport
+- Removed `globalBroadcastAddress` filter from transport
 
 ## [2.1.0-alpha.0]
 ### Added

package/common/core/concurrent.js

@@ -54,4 +54,112 @@ module.exports = {
         await Promise.allSettled(executing);
         return results;
     },
-};
+
+    /**
+     * Executes a list of tasks concurrently with IP address awareness.
+     * Tasks targeting the same IP address will execute sequentially.
+     * Tasks targeting different IP addresses can execute in parallel.
+     *
+     * @param {EventEmitter} eventEmitter - The event emitter to emit events to.
+     * @param {Array} tasks - The list of tasks to execute. Each task should have:
+     *                        { id, device: { ipAddress, ... }, task: async () => {...} }
+     * @param {number} maxConcurrent - The maximum number of concurrent tasks.
+     * @param {number} concurrentTaskDelay - The delay between concurrent tasks.
+     * @returns {Promise<Array>} - A promise that resolves with an array of results.
+     * @async
+    */
+    concurrentTasksWithNetworkAwareness: async function (
+        eventEmitter, tasks, maxConcurrent, concurrentTaskDelay = 50
+    ) {
+        const executing = new Set();
+        const results = [];
+        const ipAddressInUse = new Set(); // Track which IPs are currently executing
+
+        // Pending tasks that have not been started yet.
+        // We keep them in a list and remove them once scheduled so that a
+        // task blocked by a busy IP never blocks later tasks with free IPs.
+        const pending = tasks.map(({ id, device, task }) => ({
+            id,
+            task,
+            // Extract IP address from device (handle "ip:port" format)
+            ipAddress: device?.ipAddress ? device.ipAddress.split(':')[0] : null,
+        }));
+
+        /**
+         * Start a single task and wire up its lifecycle. When the task settles
+         * it releases its IP so waiting tasks targeting the same IP can run.
+         *
+         * @param {{id: any, task: Function, ipAddress: string|null}} item
+         */
+        const startTask = (item) => {
+            const { id, task, ipAddress } = item;
+            if (ipAddress) ipAddressInUse.add(ipAddress);
+
+            const promise = task()
+                .then(result => {
+                    eventEmitter.emit(EVENT_OUTPUT, { id, result });
+                    results.push({ id, result });
+                })
+                .catch(error => {
+                    eventEmitter.emit(EVENT_ERROR, { id, error });
+                    results.push({ id, error });
+                })
+                .finally(() => {
+                    executing.delete(promise);
+                    // Release the IP address so waiting tasks can run
+                    if (ipAddress) ipAddressInUse.delete(ipAddress);
+                });
+
+            executing.add(promise);
+        };
+
+        /**
+         * Schedule as many pending tasks as possible, respecting both the
+         * global concurrency limit and per-IP exclusivity. Scans the whole
+         * pending list (not just the head) so a busy IP does not block later
+         * tasks targeting free IPs.
+         *
+         * @async
+         */
+        const scheduleAvailable = async () => {
+            let i = 0;
+            while (i < pending.length && executing.size < maxConcurrent) {
+                const candidate = pending[i];
+
+                // Skip (leave in queue) if this IP is currently in use
+                if (candidate.ipAddress && ipAddressInUse.has(candidate.ipAddress)) {
+                    i++;
+                    continue;
+                }
+
+                // Remove from pending and start it
+                pending.splice(i, 1);
+                startTask(candidate);
+
+                if (concurrentTaskDelay > 0)
+                    await delay(concurrentTaskDelay);
+            }
+        };
+
+        // Keep pumping until every task has been scheduled and finished.
+        // Each loop: schedule what we can, then wait for at least one task to
+        // settle (which frees a concurrency slot and/or an IP) before retrying.
+        while (pending.length > 0 || executing.size > 0) {
+            await scheduleAvailable();
+
+            if (executing.size > 0) {
+                // Wait for one in-flight task to settle before scheduling more.
+                await Promise.race(executing);
+            } else if (pending.length > 0) {
+                // Nothing running but tasks remain (all were blocked by busy
+                // IPs that just got released). Yield briefly and retry.
+                /* istanbul ignore next */
+                await delay(concurrentTaskDelay > 0 ? concurrentTaskDelay : 1);
+            }
+        }
+
+        // Safety net: ensure all promises have fully settled.
+        await Promise.allSettled(executing);
+        return results;
+    },
+};

package/common/job/discover_point.js

@@ -13,7 +13,7 @@ const { readObjectList, smartReadProperty } = require('@root/common/bacnet.js')
 const { bacnetUnitMap } = require('@root/common/bacnet_unit.js')
 const { EG_BACNET_DEVICES } = require('@root/common/example')
 const { errMsg, getErrMsg } = require('@root/common/func.js')
-const { concurrentTasks } = require('@root/common/core/concurrent.js')
+const { concurrentTasksWithNetworkAwareness } = require('@root/common/core/concurrent.js')
 const {
     ERR_GENERIC, ERR_SCHEMA_VALIDATION, ERR_INVALID_DATA_TYPE, ERR_IGNORE_DUPLICATED_DEVICE_NAME,
     ERR_READING_POINTS,
@@ -170,6 +170,7 @@ module.exports = {
 
             const tasks = this.devices.map((d, i) => ({
                 id: d.deviceName,
+                device: d,
                 task: async () => {
                     void i
                     try {
@@ -213,7 +214,7 @@ module.exports = {
                 }
             }));
 
-            await concurrentTasks(discoverPointEvent, tasks, this.maxConcurrentDeviceRead);
+            await concurrentTasksWithNetworkAwareness(discoverPointEvent, tasks, this.maxConcurrentDeviceRead);
         }
 
         #updateProgress(progress) {

package/common/job/read_point.js

@@ -9,7 +9,7 @@ const { EVENT_OUTPUT, EVENT_UPDATE_STATUS, EVENT_ERROR } = require('@root/common
 const { smartReadProperty } = require('@root/common/bacnet.js')
 const { EG_BACNET_DEVICES, EG_BACNET_POINTS } = require('@root/common/example')
 const { facetsStrToObj, errMsg, getErrMsg } = require('@root/common/func.js')
-const { concurrentTasks } = require('@root/common/core/concurrent.js')
+const { concurrentTasksWithNetworkAwareness } = require('@root/common/core/concurrent.js')
 const {
     ERR_GENERIC, ERR_SCHEMA_VALIDATION, ERR_INVALID_DATA_TYPE, ERR_DUPLICATED_DEVICE_NAME,
     ERR_DUPLICATED_POINT_ID, ERR_POINT_NOT_ATTACHED_TO_DEVICE, ERR_READING_POINT
@@ -231,6 +231,7 @@ module.exports = {
                 .filter(([_, v]) => Array.isArray(v.points) && v.points.length > 0)  // eslint-disable-line
                 .map(([k, v]) => ({
                     id: k,
+                    device: v.device,
                     task: async () => {
                         return await smartReadProperty(
                             this.client, v.device, v.points, this.readMethod,
@@ -239,7 +240,7 @@ module.exports = {
                     }
                 }));
 
-            await concurrentTasks(smartReadEvent, tasks, this.maxConcurrentDeviceRead);
+            await concurrentTasksWithNetworkAwareness(smartReadEvent, tasks, this.maxConcurrentDeviceRead);
 
             // format final result
             this.points.forEach(p => {

package/common/job/write_point.js

@@ -9,7 +9,7 @@ const { EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_OUTPUT } = require('@root/common
 const { smartWriteProperty } = require('@root/common/bacnet.js')
 const { EG_BACNET_DEVICES, EG_BACNET_POINTS, EG_BACNET_WRITE_POINTS } = require('@root/common/example')
 const { errMsg, getErrMsg } = require('@root/common/func.js')
-const { concurrentTasks } = require('@root/common/core/concurrent.js')
+const { concurrentTasksWithNetworkAwareness } = require('@root/common/core/concurrent.js')
 const {
     ERR_GENERIC, ERR_SCHEMA_VALIDATION, ERR_INVALID_DATA_TYPE, ERR_DUPLICATED_DEVICE_NAME,
     ERR_DUPLICATED_POINT_ID, ERR_POINT_NOT_ATTACHED_TO_DEVICE, ERR_WRITE_POINT_NOT_FOUND,
@@ -286,6 +286,7 @@ module.exports = {
                 .filter(([_, v]) => (void _, Object.keys(v.writePoints).length > 0))
                 .map(([k, v]) => ({
                     id: k,
+                    device: v.device,
                     task: async () => {
                         return await smartWriteProperty(
                             this.client, v.device, v.writePoints, smartWriteEvent,
@@ -310,7 +311,7 @@ module.exports = {
                 ));
             });
 
-            await concurrentTasks(smartWriteEvent, tasks, this.maxConcurrentDeviceWrite);
+            await concurrentTasksWithNetworkAwareness(smartWriteEvent, tasks, this.maxConcurrentDeviceWrite);
         }
 
     }

package/ext/node-bacstack/dist/lib/transport.js

@@ -4,6 +4,7 @@ exports.Transport = void 0;
 const dgram_1 = require("dgram");
 const events_1 = require("events");
 const DEFAULT_BACNET_PORT = 47808;
+const GLOBAL_BROADCAST_ADDRESS = "255.255.255.255";
 const UDP_TYPE = "udp4";
 
 // HAL modified
@@ -23,6 +24,7 @@ class Transport extends events_1.EventEmitter {
 
         if (
             this._settings.broadcastAddress &&
+            this._settings.broadcastAddress !== GLOBAL_BROADCAST_ADDRESS &&
             this._settings.broadcastAddress !== this._settings.interface
         ) {
             this._broadcastServer = (0, dgram_1.createSocket)({

package/package.json

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