node-red-contrib-ccu 4.5.0 → 4.5.2

package/CHANGELOG.md

@@ -5,6 +5,46 @@ Notable changes to node-red-contrib-ccu. Format follows
 user-visible symptom and the cause, not the commit list (the release notes
 append commits automatically).
 
+## 4.5.2 (2026-10-02)
+
+### Fixed
+
+- **No HmIP-RF events for up to 10 minutes after hmipserver restarted**
+  (B-37). hmipserver keeps its subscribers over a restart: it calls
+  `listDevices` and `newDevices` on them and answers their pings, but
+  delivers no event to such a kept subscription until it is subscribed
+  afresh. The liveness ping saw its PONG and was content, so the
+  subscription came back only with the 600 s silence timeout. A
+  `listDevices` or `newDevices` call that does not follow the connection's
+  own `init` now makes it subscribe again at once, and events are back
+  within seconds. A device paired while Node-RED runs costs one such `init`
+  as well.
+
+## 4.5.1 (2026-10-02)
+
+### Fixed
+
+- **A burst of `getParamsetDescription Error: XML-RPC fault: Invalid device`
+  at the first start after an update** (B-36). A device deleted from the CCU
+  while Node-RED was not running stayed in the cached device table
+  (`ccu_<host>.json`) and in the values cache (`ccu_values_<host>.json`).
+  At the start its paramset descriptions were queued from the cached table;
+  hmipserver answered `-2 Invalid device`, a failed description was never
+  remembered, so every lookup queued it again (one item per channel and
+  paramset, duplicates included), each fault was logged twice without the
+  address, and each one threw away and rebuilt the interface's RPC client.
+  Seen on a CCU3 after a remote had been replaced: 150 failed calls in 40 s.
+  Now a description the interface refuses with a fault is asked for once
+  per address and paramset in a run, with one warning that names the
+  address, the paramset and the fault (a device paired anew is asked
+  again); the queue holds each description key once; `deleteDevices` drops
+  the device's queued fetches and its address from the type lists, and the
+  values cache is pruned against the device table at the start and a few
+  seconds after a `deleteDevices` or the ReGa's value read (the ReGa keeps
+  reporting the datapoints of a deleted device). An XML-RPC fault no longer
+  closes and recreates the RPC client: only a transport error does; the
+  fault is logged once, with the arguments of the call.
+
 ## 4.5.0 (2026-09-29)
 
 ### Added

package/nodes/ccu-connection.js

@@ -23,6 +23,11 @@ const binrpc = require('binrpc');
 
 const pkg = require(path.join(__dirname, '..', 'package.json'));
 
+// B-37: how long after our init the process's listDevices/newDevices still belong to it -
+// hmipserver answers the init at once and calls listDevices and newDevices afterwards. Such a
+// call later than this is the process calling on its own: it restarted and kept the subscription.
+const INIT_GRACE_MS = 30000;
+
 /**
  * check if an object is iterable
  * @link https://stackoverflow.com/a/37837872
@@ -630,6 +635,10 @@ module.exports = function (RED) {
             // and which of them are waiting for an unreachable process
             this.initRetry = {};
             this.ifaceWaiting = {};
+            // B-37: per interface {inFlight, at, reinit} of our own init, and how long after it the
+            // process's listDevices/newDevices still answer it (see keptSubscription())
+            this.initState = {};
+            this.initGrace = INIT_GRACE_MS;
             this.closing = false;
             this.serverError = {};
             this.queueTimeout = Number.parseInt(config.queueTimeout, 10) || 5000;
@@ -662,6 +671,13 @@ module.exports = function (RED) {
 
             this.newParamsetDescriptionCount = 0;
             this.paramsetQueue = [];
+            // B-36: iface/address/paramset whose description the interface refused
+            // with a fault (-2 Invalid device for an address it does not know) - not
+            // asked again in this run, so a stale cache entry costs one call, not one
+            // per lookup
+            this.paramsetFailed = new Set();
+            this.valuesPruneTimer = null;
+            this.valuesPruneDelay = 5000;
             this.paramsQueue = [];
 
             this.paramsetFile = path.join(RED.settings.userDir || path.join(__dirname, '..'), 'paramsets.json');
@@ -726,6 +742,7 @@ module.exports = function (RED) {
             this.loadMetadata();
             this.loadRegadata();
             this.loadValues();
+            this.pruneCaches();
 
             this.setContext();
 
@@ -1264,6 +1281,7 @@ module.exports = function (RED) {
                 clearTimeout(this.rpcPingTimer[iface]);
             });
             Object.keys(this.liveness).forEach((iface) => this.stopLiveness(iface));
+            clearTimeout(this.valuesPruneTimer);
 
             this.saveRegadata();
             this.saveValues();
@@ -1642,6 +1660,8 @@ module.exports = function (RED) {
                         });
                         this.cachedValuesReceived = true;
                         this.saveValues();
+                        // B-36: ReGa keeps the datapoints of a deleted device
+                        this.scheduleValuesPrune();
                         resolve();
                     }
                 });
@@ -2334,9 +2354,12 @@ module.exports = function (RED) {
                     this.createClient(iface, {quiet: true});
                 }
 
+                // B-37: listDevices/newDevices while this init runs or shortly after belong to it
+                this.initState[iface] = {inFlight: true, at: 0, reinit: false};
                 // a failed init is logged by the retry (InitRetry), not here
                 this.methodCall(iface, 'init', [initUrl, initId], {quiet: true})
                     .then(() => {
+                        this.initState[iface] = {inFlight: false, at: now(), reinit: false};
                         // the ping/re-init liveness starts after a successful init only;
                         // a failed one is retried by rpcInitFailed (task 11)
                         if (this.ifaceTypes[iface].ping && !this.closing) {
@@ -2359,10 +2382,57 @@ module.exports = function (RED) {
                             resolve(iface);
                         }
                     })
-                    .catch((error) => reject(error));
+                    .catch((error) => {
+                        this.initState[iface] = {inFlight: false, at: 0, reinit: false};
+                        reject(error);
+                    });
             });
         }
 
+        /**
+         * B-37: the interface process called listDevices or newDevices. Outside our own init it
+         * restarted and kept the subscription: hmipserver restores its subscribers from its
+         * handlers file, calls listDevices and newDevices on them and answers their pings (the
+         * PONG arrives, so neither the liveness ping nor the 600 s watchdog fires), but delivers
+         * no event to such a kept subscription until a fresh init (openccu-lite B-286, measured).
+         * So init again at once. A device paired while Node-RED runs costs one init the same way.
+         * @param iface
+         * @param {string} method
+         * @returns {boolean} whether a fresh init was started
+         */
+        keptSubscription(iface, method) {
+            const type = this.ifaceTypes[iface];
+            const state = this.initState[iface];
+            if (this.closing || !type || !type.enabled || !type.init) {
+                return false;
+            }
+
+            // never subscribed, an init running or already started for this restart
+            if (!state || state.inFlight || state.reinit || !state.at) {
+                return false;
+            }
+
+            if (this.initRetry[iface] && this.initRetry[iface].pending) {
+                return false;
+            }
+
+            if (now() - state.at < this.initGrace) {
+                return false;
+            }
+
+            state.reinit = true;
+            this.logger.info(
+                iface +
+                    ': ' +
+                    method +
+                    ' outside our init - the interface process restarted and kept the subscription, subscribing afresh',
+            );
+            this.rpcInit(iface)
+                .then(() => this.rpcInitSucceeded(iface))
+                .catch((error) => this.rpcInitFailed(iface, error));
+            return true;
+        }
+
         /**
          * Returns the links of a specific channel
          * @param {String} iface
@@ -2427,6 +2497,10 @@ module.exports = function (RED) {
                             this.saveMetadata();
                         }
 
+                        if (summary.removed) {
+                            this.scheduleValuesPrune();
+                        }
+
                         resolve(summary);
                     })
                     .catch(reject);
@@ -2896,7 +2970,13 @@ module.exports = function (RED) {
             if (device && device.PARAMSETS) {
                 device.PARAMSETS.forEach((paramset) => {
                     const name = this.paramsetName(iface, device, paramset);
-                    if (!this.paramsetDescriptions[name]) {
+                    if (
+                        !this.paramsetDescriptions[name] &&
+                        // B-36: once per description key in the queue, and never again
+                        // for an address/paramset the interface refused in this run
+                        !this.paramsetFailed.has(iface + '/' + device.ADDRESS + '/' + paramset) &&
+                        !(name && this.paramsetQueue.some((item) => item.name === name))
+                    ) {
                         this.paramsetQueue.push({
                             iface,
                             name,
@@ -2932,7 +3012,7 @@ module.exports = function (RED) {
                     clearTimeout(this.getParamsetTimeout);
                     setImmediate(() => this.paramsetQueueShift());
                 } else {
-                    this.methodCall(iface, 'getParamsetDescription', [address, paramset])
+                    this.methodCall(iface, 'getParamsetDescription', [address, paramset], {quiet: true})
                         .then((res) => {
                             //this.logger.trace('paramsetDescription', name);
                             this.newParamsetDescriptionCount += 1;
@@ -2944,7 +3024,31 @@ module.exports = function (RED) {
                                 this.saveParamsets();
                             }
                         })
-                        .catch((error) => this.logger.error(error))
+                        .catch((error) => {
+                            // B-36: one line naming the address and the paramset; a
+                            // fault is remembered, a transport error may be retried
+                            if (error && error.faultCode !== undefined) {
+                                this.paramsetFailed.add(iface + '/' + address + '/' + paramset);
+                                this.logger.warn(
+                                    'getParamsetDescription',
+                                    iface,
+                                    address,
+                                    paramset,
+                                    'fault',
+                                    error.faultCode,
+                                    error.faultString || error.message,
+                                    '- not asked again until the device is added anew',
+                                );
+                            } else {
+                                this.logger.error(
+                                    'getParamsetDescription',
+                                    iface,
+                                    address,
+                                    paramset,
+                                    error && error.message ? error.message : error,
+                                );
+                            }
+                        })
                         .then(() => {
                             this.paramsetPending = false;
                             clearTimeout(this.getParamsetTimeout);
@@ -3029,6 +3133,11 @@ module.exports = function (RED) {
                 this.logger.debug('newDevice', iface, device.ADDRESS);
             }
 
+            if (!known || deviceChanged(known, device)) {
+                // B-36: a device added anew (re-paired, or its data changed) is asked again
+                this.forgetParamsetFailures(iface, device.ADDRESS);
+            }
+
             this.metadata.devices[iface][device.ADDRESS] = device;
 
             if (!device.TYPE) {
@@ -3036,13 +3145,12 @@ module.exports = function (RED) {
                 throw new Error('device type undefined: ' + JSON.stringify(device));
             }
 
-            if (
-                this.metadata.types[iface][device.TYPE] &&
-                !this.metadata.types[iface][device.TYPE].includes(device.ADDRESS)
-            ) {
-                this.metadata.types[iface][device.TYPE].push(device.ADDRESS);
-            } else {
+            if (!this.metadata.types[iface][device.TYPE]) {
                 this.metadata.types[iface][device.TYPE] = [device.ADDRESS];
+            } else if (!this.metadata.types[iface][device.TYPE].includes(device.ADDRESS)) {
+                // an address already listed stays listed with the others (the old
+                // else branch replaced the whole list with it)
+                this.metadata.types[iface][device.TYPE].push(device.ADDRESS);
             }
 
             if (device.TYPE === 'MULTI_MODE_INPUT_TRANSMITTER') {
@@ -3059,7 +3167,116 @@ module.exports = function (RED) {
          */
         deleteDevice(iface, device) {
             this.logger.debug('deleteDevice', iface, device);
-            delete this.metadata.devices[iface][device];
+            const known = this.metadata.devices[iface] && this.metadata.devices[iface][device];
+            if (this.metadata.devices[iface]) {
+                delete this.metadata.devices[iface][device];
+            }
+
+            // B-36: nothing of a deleted device is fetched or listed by type any more -
+            // its queued descriptions (with those of its channels) and its address in
+            // metadata.types go with it. Its cached values go with the next
+            // scheduleValuesPrune(): hmipserver has been seen to answer an init with
+            // deleteDevices and newDevices for every device it has (eq-3/occu#45), so
+            // a value dropped here could belong to a device that is back a moment later.
+            const ofDevice = (address) => address === device || address.startsWith(device + ':');
+            this.paramsetQueue = this.paramsetQueue.filter((item) => item.iface !== iface || !ofDevice(item.address));
+            this.paramsQueue = this.paramsQueue.filter((item) => item.iface !== iface || !ofDevice(item.address));
+
+            const types = this.metadata.types && this.metadata.types[iface];
+            if (types) {
+                const typeNames = known && known.TYPE ? [known.TYPE] : Object.keys(types);
+                typeNames.forEach((type) => {
+                    if (Array.isArray(types[type])) {
+                        types[type] = types[type].filter((addr) => addr !== device);
+                        if (types[type].length === 0) {
+                            delete types[type];
+                        }
+                    }
+                });
+            }
+        }
+
+        /**
+         * B-36: the device table decides which cached values and type lists are
+         * kept - at the start the cache files may still hold a device that was
+         * deleted while Node-RED was not running.
+         */
+        pruneCaches() {
+            const types = (this.metadata && this.metadata.types) || {};
+            Object.keys(types).forEach((iface) => {
+                const devices = this.metadata.devices && this.metadata.devices[iface];
+                if (!devices) {
+                    return;
+                }
+
+                Object.keys(types[iface]).forEach((type) => {
+                    if (!Array.isArray(types[iface][type])) {
+                        return;
+                    }
+
+                    types[iface][type] = types[iface][type].filter((addr) => devices[addr]);
+                    if (types[iface][type].length === 0) {
+                        delete types[iface][type];
+                    }
+                });
+            });
+
+            const pruned = this.pruneValues();
+            if (pruned) {
+                this.logger.info('values cache: dropped', pruned, 'values of devices not in the device table');
+                this.saveValues();
+            }
+        }
+
+        /**
+         * B-36: prune the values cache against the device table a few seconds after
+         * the last deleteDevices or ReGa getValues - once hmipserver's
+         * deleteDevices/newDevices pair of an init has settled, and after ReGa
+         * reported the datapoints it keeps of a deleted device again.
+         */
+        scheduleValuesPrune() {
+            clearTimeout(this.valuesPruneTimer);
+            this.valuesPruneTimer = setTimeout(() => {
+                this.valuesPruneTimer = null;
+                const pruned = this.pruneValues();
+                if (pruned) {
+                    this.logger.info('values cache: dropped', pruned, 'values of devices not in the device table');
+                    this.saveValues();
+                }
+            }, this.valuesPruneDelay);
+        }
+
+        /**
+         * B-36: drop cached values whose channel is not in its interface's device
+         * table. An interface without a table (not read yet) keeps its values.
+         * @returns {number} how many were dropped
+         */
+        pruneValues() {
+            let pruned = 0;
+            const tables = (this.metadata && this.metadata.devices) || {};
+            Object.keys(this.values).forEach((datapointName) => {
+                const [iface, channel] = datapointName.split('.');
+                const devices = tables[iface];
+                if (channel && devices && Object.keys(devices).length > 0 && !devices[channel]) {
+                    delete this.values[datapointName];
+                    pruned += 1;
+                }
+            });
+            return pruned;
+        }
+
+        /**
+         * B-36: a device added anew is asked for its descriptions again.
+         * @param iface
+         * @param address device or channel address
+         */
+        forgetParamsetFailures(iface, address) {
+            const prefix = iface + '/' + address;
+            for (const key of this.paramsetFailed) {
+                if (key.startsWith(prefix + '/') || key.startsWith(prefix + ':')) {
+                    this.paramsetFailed.delete(key);
+                }
+            }
         }
 
         /**
@@ -3299,7 +3516,8 @@ module.exports = function (RED) {
                         this.saveMetadata();
                     }
 
-                    if (iface) {
+                    // B-37: a restart that kept the subscription gets a fresh init, no ping
+                    if (iface && !this.keptSubscription(iface, 'newDevices')) {
                         this.deviceCallback(iface);
                     }
                 },
@@ -3322,6 +3540,7 @@ module.exports = function (RED) {
 
                     if (changed) {
                         this.saveMetadata();
+                        this.scheduleValuesPrune();
                     }
 
                     if (iface) {
@@ -3339,6 +3558,9 @@ module.exports = function (RED) {
 
                     this.logger.debug('    >', iface, 'listDevices', JSON.stringify(res));
                     callback(null, res);
+                    if (iface) {
+                        this.keptSubscription(iface, 'listDevices');
+                    }
                 },
                 event: (_, parameters, callback) => {
                     const iface = this.rpcIface('event', parameters);
@@ -3907,7 +4129,25 @@ module.exports = function (RED) {
                 if (this.clients[iface]) {
                     this.logger.debug('rpc >', iface, method, JSON.stringify(parameters));
                     this.clients[iface].methodCall(method, parameters, (err, res) => {
-                        if (err) {
+                        if (err && err.faultCode !== undefined) {
+                            // B-36: homematic-xmlrpc delivers a fault as an Error with
+                            // faultCode/faultString. The process answered - the client is
+                            // fine and stays; one line, with the arguments that were refused.
+                            this.logger[quiet ? 'debug' : 'error'](
+                                '    <',
+                                iface,
+                                method,
+                                JSON.stringify(parameters),
+                                'fault',
+                                err.faultCode,
+                                err.faultString,
+                            );
+                            if (err.faultString === undefined) {
+                                err.faultString = err.message;
+                            }
+
+                            reject(err);
+                        } else if (err) {
                             this.logger[quiet ? 'debug' : 'error']('    <', iface, method, err);
                             this.closeClient(iface);
                             // a closed node creates no new client (it would reconnect forever)
@@ -3917,7 +4157,15 @@ module.exports = function (RED) {
 
                             reject(err);
                         } else if (res && res.faultCode) {
-                            this.logger[quiet ? 'debug' : 'error']('    <', iface, method, JSON.stringify(res));
+                            this.logger[quiet ? 'debug' : 'error'](
+                                '    <',
+                                iface,
+                                method,
+                                JSON.stringify(parameters),
+                                'fault',
+                                res.faultCode,
+                                res.faultString,
+                            );
                             const fault = new Error(res.faultString);
                             fault.faultCode = res.faultCode;
                             fault.faultString = res.faultString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-ccu",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "license": "MIT",
   "main": "none",
   "keywords": [
@@ -64,7 +64,7 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-html": "^8.2.0",
     "globals": "^16.5.0",
-    "hm-simulator": "^0.1.1",
+    "hm-simulator": "^1.3.1",
     "mocha": "^11.7.1",
     "node-red": "^4.1.0",
     "node-red-node-test-helper": "^0.3.6",
@@ -72,12 +72,6 @@
     "prettier": "^3.9.6",
     "should": "^13.2.3"
   },
-  "overrides": {
-    "hm-simulator": {
-      "homematic-xmlrpc": "^2.0.0",
-      "binrpc": "^4.3.0"
-    }
-  },
   "engines": {
     "node": "^20.19 || ^22.12 || >=24"
   },