node-red-contrib-knx-ultimate 3.1.9 → 3.2.0

package/CHANGELOG.md

@@ -6,6 +6,10 @@
 
 # CHANGELOG
 
+**Version 3.2.0** - September 2024<br/>
+- Major Version.<br/>
+- HUE engine: implemented a new "limiter" package for better calculate the maximum numbers of telegrams accepted by HUE Bridge.<br/>
+
 **Version 3.1.9** - September 2024<br/>
 - HUE Bridge: you can now register to a bridge with your own credentials.<br/>
 - HUE Bridge: you can reveal the encrypted bridge's credentials (there is a button for that).<br/>

package/http2Testing/myhttp2.js

@@ -0,0 +1,103 @@
+
+
+const http2 = require('node:http2');
+//import http2, { ClientHttp2Session, IncomingHttpHeaders, IncomingHttpStatusHeader } from "http2";
+
+class Http2Client {
+    /**
+    * Parameters.
+    *
+    * @param config.key the credentualskey.
+    * @param config.url the bridge's URL
+    * @param config.path the resource url
+    * @param options the standard http2 options
+    */
+    constructor(config, options) {
+        options.rejectUnauthorized = false;
+        options.headers = {
+            'hue-application-key': config.key,
+        };
+        this.bridgeKey = config.key;
+        this.http2Connection = http2.connect(config.url, options);
+        this.http2Connection.on('error', (err) => {
+            console.error(err);
+            this.http2Connection.close();
+        });
+    }
+
+    async get(path, headers) {
+        await this.executeRequest({ ":method": "GET", ':path': path, ...headers });
+    }
+
+
+    async put(path, headers, body) {
+        await this.executeRequest({ ":method": "PUT", ':path': path, ...headers }, body);
+    }
+
+    async post(path, headers, body) {
+        await this.executeRequest({ ":method": "POST", ':path': path, ...headers }, body);
+    }
+
+    async delete(path, headers) {
+        await this.executeRequest({ ":method": "DELETE", ':path': path, ...headers });
+    }
+
+    executeRequest(headers, body) {
+        headers['headers'] = {
+            'hue-application-key': this.bridgeKey
+        };
+        return new Promise((resolve, reject) => {
+            const stream = this.http2Connection.request(headers);
+            if (body !== undefined) {
+                stream.write(JSON.stringify(body), 'utf8');
+            }
+
+            stream.setEncoding('utf8');
+            let response = {
+                headers: {},
+                data: ""
+            }
+            stream.on('response', (responseHeaders) => {
+                response.headers = responseHeaders;
+            });
+
+            stream.on('data', (chunk) => {
+                response.data += chunk;
+            });
+
+            stream.on('end', () => {
+                stream.close();
+                resolve(response.data);
+            });
+
+            stream.on('error', (e) => {
+                reject(e);
+            });
+
+            stream.end();
+        });
+    }
+
+
+    createEventSource(path, headers, onData, onClose) {
+        const stream = this.http2Connection.request({ ":method": "GET", ':path': path, "Accept": "text/event-stream", ...headers });
+        stream.setEncoding('utf8');
+
+        // Each data event will contain a single event from the Hue bridge.
+        stream.on('data', (data) => {
+            onData(data);
+        });
+        stream.on('end', () => {
+            stream.close();
+            onClose();
+        });
+        stream.on('error', (error) => {
+            console.error(error);
+            stream.close();
+            onClose(error);
+        });
+        stream.end();
+    }
+
+}
+module.exports = Http2Client

package/http2Testing/ratelimiter.js

