node-red-contrib-ccu 4.2.0 → 4.4.0

package/nodes/lib/dynconfig.js

@@ -0,0 +1,81 @@
+/* Per-message dynamic node configuration (B-2, issues #172 #71 #103 #80
+   #56 #148 #133).
+
+   Two mechanisms, in increasing precedence:
+
+   1. Flat properties (`msg.channel`, `msg.rooms`, ...). Long-standing
+      behaviour of ccu-set-value/ccu-value/ccu-get-value: they fill in
+      configuration the node itself leaves empty. Kept as-is because
+      messages coming straight from an event node carry exactly these
+      names, which is what makes it convenient - and, for the same
+      reason, only ever used for the nodes that already did it.
+   2. `msg.config`, an object of overrides. Always wins, works for every
+      configurable field including lists, and cannot collide with the
+      properties an event message carries (`msg.ccu` is the CCU host, so
+      it is not available as a namespace). This is what makes the
+      settings of the signal/display/switch/sysvar nodes reachable from
+      a flow.
+
+   The old inline implementation in ccu-set-value wrote message
+   properties into the node's own `config` object, so only the *first*
+   message ever configured the node: every later message hit the
+   `if (!config[key])` guard and was ignored (#133). Nothing here mutates
+   the stored configuration. */
+
+/**
+ * Build the effective configuration for one message.
+ *
+ * @param {object} config the node's stored configuration (never mutated)
+ * @param {object} message the incoming message
+ * @param {string[]} keys the keys that may be overridden; anything else
+ *        in `msg.config` is ignored, so a stray property cannot reach
+ *        node internals
+ * @param {object} [options]
+ * @param {boolean} [options.flat=false] also fill empty keys from
+ *        top-level message properties (mechanism 1)
+ * @returns {{config: object, dynamic: boolean}} effective config plus
+ *          whether anything actually came from the message
+ */
+function effectiveConfig(config, message, keys, options) {
+    const effective = {...config};
+    let dynamic = false;
+
+    if (!message || typeof message !== 'object') {
+        return {config: effective, dynamic};
+    }
+
+    if (options && options.flat) {
+        keys.forEach((key) => {
+            if (!effective[key] && key in message) {
+                effective[key] = message[key];
+                dynamic = true;
+            }
+        });
+    }
+
+    const overrides = message.config;
+    if (overrides && typeof overrides === 'object' && !Array.isArray(overrides)) {
+        keys.forEach((key) => {
+            if (key in overrides) {
+                effective[key] = overrides[key];
+                dynamic = true;
+            }
+        });
+    }
+
+    return {config: effective, dynamic};
+}
+
+/**
+ * A stable identity for a set of configuration keys, used to decide
+ * whether a cache derived from them is still valid. Two effective configs
+ * that produce the same key select the same devices/datapoints.
+ * @param {object} config
+ * @param {string[]} keys
+ * @returns {string}
+ */
+function configCacheKey(config, keys) {
+    return keys.map((key) => JSON.stringify(config[key] === undefined ? null : config[key])).join(' ');
+}
+
+module.exports = {effectiveConfig, configCacheKey};

package/nodes/lib/localccu.js

@@ -0,0 +1,81 @@
+/* Detecting "Node-RED runs on the CCU itself" (B-4).
+
+   When it does, the interface processes can be reached directly on their
+   3xxxx ports (BINRPC where available) instead of going through the CCU's
+   lighttpd proxy on 1999/2000/2001/2010/9292 - fewer hops, and BINRPC
+   instead of XML-RPC for BidCos.
+
+   The old test grepped /etc/lighttpd/conf.d/proxy.conf for
+   `"port" => 32001`. On current firmware that file is a one-line
+   `include "/var/etc/lighttpd_proxy.conf"`, which itself only includes
+   proxy_normal.conf - the port markers are two levels down, so the regex
+   has not matched since (verified on CCU3 firmware 3.89.8, where 31999,
+   32001, 32010 and 39292 are all listening while proxy.conf says nothing
+   about them). Every local install has silently been running through the
+   proxy.
+
+   Rather than chasing lighttpd's include chain, ask the kernel: a
+   listener on the direct port is exactly the condition that makes using
+   it correct. /proc/net/tcp is a plain file, so this stays synchronous -
+   the interface table is built in the connection node's constructor. */
+
+const fs = require('fs');
+
+/** rfd's direct BINRPC port on firmware >= 3.41; the marker for "on the CCU". */
+const LOCAL_PROBE_PORTS = [32001, 31999];
+
+const PROC_NET_TCP = ['/proc/net/tcp', '/proc/net/tcp6'];
+
+/** /proc/net/tcp connection state 0A = TCP_LISTEN. */
+const TCP_LISTEN = '0A';
+
+/**
+ * The TCP ports something is listening on, from /proc/net/tcp{,6}.
+ * @param {string[]} [files] override, for tests
+ * @returns {Set<number>} empty when /proc is unavailable (non-Linux)
+ */
+function listeningPorts(files) {
+    const ports = new Set();
+
+    (files || PROC_NET_TCP).forEach((file) => {
+        let content;
+        try {
+            content = fs.readFileSync(file, 'utf8');
+        } catch {
+            return;
+        }
+
+        content.split('\n').forEach((line) => {
+            // sl  local_address rem_address st ...
+            const columns = line.trim().split(/\s+/);
+            if (columns.length < 4 || columns[3] !== TCP_LISTEN) {
+                return;
+            }
+
+            const port = Number.parseInt(String(columns[1]).split(':')[1], 16);
+            if (Number.isInteger(port)) {
+                ports.add(port);
+            }
+        });
+    });
+
+    return ports;
+}
+
+/**
+ * Are we talking to a CCU we are running on, with the direct ports open?
+ * @param {string} host the configured CCU host
+ * @param {object} [options]
+ * @param {string[]} [options.files] /proc files to read, for tests
+ * @returns {boolean}
+ */
+function isLocalCcu(host, options) {
+    if (!host || !(String(host).startsWith('127.') || host === 'localhost' || host === '::1')) {
+        return false;
+    }
+
+    const ports = listeningPorts(options && options.files);
+    return LOCAL_PROBE_PORTS.some((port) => ports.has(port));
+}
+
+module.exports = {isLocalCcu, listeningPorts, LOCAL_PROBE_PORTS};

package/nodes/lib/message.js

@@ -18,6 +18,8 @@
  * @param {object} [additions] merged into the message (cache, working, uncertain, ts, lc, ...)
  * @returns {object} the message
  */
+const {enumList} = require('./cast.js');
+
 function createMessage(ccu, iface, channel, datapoint, payload, additions) {
     const datapointName = iface + '.' + channel + '.' + datapoint;
     if (!ccu.values[datapointName]) {
@@ -73,12 +75,14 @@ function createMessage(ccu, iface, channel, datapoint, payload, additions) {
         datapointType: description.TYPE,
         datapointMin: description.MIN,
         datapointMax: description.MAX,
-        datapointEnum: description.ENUM,
+        // the CCU sends the names in VALUE_LIST; reading description.ENUM
+        // meant both of these were always undefined (B-3, ROADMAP 8.2)
+        datapointEnum: enumList(description),
         datapointDefault: description.DEFAULT,
         datapointControl: description.CONTROL,
         value: payload,
         valuePrevious: ccu.values[datapointName].value,
-        valueEnum: description.ENUM ? description.ENUM[Number(payload)] : undefined,
+        valueEnum: enumList(description) ? enumList(description)[Number(payload)] : undefined,
         valueStable,
         rooms: ccu.channelRooms[channel] || [],
         room: