node-red-contrib-ccu 4.2.0 → 4.4.0

package/nodes/ccu-connection.js

@@ -9,10 +9,12 @@ const {castValue, castSysvar} = require('./lib/cast.js');
 const {combinedParameterValue} = require('./lib/combined.js');
 const {createMessage} = require('./lib/message.js');
 const {topicReplace} = require('./lib/topic.js');
+const {isLocalCcu} = require('./lib/localccu.js');
 const {bestMatch} = require('./lib/similarity.js');
 const nextport = require('./lib/nextport.js');
 const hmDiscover = require('./lib/discover.js');
 const {Rega} = require('homematic-rega'); // ES module - require(esm) needs Node >= 20.19 / >= 22.12
+const metaProvider = require('./lib/metaprovider.js');
 const xmlrpc = require('homematic-xmlrpc');
 const binrpc = require('binrpc');
 
@@ -407,15 +409,13 @@ module.exports = function (RED) {
 
             this.checkDuplicateConfig(config);
 
-            this.isLocal = false;
-            if (config.host.startsWith('127.') || config.host === 'localhost') {
-                try {
-                    const rfdConf = fs.readFileSync('/etc/lighttpd/conf.d/proxy.conf').toString();
-                    if (rfdConf.match(/"port"\s+=>\s+32001/)) {
-                        this.logger.info('local connection on ccu >= v3.41 detected');
-                        this.isLocal = true;
-                    }
-                } catch {}
+            // B-4: this used to grep /etc/lighttpd/conf.d/proxy.conf for the
+            // direct port. That file is a bare include on current firmware, so
+            // the check never matched and every local install went through the
+            // proxy. Ask the kernel for a listener instead.
+            this.isLocal = isLocalCcu(config.host);
+            if (this.isLocal) {
+                this.logger.info('local connection on ccu >= v3.41 detected');
             }
 
             this.ifaceTypes = {
@@ -529,6 +529,10 @@ module.exports = function (RED) {
             this.rpcBinPort = Number.parseInt(config.rpcBinPort, 10);
             this.rpcXmlPort = Number.parseInt(config.rpcXmlPort, 10);
             this.rpcPingTimeout = Number.parseInt(config.rpcPingTimeout, 10) || 60;
+            // #44: opt out of the periodic ping/timeout supervision. Off means
+            // no pings and no timeout-triggered re-init for this connection -
+            // reconnecting after a CCU restart is then up to the CCU.
+            this.rpcPingEnabled = config.rpcPing === undefined ? true : Boolean(config.rpcPing);
             this.rpcPingTimer = {};
             this.ifaceStatus = {};
             this.serverError = {};
@@ -539,6 +543,19 @@ module.exports = function (RED) {
 
             this.regaEnabled = config.regaEnabled;
             this.regaPollEnabled = config.regaPoll;
+            // B-17 openccu-lite: the metadata api sits behind the box's
+            // lighttpd, i.e. on the plain http(s) port. The field exists for
+            // reverse proxies and tests, it is empty in every normal install.
+            this.tlsEnabled = Boolean(config.tls);
+            this.inSecure = Boolean(config.inSecure);
+            this.metaPort = Number.parseInt(config.metaPort, 10) || (config.tls ? 443 : 80);
+            this.metaToken = config.metaToken || metaProvider.readLocalToken();
+            this.metaMode = false;
+            this.meta = null;
+            // #167: minutes between re-reads of channel names, rooms and
+            // functions. 0 switches it off.
+            this.regaMetaInterval =
+                config.regaMetaInterval === undefined ? 15 : Number.parseInt(config.regaMetaInterval, 10) || 0;
             this.regaInterval = Number.parseInt(config.regaInterval, 10);
             this.hadTimeout = new Set();
 
@@ -632,10 +649,27 @@ module.exports = function (RED) {
             });
 
             if (config.regaEnabled) {
-                this.getRegaData().then(() => {
-                    this.regaPoll();
-                    this.initIfaces(config);
-                });
+                this.lastRegaDataRefresh = now();
+                // B-17: ask the box once whether it speaks the openccu-lite
+                // metadata api. It does not on a CCU/RaspberryMatic/OpenCCU,
+                // where everything below runs exactly as before.
+                this.lastMetaProbe = now();
+                this.detectMeta()
+                    .then((info) => {
+                        if (info) {
+                            return this.startMeta(info);
+                        }
+
+                        return this.getRegaData().then(() => {
+                            this.regaPoll();
+                        });
+                    })
+                    .catch((error) => {
+                        this.logger.error('name sync ' + error.message);
+                    })
+                    .then(() => {
+                        this.initIfaces(config);
+                    });
             } else {
                 this.initIfaces(config);
             }
@@ -814,6 +848,8 @@ module.exports = function (RED) {
                         regaChannels: this.regaChannels,
                         channelRooms: this.channelRooms,
                         channelFunctions: this.channelFunctions,
+                        rooms: this.rooms,
+                        functions: this.functions,
                         groups: this.groups,
                         sysvar: this.sysvar,
                         program: this.program,
@@ -877,6 +913,16 @@ module.exports = function (RED) {
                     this.channelRooms = regadata.channelRooms;
                     this.channelFunctions = regadata.channelFunctions;
                     this.groups = regadata.groups;
+                    // written since 4.4.0 - the editor's room/function pickers
+                    // were empty until the first successful sync before that
+                    if (Array.isArray(regadata.rooms)) {
+                        this.rooms = regadata.rooms;
+                    }
+
+                    if (Array.isArray(regadata.functions)) {
+                        this.functions = regadata.functions;
+                    }
+
                     /*
                     this.sysvar = regadata.sysvar;
                     Object.keys(this.sysvar).forEach(s => {
@@ -986,6 +1032,12 @@ module.exports = function (RED) {
             this.cancelRegaPoll = true;
             clearTimeout(this.regaPollTimeout);
 
+            if (this.meta) {
+                this.logger.debug('stop metadata event stream');
+                this.meta.stop();
+                this.meta = null;
+            }
+
             Object.keys(this.rpcPingTimer).forEach((iface) => {
                 this.logger.debug('clear rpcPingTimer', iface);
                 clearTimeout(this.rpcPingTimer[iface]);
@@ -1065,7 +1117,165 @@ module.exports = function (RED) {
                 .then(() => this.getRegaFunctions())
                 .then(() => this.getRegaValues())
                 .then(() => this.getGroupsData())
-                .catch(this.logger.error);
+                .catch((error) => {
+                    this.logger.error(error);
+                    this.recheckMeta();
+                });
+        }
+
+        /**
+         * B-17: is this box an openccu-lite? `GET /api/meta/v1/version` needs
+         * no credential and answers only there - a CCU replies 404 or HTML.
+         * Never rejects; an unreachable box is simply "no".
+         * @returns {Promise<object|null>}
+         */
+        detectMeta() {
+            return metaProvider.detect({
+                host: this.host,
+                port: this.metaPort,
+                tls: Boolean(this.tlsEnabled),
+                insecure: Boolean(this.inSecure),
+                logger: this.logger,
+            });
+        }
+
+        /**
+         * Take names, rooms and functions from the openccu-lite metadata api
+         * instead of from the ReGaHSS. Resolves as soon as the first snapshot
+         * has been applied (or after 5 s, so a missing credential does not hold
+         * up the interfaces).
+         * @param {object} info the /version document
+         * @returns {Promise<any>}
+         */
+        startMeta(info) {
+            this.metaMode = true;
+            this.lastMetaProbe = now();
+            clearTimeout(this.regaPollTimeout);
+            this.logger.info(
+                'openccu-lite detected (' +
+                    (info.implementation || 'meta api') +
+                    ', api version ' +
+                    info.version +
+                    ') - names, rooms and functions come from its metadata api',
+            );
+            this.logger.info(
+                'this box has no ReGaHSS: system variables, programs and HM-Script are not available (sysvar, program, poll and script nodes stay idle)',
+            );
+
+            if (info.version > 1) {
+                this.logger.warn(
+                    'the box speaks metadata api version ' +
+                        info.version +
+                        ', this version of node-red-contrib-ccu implements version 1',
+                );
+            }
+
+            if (!this.metaToken) {
+                this.logger.warn(
+                    'no metadata api token: create one on the box (Users page) and enter it in the connection node, or run on the box where ' +
+                        metaProvider.LOCAL_TOKEN_FILE +
+                        ' is readable. Without it the nodes work with addresses only.',
+                );
+            }
+
+            return new Promise((resolve) => {
+                const done = setTimeout(resolve, 5000);
+                this.meta = new metaProvider.MetaProvider({
+                    host: this.host,
+                    port: this.metaPort,
+                    tls: Boolean(this.tlsEnabled),
+                    insecure: Boolean(this.inSecure),
+                    token: this.metaToken,
+                    logger: this.logger,
+                    onNames: (names) => {
+                        this.applyMetaNames(names);
+                        clearTimeout(done);
+                        resolve();
+                    },
+                    onStatus: (connected) => {
+                        this.setIfaceStatus('ReGaHSS', connected);
+                    },
+                    onGone: () => {
+                        this.metaMode = false;
+                        this.meta = null;
+                        this.lastMetaProbe = 0;
+                        this.logger.warn('this box no longer answers as openccu-lite - detecting again');
+                        this.detectMeta().then((again) => {
+                            if (again) {
+                                return this.startMeta(again);
+                            }
+
+                            return this.getRegaData().then(() => this.regaPoll());
+                        });
+                    },
+                });
+                this.meta.start();
+            });
+        }
+
+        /**
+         * The metadata api's answer, in the shape the rest of the code expects
+         * from the ReGa: names by address, rooms and functions as arrays of
+         * names. Called for the snapshot and again for every change event.
+         * @param {object} names
+         */
+        applyMetaNames(names) {
+            this.channelNames = names.channelNames;
+            this.channelRooms = names.channelRooms;
+            this.channelFunctions = names.channelFunctions;
+            this.rooms = names.rooms;
+            this.functions = names.functions;
+            this.logger.debug(
+                'meta revision ' +
+                    names.revision +
+                    ': ' +
+                    Object.keys(names.channelNames).length +
+                    ' names, ' +
+                    names.rooms.length +
+                    ' rooms, ' +
+                    names.functions.length +
+                    ' functions',
+            );
+            this.saveRegadata();
+        }
+
+        /**
+         * The ReGa did not answer. Maybe this box became an openccu-lite (a
+         * restored backup, a firmware swap) - probe again, at most every five
+         * minutes, so a box that changes underneath a running Node-RED is
+         * picked up without a redeploy.
+         */
+        recheckMeta() {
+            if (this.metaMode || this.cancelRegaPoll || this.metaRecheckPending) {
+                return;
+            }
+
+            if (now() - (this.lastMetaProbe || 0) < 300000) {
+                return;
+            }
+
+            this.lastMetaProbe = now();
+            this.metaRecheckPending = true;
+            this.detectMeta()
+                .then((info) => {
+                    this.metaRecheckPending = false;
+                    if (info && !this.metaMode) {
+                        return this.startMeta(info);
+                    }
+                })
+                .catch(() => {
+                    this.metaRecheckPending = false;
+                });
+        }
+
+        /**
+         * The error a ReGa-only feature answers with on openccu-lite. The
+         * nodes stay in the palette and in the flow, every message gets this.
+         * @param {string} feature
+         * @returns {Error}
+         */
+        regaMissingError(feature) {
+            return new Error(feature + ' are not available on this box (openccu-lite has no ReGaHSS)');
         }
 
         /**
@@ -1084,7 +1294,14 @@ module.exports = function (RED) {
                             const ts = dp.ts;
                             const [iface, channel, datapoint] = dp.name.split('.');
                             if (this.enabledIfaces.includes(iface) && datapoint) {
-                                if (['RSSI_DEVICE', 'RSSI_PEER'].includes(datapoint)) {
+                                if (
+                                    ['RSSI_DEVICE', 'RSSI_PEER'].includes(datapoint) &&
+                                    typeof dp.value === 'number' &&
+                                    dp.value > 127
+                                ) {
+                                    // the ReGa reports the unsigned byte; without
+                                    // the guard an already-signed value or the 0
+                                    // for "never received" became -318 / -256 (#183)
                                     dp.value -= 256;
                                 }
 
@@ -1218,6 +1435,11 @@ module.exports = function (RED) {
          */
         programActive(name, active) {
             return new Promise((resolve, reject) => {
+                if (this.metaMode) {
+                    reject(this.regaMissingError('programs'));
+                    return;
+                }
+
                 const program = this.program[name];
                 if (program) {
                     const script = `dom.GetObject(${program.id}).Active(${active});`;
@@ -1245,6 +1467,11 @@ module.exports = function (RED) {
          */
         programExecute(name) {
             return new Promise((resolve, reject) => {
+                if (this.metaMode) {
+                    reject(this.regaMissingError('programs'));
+                    return;
+                }
+
                 const program = this.program[name];
                 if (program) {
                     const d = new Date();
@@ -1279,6 +1506,11 @@ module.exports = function (RED) {
          */
         setVariable(name, value) {
             return new Promise((resolve, reject) => {
+                if (this.metaMode) {
+                    reject(this.regaMissingError('system variables'));
+                    return;
+                }
+
                 if (!this.hasRegaVariables) {
                     this.logger.debug('variables not yet known. defer setVariable ' + name);
                     clearTimeout(this.setVariableQueueTimeout[name]);
@@ -1319,8 +1551,19 @@ module.exports = function (RED) {
          */
         regaPoll() {
             //this.logger.trace('regaPoll');
+            if (this.metaMode) {
+                // nothing to poll: no variables, no programs, and names arrive
+                // over the metadata api's event stream
+                return;
+            }
+
             if (this.regaPollPending) {
-                this.logger.warn('rega poll already pending');
+                // #166: writing several variables at once used to lose all but
+                // the first immediate re-poll, so their new values only showed
+                // up at the next scheduled one (30 s by default). Remember the
+                // request and run exactly one more poll afterwards.
+                this.logger.debug('rega poll already pending, will repeat');
+                this.regaPollAgain = true;
             } else {
                 this.regaPollPending = true;
                 clearTimeout(this.regaPollTimeout);
@@ -1342,6 +1585,14 @@ module.exports = function (RED) {
 
                         this.firstRegaPollDone = true;
                         this.regaPollPending = false;
+
+                        if (this.regaPollAgain && !this.cancelRegaPoll) {
+                            this.regaPollAgain = false;
+                            this.regaPoll();
+                        } else {
+                            this.regaPollAgain = false;
+                            this.refreshRegaDataIfDue();
+                        }
                     });
             }
         }
@@ -1481,6 +1732,38 @@ module.exports = function (RED) {
          * Poll ReGaHSS variables and call subscription callbacks
          * @returns {Promise}
          */
+        /**
+         * Re-read the ReGa metadata that only ever got fetched once, in the
+         * constructor: channel names, rooms and functions. A room or function
+         * added in the CCU WebUI was invisible until the flow was redeployed
+         * (#167). Cheap enough for a slow schedule - three small scripts.
+         * @returns {Promise<any>}
+         */
+        refreshRegaData() {
+            this.lastRegaDataRefresh = now();
+            this.logger.debug('refreshRegaData');
+            return this.getRegaChannels()
+                .then(() => this.getRegaRooms())
+                .then(() => this.getRegaFunctions())
+                .then(() => this.saveRegadata())
+                .catch((error) => {
+                    this.logger.error('refreshRegaData', error);
+                    this.recheckMeta();
+                });
+        }
+
+        /** Runs refreshRegaData() when the configured interval has elapsed. */
+        refreshRegaDataIfDue() {
+            if (!this.regaMetaInterval || this.cancelRegaPoll) {
+                return;
+            }
+
+            const elapsed = now() - (this.lastRegaDataRefresh || 0);
+            if (elapsed >= this.regaMetaInterval * 60000) {
+                this.refreshRegaData();
+            }
+        }
+
         getRegaVariables() {
             return new Promise((resolve, reject) => {
                 this.logger.debug('getRegaVariables');
@@ -1766,6 +2049,10 @@ module.exports = function (RED) {
          * @param iface
          */
         rpcCheckInit(iface) {
+            if (!this.rpcPingEnabled) {
+                return;
+            }
+
             if (!this.metadata.devices[iface] || !Object.keys(this.metadata.devices[iface]).length > 0) {
                 return;
             }
@@ -2509,6 +2796,7 @@ module.exports = function (RED) {
                 'change',
                 'cache',
                 'stable',
+                'uncertain',
                 'iface',
                 'device',
                 'deviceType',
@@ -2714,6 +3002,15 @@ module.exports = function (RED) {
             let matchChange;
             let matchStable;
 
+            // Checked before the attribute loop below: that loop may break
+            // early for a whitelisted datapoint, and this decision has to be
+            // made for every message regardless of key order. Only present in
+            // the filter when a node opted in, so existing subscriptions keep
+            // receiving values the ReGa could not timestamp (#96).
+            if (filter && filter.uncertain === false && message.uncertain) {
+                return false;
+            }
+
             if (filter) {
                 const arrayAttr = Object.keys(filter);
 
@@ -2753,6 +3050,11 @@ module.exports = function (RED) {
                         continue;
                     }
 
+                    if (attr === 'uncertain') {
+                        // already decided above, and not a value to compare
+                        continue;
+                    }
+
                     if (this.callbackWhitelists[message.datapointName].has(id)) {
                         if (matchCache && matchChange && matchStable) {
                             break;
@@ -3058,6 +3360,11 @@ module.exports = function (RED) {
          */
         script(script) {
             return new Promise((resolve, reject) => {
+                if (this.metaMode) {
+                    reject(this.regaMissingError('HM-Script and ReGaHSS scripts'));
+                    return;
+                }
+
                 execToCallback(this.rega.exec(script), (err, payload, objects) => {
                     if (err) {
                         reject(err);

package/nodes/ccu-display.js

@@ -1,6 +1,19 @@
 const path = require('path');
 
 const statusHelper = require(path.join(__dirname, '/lib/status.js'));
+const {effectiveConfig} = require(path.join(__dirname, '/lib/dynconfig.js'));
+
+/** Everything a message may override through msg.config (B-2, #80 #185). */
+const DYNAMIC_KEYS = [
+    'iface',
+    'channel',
+    'channelType',
+    'sound',
+    'repeat',
+    'pause',
+    'signal',
+    ...[1, 2, 3, 4, 5, 6].flatMap((i) => ['line' + i, 'color' + i, 'icon' + i, 'disable' + i]),
+];
 
 module.exports = function (RED) {
     class CcuDisplay {
@@ -143,43 +156,46 @@ module.exports = function (RED) {
             }
 
             this.on('input', (message, send, done) => {
+                // msg.line1 & co. keep working as before; msg.config
+                // additionally reaches the channel and the EP-WM55 settings
+                const {config: effective} = effectiveConfig(config, message, DYNAMIC_KEYS);
                 let payload = '0x02';
 
                 let countLines = 6; // HM-Dis-WM55
-                if (config.channelType === 'HM-Dis-EP-WM55') {
+                if (effective.channelType === 'HM-Dis-EP-WM55') {
                     payload += ',0x0A';
                     countLines = 3;
                 }
 
                 for (let i = 1; i <= countLines; i++) {
-                    if (!message['disable' + i] && !config['disable' + i]) {
-                        payload += convertString(message['line' + i] || config['line' + i]);
-                        if (config.channelType === 'HM-Dis-WM55') {
-                            payload += convertColor(message['color' + i] || config['color' + i]);
+                    if (!message['disable' + i] && !effective['disable' + i]) {
+                        payload += convertString(message['line' + i] || effective['line' + i]);
+                        if (effective.channelType === 'HM-Dis-WM55') {
+                            payload += convertColor(message['color' + i] || effective['color' + i]);
                         }
 
-                        payload += convertIcon(message['icon' + i] || config['icon' + i]);
+                        payload += convertIcon(message['icon' + i] || effective['icon' + i]);
                     }
 
                     payload += ',0x0A';
                 }
 
-                if (config.channelType === 'HM-Dis-EP-WM55') {
-                    if (config.sound) {
-                        payload += ',0x14,' + config.sound + ',0x1C';
+                if (effective.channelType === 'HM-Dis-EP-WM55') {
+                    if (effective.sound) {
+                        payload += ',0x14,' + effective.sound + ',0x1C';
                     }
 
-                    payload += ',' + config.repeat + ',0x1D,' + config.pause + ',0x16';
+                    payload += ',' + effective.repeat + ',0x1D,' + effective.pause + ',0x16';
 
-                    if (config.signal) {
-                        payload += ',' + config.signal;
+                    if (effective.signal) {
+                        payload += ',' + effective.signal;
                     }
                 }
 
                 payload += ',0x03';
 
                 this.ccu
-                    .setValue(config.iface, config.channel, 'SUBMIT', payload)
+                    .setValue(effective.iface, effective.channel, 'SUBMIT', payload)
                     .then(() => {
                         done();
                     })

package/nodes/ccu-get-value.html

@@ -195,7 +195,9 @@
                     arr.sort((a, b) => a.localeCompare(b));
                     $nodeInputChannel.autocomplete('option', 'source', arr);
 
-                    if (!data[$nodeInputChannel.val().split(' ')[0]]) {
+                    // ${ENV} placeholders are substituted by Node-RED before the node is
+                    // constructed (subflow parameters, #158) - do not clear them
+                    if (!/^\$\{[^}]+\}$/.test($nodeInputChannel.val()) && !data[$nodeInputChannel.val().split(' ')[0]]) {
                         $nodeInputChannel.val('');
                         $nodeInputDatapoint.val('');
                     }

package/nodes/ccu-mqtt.html

@@ -10,6 +10,7 @@
 
             topicOutputEvent: {value: 'hm/status/${channelName}/${datapoint}'},  
             topicInputSetValue: {value: 'hm/set/${channelNameOrAddress}/${datapoint}'},  
+            topicInputGet: {value: 'hm/get/${channelNameOrAddress}/${datapoint}'},  
 
             topicOutputSysvar: {value: 'hm/status/${name}'},  
             topicInputSysvar: {value: 'hm/set/${name}'},  
@@ -17,7 +18,7 @@
             topicInputPutParam: {value: 'hm/paramset/${channelNameOrAddress}/${paramset}/${param}'},  
             topicInputPutParamset: {value: 'hm/paramset/${channelNameOrAddress}/${paramset}'},  
 
-            topicInputRpc: {value: 'hm/rpc/${iface}/${method}/${command}/${callid}'},  
+            topicInputRpc: {value: 'hm/rpc/${iface}/${method}/${callid}'},  
             topicOutputRpc: {value: 'hm/response/${callid}'},  
 
             topicCounters: {value: 'hm/status/counter/${iface}/${rxtx}'},  
@@ -36,6 +37,20 @@
         labelStyle() {
             return this.name ? 'node_label_italic' : '';
         },
+        oneditprepare() {
+            // The RPC command was never implemented, so its topic template
+            // carried a meaningless ${command} segment. Nothing can have
+            // depended on it - migrate nodes that still hold the old default.
+            if (this.topicInputRpc === 'hm/rpc/${iface}/${method}/${command}/${callid}') {
+                this.topicInputRpc = 'hm/rpc/${iface}/${method}/${callid}';
+                $('#node-input-topicInputRpc').val(this.topicInputRpc);
+            }
+
+            if (typeof this.topicInputGet === 'undefined') {
+                this.topicInputGet = 'hm/get/${channelNameOrAddress}/${datapoint}';
+                $('#node-input-topicInputGet').val(this.topicInputGet);
+            }
+        },
         oneditsave() {
         }
     });
@@ -84,6 +99,10 @@
         <label for="node-input-topicInputSetValue">setValue</label>
         <input type="text" id="node-input-topicInputSetValue">
     </div>
+    <div class="form-row">
+        <label for="node-input-topicInputGet">get</label>
+        <input type="text" id="node-input-topicInputGet">
+    </div>
     <div class="form-row">
         <label for="node-input-topicOutputSysvar">Sysvar/Program Change</label>
         <input type="text" id="node-input-topicOutputSysvar">
@@ -100,16 +119,14 @@
         <label for="node-input-topicInputPutParamset">putParamset</label>
         <input type="text" id="node-input-topicInputPutParamset">
     </div>
-    <!--
     <div class="form-row">
         <label for="node-input-topicInputRpc">RPC</label>
         <input type="text" id="node-input-topicInputRpc">
     </div>
     <div class="form-row">
-        <label for="node-input-topicInputRpc">RPC Response</label>
+        <label for="node-input-topicOutputRpc">RPC Response</label>
         <input type="text" id="node-input-topicOutputRpc">
     </div>
-    -->
     <div class="form-row">
         <label for="node-input-topicCounters">Message Counters</label>
         <input type="text" id="node-input-topicCounters">