@@ -0,0 +1,24 @@
+const { RateLimiter } = require('limiter');
+// Configura il rate limiter
+const limiter = new RateLimiter({ tokensPerInterval: 1, interval: 150 });
+
+console.log("Parto");
+async function Vai(params) {
+    do {
+
+        // Verifica se è possibile eseguire una nuova richiesta
+        const remainingRequests = await limiter.removeTokens(1);
+        if (remainingRequests >= 0) {
+            // Richiesta consentita
+            console.log("Messaggio. remainingRequests=" + remainingRequests + " " + new Date().toTimeString());
+        } else {
+            // Limite superato
+            console.log("HO DETTO SPETA. remainingRequests=" + remainingRequests + " " + new Date().toTimeString());
+        }
+
+    } while (true);
+}
+Vai();
+console.log("Fine");
+
+

package/http2Testing/ratelimitertestbed.js

@@ -0,0 +1,7 @@
+const RateLimiter = require("./ratelimiter");
+
+async function ba(params) {
+    await RateLimiter.sendMessage()
+}
+
+ba;

package/http2Testing/testbed.js

@@ -0,0 +1,36 @@
+const Http2Client = require('./myhttp2');
+const bridgeIp = '192.168.1.36';
+const bridgeUsername = '';
+const Clientkey = '';
+const ca = ``; // Certificato https://developers.meethue.com/develop/application-design-guidance/using-https/
+
+const http2Client = new Http2Client(
+    {
+        url: `https://${bridgeIp}`,
+        key: bridgeUsername
+    },
+    {
+
+        // ca: ca,
+        // checkServerIdentity: function (hostname, cert) {
+        //     if (cert.subject.CN === this.bridge.getId().toLowerCase()) {
+        //         console.log("Successful server identity check!");
+        //         return undefined;
+        //     } else {
+        //         return new Error("Server identity check failed. CN does not match bridgeId.");
+        //     }
+        // },
+    });
+
+console.log(http2Client.get(`https://${bridgeIp}/clip/v2/resource/device`));
+
+// async (params) => {
+//     await http2Client.createEventSource(
+//         "/eventstream/clip/v2",
+//         { "hue-application-key": bridgeUsername },
+//         (data) => { console.log(data); },
+//         (error) => { console.log(`Event source closed! ${error}`); }
+//     );
+// }
+
+

package/nodes/utils/http.js

@@ -1,10 +1,13 @@
-/**
- * Promise wrapper around simple get. 
- * Modified code based on: https://github.com/rodney42/node-hue/blob/main/lib/http.js
- * Thank you rodney42
- */
+
 const simpleget = require('simple-get');
 
+/**
+* Parameters.
+*
+* @param config.key the credentualskey.
+* @param config.prefix the bridge's URL
+* @param config.url the resource url
+*/
 module.exports.use = (config) => {
     let http = {};
 
@@ -24,6 +27,7 @@ module.exports.use = (config) => {
             simpleget.concat(opt, (err, res, data) => {
                 try {
                     if (err) {
+                        RED.log.error(`utils.https: config.http.call: simpleget.concat ${err.message} : ${err.stack || ""} `);
                         reject(err);
                     } else {
                         // log.trace('http data ' + data);
@@ -31,6 +35,7 @@ module.exports.use = (config) => {
                             try {
                                 let result = JSON.parse(data);
                                 if (result.errors && result.errors.length > 0) {
+                                    //console.log("\x1b[41m OrroreUno \x1b[0m result.errors ", result.errors, " " + new Date().toTimeString(), this.commandQueue.length, "remainingRequests " + remainingRequests);
                                     reject(new Error("The response for " + opt.url + " returned errors " + JSON.stringify(result.errors)));
                                 }
                                 if (!result.data) {
@@ -41,6 +46,7 @@ module.exports.use = (config) => {
                                 RED.log.error(`utils.https: config.http.call: let result = JSON.parse(data); =: ${error.message} : ${error.stack || ""} `);
                             }
                         } else {
+                            RED.log.error(`utils.https: config.http.call: simpleget.concat: Error response: status code: ${res.statusCode || undefined}`);
                             reject(new Error("Error response for " + opt.url + " with status " + res.statusCode + " " + res.statusMessage));
                         }
                     }

package/nodes/utils/hueEngine.js

@@ -2,7 +2,11 @@
 const { EventEmitter } = require("events");
 const EventSource = require("eventsource");
 const http = require("./http");
-const pleaseWait = t => new Promise((resolve, reject) => setTimeout(resolve, t))
+// const pleaseWait = t => new Promise((resolve, reject) => setTimeout(resolve, t))
+const { RateLimiter } = require('limiter');
+//const { forEach } = require("lodash");
+// Configura il rate limiter
+const limiter = new RateLimiter({ tokensPerInterval: 1, interval: 150 }); // HUE telegram interval
 
 class classHUE extends EventEmitter {
 
@@ -108,12 +112,10 @@ class classHUE extends EventEmitter {
     }, 10 * (60 * 1000)); // 10 minutes
   };
 
-  // Handle the send queue
-  // ######################################
-  handleQueue = async () => {
-    if (this.commandQueue.length > 0) {
-      // const jRet = { ...this.commandQueue.shift() } //Clone the object by value
-      const jRet = this.commandQueue.shift();
+  // Process single item in the queue
+  processQueueItem = async () => {
+    try {
+      const jRet = this.commandQueue.pop();
       // jRet is ({ _lightID, _state, _operation });;
       switch (jRet._operation) {
         case "setLight":
@@ -153,8 +155,7 @@ class classHUE extends EventEmitter {
               this.writeHueQueueAdd(light.rid, jRet._state, "setLight");
             });
           } catch (error) {
-            if (this.sysLogger !== undefined && this.sysLogger !== null)
-              this.sysLogger.error(`KNXUltimatehueEngine: classHUE: handleQueue: stopScene: ${error.message}`);
+            if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error(`KNXUltimatehueEngine: classHUE: handleQueue: stopScene: ${error.message}`);
           }
           break;
         case "Ping":
@@ -170,10 +171,29 @@ class classHUE extends EventEmitter {
         default:
           break;
       }
+    } catch (error) {
+      if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error(`KNXUltimatehueEngine: classHUE: processQueueItem: ${error.trace}`);
     }
-    // The Hue bridge allows about 10 telegram per second, so i need to make a queue manager
-    await pleaseWait(150); // Waits
-    if (this.closePushEventStream === false) this.handleQueue();
+  };
+
+  // // Handle the send queue
+  // // ######################################
+  handleQueue = async () => {
+    // Verifica se è possibile eseguire una nuova richiesta
+    do {
+      const remainingRequests = await limiter.removeTokens(1);
+      if (this.commandQueue.length > 0) {
+        //if (remainingRequests >= 0) {
+        // OK, i can send
+        //console.log("\x1b[32m Messaggio. remainingRequests=" + remainingRequests + "\x1b[0m " + new Date().toTimeString(), this.commandQueue.length, "remainingRequests " + remainingRequests);
+        await this.processQueueItem();
+        //} else {
+        // Limit reached, skip this round.
+        //console.log("\x1b[41m HO DETTO SPETA. remainingRequests=" + remainingRequests + "\x1b[0m " + new Date().toTimeString(), this.commandQueue.length, "remainingRequests " + remainingRequests);
+        //}
+      }
+    } while (this.closePushEventStream === false);
+    //console.log("\x1b[42m End processing commandQueue \x1b[0m " + new Date().toTimeString(), this.commandQueue.length);
   };
 
   writeHueQueueAdd = async (_lightID, _state, _operation) => {

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=16.0.0"
   },
-  "version": "3.1.9",
+  "version": "3.2.0",
   "description": "Control your KNX intallation via Node-Red! A bunch of KNX nodes, with integrated Philips HUE control and ETS group address importer. Easy to use and highly configurable.",
   "dependencies": {
     "binary-parser": "2.2.1",
@@ -12,6 +12,7 @@
     "eventsource": "2.0.2",
     "js-yaml": "4.1.0",
     "knxultimate": ">=2.3.5",
+    "limiter": "^2.1.0",
     "lodash": "4.17.21",
     "log-driver": "1.2.7",
     "mkdirp": "3.0.1",