node-red-contrib-ccu 4.4.3 → 4.4.5

package/CHANGELOG.md

@@ -5,23 +5,62 @@ 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.4.5 (2026-09-26)
+
+### Fixed
+
+- **A Node-RED started before rfd went through the CCU's proxy for good.**
+  The connection decides at start whether it runs on the CCU itself, and
+  looked only for a listener on rfd's direct port. On openccu-lite, where
+  RedMatic starts at boot before the interface processes (the early start),
+  that port is not open yet, so every interface went through lighttpd's
+  proxy ports (XML-RPC instead of BIN-RPC for BidCos) until the next restart.
+  A loopback host on a system that has the CCU's interface list
+  (`/etc/config/InterfacesList.xml`) is now taken as local as well.
+- **Waiting for an interface process that is still starting is no warning**
+  (task 12). Before the interface was ever connected, a refused connection
+  is one info line (_"HmIP-RF not listening yet (connect ECONNREFUSED),
+  waiting for it - retrying in 1 s"_); another transport error, or a refused
+  connection after the interface had been connected, is still a warning, and
+  a fault answer an error.
+
+### Changed
+
+- **A failed `init` is retried after 1 s, 2 s, 4 s and 8 s, then every 15 s**
+  (task 12; was 2, 4, 8, 16 s, then every 30 s), the schedule of hm2mqtt.js and
+  the Homematic Manager.
+
+## 4.4.4 (2026-09-17)
+
+### Fixed
+
+- **An interface stayed without events for minutes, or for good, when its
+  process did not answer the first `init`** (task 11). A failed `init` at
+  start (connection refused, timeout) was only retried by the ping
+  supervision, which does nothing without cached devices and waits the ping
+  timeout otherwise: 60 s, and 600 s for HmIP-RF. A Node-RED that starts
+  before the interface processes (a box still booting, a daemon restart) now
+  retries the `init` on its own after 2 s, 4 s, 8 s, 16 s and then every 30 s,
+  for every interface, until it succeeds or the node is closed or redeployed.
+  While it waits, the log has one warning (_"HmIP-RF not reachable yet
+  (connect ECONNREFUSED), retrying"_) instead of an error line, the success
+  after retries is logged (_"HmIP-RF connected after 3 attempts"_), and the
+  nodes show **waiting** (yellow ring) instead of disconnected. A fault answer
+  of a running process stays an error. After a successful `init` the ping and
+  re-`init` supervision works as before.
+
 ## 4.4.3 (2026-09-09)
 
 ### Fixed
 
-- **Node-RED at 100 % CPU and unresponsive on openccu-lite** (B-27, found on
-  the maintainer's Pi 4 with RedMatic 9.4.2). openccu-lite has no ReGaHSS, so
-  nothing listens on port 31999 — but the connection node still created the
-  ReGaHSS binrpc client in metadata mode, and binrpc up to 4.2.0 armed a new
-  reconnect timer for both the `error` and the `close` event of every refused
-  connect, so the number of attempts doubled every 2.5 s without bound: about
-  7,000 refused connects per second, 30,000 pending timers and 68 million
-  connects in under three hours. The same explosion hit a CCU whenever its
-  ReGaHSS was down for a while (restart, backup restore); it just ended when
-  the port came back. Two changes: the ReGaHSS client is not created at all
-  while the box is an openccu-lite (and is closed when a box becomes one, or
-  created when it stops being one), and this release requires
-  [binrpc 4.3.0](https://github.com/hobbyquaker/binrpc/blob/master/CHANGELOG.md),
+- **Node-RED at 100 % CPU and unresponsive while ReGaHSS is unreachable**
+  (B-27). binrpc up to 4.2.0 armed a new reconnect timer for both the `error`
+  and the `close` event of every refused connect, so the number of attempts to
+  the ReGaHSS port 31999 doubled every 2.5 s without bound: about 7,000 refused
+  connects per second, 30,000 pending timers and 68 million connects in under
+  three hours. On a CCU this hit whenever ReGaHSS was down for a while
+  (restart, backup restore) and ended when the port came back. This release
+  requires [binrpc 4.3.0](https://github.com/hobbyquaker/binrpc/blob/master/CHANGELOG.md),
   which keeps a single reconnect timer per client with exponential backoff
   (2.5 s doubling to 30 s) and has `close()`. The connection node now closes
   its rpc clients when it is removed or redeployed, and when it replaces a
@@ -81,46 +120,11 @@ hang up` — became an **unhandled rejection**, which Node >= 15 turns
 
 ### Added
 
-- **openccu-lite support** (roadmap B-17). [openccu-lite](https://github.com/hobbyquaker/openccu-lite)
-  is a Homematic CCU firmware without ReGaHSS: the interface processes
-  are unchanged, but nothing listens on 8181/8183, HM-Script is never
-  interpreted and there are no ReGa ids. The connection node now asks
-  the box `GET /api/meta/v1/version` when it starts and on every
-  reconnect of its name sync; a CCU3/RaspberryMatic/OpenCCU answers 404
-  and everything runs exactly as before, an openccu-lite answers with
-  its API version and device, channel, room and function names come
-  from its metadata API instead — a snapshot at start, then the box's
-  Server-Sent-Events change stream, so a rename in the box's UI reaches
-  running flows within a second without a redeploy. `msg.channelName`,
-  `msg.rooms`, `msg.functions` and the room/function filters keep the
-  shape they have on a CCU (rooms and functions are a tree there and
-  are flattened to the usual arrays of names, most specific first).
-  Nothing has to be configured: the same connection node works on both
-  kinds of box, which is what makes moving a backup between them
-  harmless.
-- connection node: **openccu-lite token** and **openccu-lite port**
-  fields. The token is only needed when Node-RED does _not_ run on the
-  box — on the box the read-only token in
-  `/usr/local/etc/occulite/local-token` is picked up automatically, off
-  the box the administrator creates one on the box's _Users_ page. A
-  rejected or missing token is not fatal: the nodes work with addresses
-  instead of names, the connection logs it once and takes the names as
-  soon as a valid token is there. The port field is only for boxes
-  whose web server is not on 80/443. Both are ignored on a CCU.
 - connection node: the cached `ccu_rega_<host>.json` now also holds the
   room and function name lists, so the editor's room and function
   pickers are filled right after a restart instead of only after the
   first successful sync.
 
-### Changed
-
-- `ccu-sysvar`, `ccu-program`, `ccu-script` and `ccu-poll` stay in the
-  palette and in flows on openccu-lite, and stay accepted in the
-  editor. There is no ReGa DOM on such a box, so instead of failing the
-  connection they log one line when the connection starts and answer
-  every message with a clear error (`… are not available on this box
-(openccu-lite has no ReGaHSS)`). On a CCU nothing about them changes.
-
 ## 4.3.0 (2026-09-04)
 
 ### Added

package/README.md

@@ -30,45 +30,16 @@ Some example flows can be found in the [RedMatic Wiki](https://github.com/rdmtc/
 
 ## openccu-lite
 
-[openccu-lite](https://github.com/hobbyquaker/openccu-lite) is a Homematic CCU firmware **without ReGaHSS**. The
-interface processes (`rfd`, `hs485d`, `hmipserver`) are the same, so everything these nodes do over BINRPC/XMLRPC works
-unchanged — but there is no logic layer: nothing listens on 8181/8183, HM-Script is never interpreted, and there are no
-ReGa ids. Device, channel, room and function names come from the box's metadata API instead.
-
-Nothing has to be configured for this. When the connection node starts (and on every reconnect of its name sync) it
-asks the box `GET /api/meta/v1/version`; a CCU3, RaspberryMatic or OpenCCU answers 404 and the ReGaHSS path runs exactly
-as before, an openccu-lite answers with its API version and the node takes names, rooms and functions from there —
-loaded once as a snapshot and then kept current from the box's event stream, so a rename in the box's UI shows up in
-your flows within a second, without a redeploy. `msg.channelName`, `msg.rooms`, `msg.functions` and the room/function
-filters keep exactly the shape they have on a CCU. The same connection node configuration works on both, which is what
-makes moving a backup between the two harmless.
-
-**Credential.** Every metadata endpoint except the version probe needs a token:
-
-- Node-RED **on the box** (RedMatic): nothing to do — the box's own read-only token is read from
-  `/usr/local/etc/occulite/local-token`.
-- Node-RED **elsewhere** (a PC, a container): create a token on the box's _Users_ page and paste it into the
-  **openccu-lite token** field of the connection node. The **openccu-lite port** field next to it is only needed when
-  the box's web server is not on port 80 (443 with TLS).
-
-Without a token the nodes still work, with addresses instead of names: the connection logs the rejected credential once
-and picks the names up on the next retry, as soon as a valid token is there.
-
-**What has no replacement on openccu-lite** (from openccu-lite's own porting guide):
-
-- **System variables** and **programs**: there is no ReGa DOM. The `ccu-sysvar`, `ccu-program` and `ccu-poll` nodes stay
-  in the palette and in your flows — they are accepted, they never break the connection, and every message they get is
-  answered with a clear error instead.
-- **`exec()` of HM-Script** — `dom.GetObject`, `system.GetSessionVarStr` and everything else the `ccu-script` node
-  sends: gone, same handling as above.
-- **ReGa ids** (`dom.GetObject(1234)`): there are none. The metadata API identifies objects by
-  `<interface>.<address>`; these nodes have always keyed on the address, so nothing changes for flows.
-- **Service messages / alarms** (system variables 40 and 41): interface-level state only.
-- **The CCU WebUI's JSON-RPC API** (`/api/homematic.cgi`, `Session.login`, `Device.listAll`): not present.
-
-Rooms and functions are a **tree** on openccu-lite (`room/eg/wohnzimmer`), not a flat list. They are flattened to the
-arrays these nodes have always published, most specific first: a channel in _Wohnzimmer_ below _Erdgeschoss_ gets
-`msg.rooms = ["Wohnzimmer", "Erdgeschoss"]` and `msg.room = "Wohnzimmer"`, so a room filter on either name matches.
+[openccu-lite](https://github.com/hobbyquaker/openccu-lite) is a Homematic CCU firmware based on OpenCCU **without
+ReGaHSS**. The interface processes (`rfd`, `hs485d`, `hmipserver`) are the same, so everything these nodes do over
+BINRPC/XMLRPC works unchanged. Device, channel, room and function names come from the system's metadata API instead of
+ReGaHSS; the connection node detects this at start (`GET /api/meta/v1/version`), nothing has to be configured, and
+`msg.channelName`, `msg.rooms`, `msg.functions` and the room/function filters keep their shape.
+
+- Node-RED **on the system** (RedMatic from its addon catalogue): the system's own read-only token is used, nothing to do.
+- Node-RED **elsewhere**: an API token of the system goes into the connection node's **openccu-lite token** field.
+- **System variables, programs and HM-Script do not exist there.** The `ccu-sysvar`, `ccu-program`, `ccu-script` and
+  `ccu-poll` nodes stay in the flows and answer every message with an error.
 
 ## Home Assistant
 

package/nodes/ccu-connection.js

@@ -15,6 +15,7 @@ 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 {InitRetry} = require('./lib/initretry.js');
 const xmlrpc = require('homematic-xmlrpc');
 const binrpc = require('binrpc');
 
@@ -100,6 +101,7 @@ module.exports = function (RED) {
                         object[iface] = {
                             enabled: Boolean(config.ifaceTypes[iface].enabled),
                             connected: Boolean(config.ifaceStatus[iface]),
+                            waiting: Boolean(config.ifaceWaiting && config.ifaceWaiting[iface]),
                         };
                     });
                     res.status(200).send(JSON.stringify(object));
@@ -535,6 +537,11 @@ module.exports = function (RED) {
             this.rpcPingEnabled = config.rpcPing === undefined ? true : Boolean(config.rpcPing);
             this.rpcPingTimer = {};
             this.ifaceStatus = {};
+            // task 11: interfaces whose init failed and is retried (InitRetry per iface),
+            // and which of them are waiting for an unreachable process
+            this.initRetry = {};
+            this.ifaceWaiting = {};
+            this.closing = false;
             this.serverError = {};
             this.queueTimeout = Number.parseInt(config.queueTimeout, 10) || 5000;
             this.queuePause = Number.parseInt(config.queuePause, 10) || 0;
@@ -799,29 +806,104 @@ module.exports = function (RED) {
          * @param iface
          * @param connected
          */
-        setIfaceStatus(iface, connected) {
-            if (this.ifaceStatus[iface] !== connected) {
-                if (iface === 'ReGaHSS') {
-                    this.logger.info('Interface', iface, connected ? 'connected' : 'disconnected');
-                } else {
-                    this.logger.info(
-                        'Interface',
-                        iface,
-                        connected
-                            ? this.ifaceTypes[iface].protocol + ' port ' + this.ifaceTypes[iface].port + ' connected'
-                            : 'disconnected',
-                    );
+        setIfaceStatus(iface, connected, waiting = false) {
+            waiting = Boolean(waiting) && !connected;
+            const waitingChanged = Boolean(this.ifaceWaiting[iface]) !== waiting;
+            if (this.ifaceStatus[iface] !== connected || waitingChanged) {
+                if (this.ifaceStatus[iface] !== connected) {
+                    if (iface === 'ReGaHSS') {
+                        this.logger.info('Interface', iface, connected ? 'connected' : 'disconnected');
+                    } else if (waiting) {
+                        // task 11: the retry logs the one warn line, this stays quiet
+                        this.logger.debug('Interface', iface, 'waiting');
+                    } else {
+                        this.logger.info(
+                            'Interface',
+                            iface,
+                            connected
+                                ? this.ifaceTypes[iface].protocol +
+                                      ' port ' +
+                                      this.ifaceTypes[iface].port +
+                                      ' connected'
+                                : 'disconnected',
+                        );
+                    }
                 }
 
                 this.ifaceStatus[iface] = !this.serverError[iface] && connected;
+                if (waiting) {
+                    this.ifaceWaiting[iface] = true;
+                } else {
+                    delete this.ifaceWaiting[iface];
+                }
+
                 Object.keys(this.users).forEach((id) => {
                     if (typeof this.users[id].setStatus === 'function') {
-                        this.users[id].setStatus({ifaceStatus: this.ifaceStatus});
+                        this.users[id].setStatus({ifaceStatus: this.ifaceStatus, ifaceWaiting: this.ifaceWaiting});
                     }
                 });
             }
         }
 
+        /**
+         * task 11: the init retry of an interface, created on its first failure.
+         * @param iface
+         * @returns {InitRetry}
+         */
+        getInitRetry(iface) {
+            if (!this.initRetry[iface]) {
+                this.initRetry[iface] = new InitRetry({
+                    iface,
+                    logger: this.logger,
+                    attempt: () => this.rpcInit(iface, {retry: true}),
+                    onState: (state) => {
+                        if (state === 'connected') {
+                            this.setIfaceStatus(iface, true);
+                        } else {
+                            this.hadTimeout.add(iface);
+                            this.setIfaceStatus(iface, false, state === 'waiting');
+                        }
+                    },
+                });
+            }
+
+            return this.initRetry[iface];
+        }
+
+        /**
+         * An init succeeded (the first one, a retry, or a re-init after a ping timeout).
+         * @param iface
+         */
+        rpcInitSucceeded(iface) {
+            if (this.initRetry[iface]) {
+                this.initRetry[iface].succeeded();
+            } else {
+                this.setIfaceStatus(iface, true);
+            }
+        }
+
+        /**
+         * An init failed: retry it with backoff, whether or not the interface has
+         * cached devices or a ping (task 11).
+         * @param iface
+         * @param error
+         */
+        rpcInitFailed(iface, error) {
+            if (this.closing || !this.ifaceTypes[iface] || !this.ifaceTypes[iface].enabled) {
+                return;
+            }
+
+            this.getInitRetry(iface).failed(error);
+        }
+
+        /** stop every scheduled init retry (close, redeploy) */
+        stopInitRetries() {
+            Object.keys(this.initRetry).forEach((iface) => {
+                this.initRetry[iface].stop();
+            });
+            this.initRetry = {};
+        }
+
         /**
          *
          * @returns {Promise<any>}
@@ -1026,6 +1108,8 @@ module.exports = function (RED) {
          */
         destructor(done) {
             this.logger.debug('ccu-connection destructor');
+            this.closing = true;
+            this.stopInitRetries();
             this.stats(false);
 
             this.logger.debug('clear regaPollTimeout');
@@ -1895,12 +1979,10 @@ module.exports = function (RED) {
                             if (this.ifaceTypes[iface].init) {
                                 return this.rpcInit(iface)
                                     .then(() => {
-                                        this.setIfaceStatus(iface, true);
+                                        this.rpcInitSucceeded(iface);
                                     })
                                     .catch((error) => {
-                                        this.logger.error('init', iface, error);
-                                        this.hadTimeout.add(iface);
-                                        this.setIfaceStatus(iface, false);
+                                        this.rpcInitFailed(iface, error);
                                     });
                             }
 
@@ -1939,7 +2021,7 @@ module.exports = function (RED) {
             }
         }
 
-        createClient(iface) {
+        createClient(iface, {quiet = false} = {}) {
             return new Promise((resolve) => {
                 const {rpc, port, path, protocol, auth, user, pass, tls, inSecure} = this.ifaceTypes[iface];
                 const clientOptions = {};
@@ -1962,7 +2044,7 @@ module.exports = function (RED) {
                     this.clients[iface] = rpc.createClient(clientOptions);
                 }
 
-                this.logger.info(
+                this.logger[quiet ? 'debug' : 'info'](
                     'rpc client ' +
                         iface +
                         ' ' +
@@ -1989,7 +2071,7 @@ module.exports = function (RED) {
          * @param iface
          * @returns {Promise<any>}
          */
-        rpcInit(iface) {
+        rpcInit(iface, {retry = false} = {}) {
             return new Promise((resolve, reject) => {
                 const initUrl = this.rpcServer(iface);
                 const hash = base62(crypto.createHash('sha1').update(initUrl).digest()).slice(0, 6);
@@ -1997,7 +2079,8 @@ module.exports = function (RED) {
                 this.lastEvent[iface] = now();
 
                 const {protocol, port} = this.ifaceTypes[iface];
-                this.logger.info(
+                // task 11: a retry logs its attempt at debug level
+                this.logger[retry ? 'debug' : 'info'](
                     'init ' +
                         iface +
                         ' (' +
@@ -2011,8 +2094,22 @@ module.exports = function (RED) {
                         ' ' +
                         initId,
                 );
-                this.methodCall(iface, 'init', [initUrl, initId])
+                if (retry) {
+                    // a fresh client: the one created after the failure (binrpc) may
+                    // still wait for its own reconnect timer and fail the write at once
+                    this.closeClient(iface);
+                    this.createClient(iface, {quiet: true});
+                }
+
+                // a failed init is logged by the retry (InitRetry), not here
+                this.methodCall(iface, 'init', [initUrl, initId], {quiet: true})
                     .then(() => {
+                        // 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) {
+                            this.rpcCheckInit(iface);
+                        }
+
                         if (iface === 'CUxD') {
                             this.getDevices(iface)
                                 .then(() => resolve(iface))
@@ -2028,12 +2125,7 @@ module.exports = function (RED) {
                             resolve(iface);
                         }
                     })
-                    .catch((error) => reject(error))
-                    .finally(() => {
-                        if (this.ifaceTypes[iface].ping) {
-                            this.rpcCheckInit(iface);
-                        }
-                    });
+                    .catch((error) => reject(error));
             });
         }
 
@@ -2118,7 +2210,9 @@ module.exports = function (RED) {
                 this.hadTimeout.add(iface);
                 this.setIfaceStatus(iface, false);
                 this.logger.warn('ping timeout', iface, elapsed);
-                this.rpcInit(iface).catch((error) => this.logger.error(error.message));
+                this.rpcInit(iface)
+                    .then(() => this.rpcInitSucceeded(iface))
+                    .catch((error) => this.rpcInitFailed(iface, error));
                 return;
             }
 
@@ -2142,7 +2236,8 @@ module.exports = function (RED) {
             this.logger.debug('rpcClose');
             const calls = [];
             Object.keys(this.clients).forEach((iface) => {
-                if (this.ifaceTypes[iface].init) {
+                // an interface still waiting for its process never took our init
+                if (this.ifaceTypes[iface].init && !this.ifaceWaiting[iface]) {
                     this.logger.debug('queue de-init ' + iface + ' ' + this.initUrl(iface));
                     calls.push(() => {
                         return new Promise((resolve) => {
@@ -3204,19 +3299,26 @@ module.exports = function (RED) {
          * @param params
          * @returns {Promise<any>}
          */
-        methodCall(iface, method, parameters) {
+        methodCall(iface, method, parameters, {quiet = false} = {}) {
             return new Promise((resolve, reject) => {
                 if (this.clients[iface]) {
                     this.logger.debug('rpc >', iface, method, JSON.stringify(parameters));
                     this.clients[iface].methodCall(method, parameters, (err, res) => {
                         if (err) {
-                            this.logger.error('    <', iface, method, err);
+                            this.logger[quiet ? 'debug' : 'error']('    <', iface, method, err);
                             this.closeClient(iface);
-                            this.createClient(iface);
+                            // a closed node creates no new client (it would reconnect forever)
+                            if (!this.closing) {
+                                this.createClient(iface, {quiet});
+                            }
+
                             reject(err);
                         } else if (res && res.faultCode) {
-                            this.logger.error('    <', iface, method, JSON.stringify(res));
-                            reject(new Error(res.faultString));
+                            this.logger[quiet ? 'debug' : 'error']('    <', iface, method, JSON.stringify(res));
+                            const fault = new Error(res.faultString);
+                            fault.faultCode = res.faultCode;
+                            fault.faultString = res.faultString;
+                            reject(fault);
                         } else {
                             this.logger.debug('    <', iface, method, JSON.stringify(res));
                             resolve(res);

package/nodes/lib/initretry.js

@@ -0,0 +1,207 @@
+/*
+ * Retrying a failed rpc init, separate from the ping/re-init liveness.
+ *
+ * An interface process that does not answer yet (a box still booting, an
+ * addon started before the interfaces, a daemon restart) used to leave the
+ * interface without events: rpcCheckInit only runs with cached devices and
+ * then waits pingTimeout (600 s for HmIP-RF). Now a failed init schedules its
+ * own retry, 1 s, 2 s, 4 s, 8 s and then every 15 s (task 12), until it
+ * succeeds or the node is closed.
+ *
+ * While the process is unreachable the interface is "waiting": one line, then
+ * debug. Before the interface was ever connected, a refused connection is
+ * info - the process is still starting (openccu-lite's early start starts
+ * Node-RED before rfd and hmipserver) - and every other transport error, or a
+ * refusal after it had been connected, is a warning. A fault answer (the
+ * process is up and refuses the init) stays an error, logged once per
+ * distinct fault.
+ */
+
+const RETRY_DELAYS = [1000, 2000, 4000, 8000];
+const RETRY_MAX_DELAY = 15000;
+
+/**
+ * The delay before the next attempt.
+ * @param {number} failures failed attempts so far (1 after the first failure)
+ * @returns {number} milliseconds
+ */
+function retryDelay(failures) {
+    if (failures >= 1 && failures <= RETRY_DELAYS.length) {
+        return RETRY_DELAYS[failures - 1];
+    }
+
+    return RETRY_MAX_DELAY;
+}
+
+/**
+ * Whether the error is a fault answer of the interface process (it is up)
+ * rather than a transport error (refused, reset, timeout).
+ * @param {*} error
+ * @returns {boolean}
+ */
+function isFault(error) {
+    return Boolean(error) && typeof error === 'object' && error.faultCode !== undefined;
+}
+
+/**
+ * Whether nothing listens on the port (yet): the process is not started.
+ * @param {*} error
+ * @returns {boolean}
+ */
+function isRefused(error) {
+    return Boolean(error) && (error.code === 'ECONNREFUSED' || /ECONNREFUSED/.test(String(error.message || '')));
+}
+
+/**
+ * A short reason for the log line, e.g. "connect ECONNREFUSED".
+ * @param {*} error
+ * @returns {string}
+ */
+function describeError(error) {
+    if (!error) {
+        return 'unknown error';
+    }
+
+    if (isFault(error)) {
+        return 'fault ' + error.faultCode + (error.faultString ? ' ' + error.faultString : '');
+    }
+
+    if (error.code) {
+        return (error.syscall ? error.syscall + ' ' : 'connect ') + error.code;
+    }
+
+    return error.message || String(error);
+}
+
+class InitRetry {
+    /**
+     * @param {object} options
+     * @param {string} options.iface interface name for the log lines
+     * @param {function(): Promise} options.attempt one init attempt
+     * @param {object} options.logger {debug, info, warn, error}
+     * @param {function(string)} options.onState 'waiting' | 'failed' | 'connected'
+     * @param {object} [options.timers] {setTimeout, clearTimeout}, for tests
+     */
+    constructor({iface, attempt, logger, onState, timers}) {
+        this.iface = iface;
+        this.attempt = attempt;
+        this.logger = logger;
+        this.onState = onState || (() => {});
+        this.timers = timers || {setTimeout, clearTimeout};
+        this.timer = null;
+        this.stopped = false;
+        this.everConnected = false;
+        this.reset();
+    }
+
+    reset() {
+        this.failures = 0;
+        this.warned = false;
+        this.faults = new Set();
+    }
+
+    /** true while a retry is scheduled */
+    get pending() {
+        return this.timer !== null;
+    }
+
+    /**
+     * An init attempt failed: log it and schedule the next one.
+     * @param {*} error
+     */
+    failed(error) {
+        if (this.stopped) {
+            return;
+        }
+
+        this.failures += 1;
+        const delay = retryDelay(this.failures);
+        const seconds = delay / 1000;
+        const reason = describeError(error);
+        if (isFault(error)) {
+            if (this.faults.has(reason)) {
+                this.logger.debug(
+                    'init ' + this.iface + ' failed again: ' + reason + ', retrying in ' + seconds + ' s',
+                );
+            } else {
+                this.faults.add(reason);
+                this.logger.error('init ' + this.iface + ' failed: ' + reason + ', retrying in ' + seconds + ' s');
+            }
+
+            this.onState('failed');
+        } else {
+            if (this.warned) {
+                this.logger.debug(
+                    this.iface + ' still not reachable (' + reason + '), next attempt in ' + seconds + ' s',
+                );
+            } else {
+                this.warned = true;
+                if (!this.everConnected && isRefused(error)) {
+                    this.logger.info(
+                        this.iface +
+                            ' not listening yet (' +
+                            reason +
+                            '), waiting for it - retrying in ' +
+                            seconds +
+                            ' s',
+                    );
+                } else {
+                    this.logger.warn(this.iface + ' not reachable yet (' + reason + '), retrying');
+                }
+            }
+
+            this.onState('waiting');
+        }
+
+        this.clear();
+        this.timer = this.timers.setTimeout(() => {
+            this.timer = null;
+            this.run();
+        }, delay);
+    }
+
+    /** one attempt now */
+    run() {
+        if (this.stopped) {
+            return Promise.resolve();
+        }
+
+        return Promise.resolve()
+            .then(() => this.attempt())
+            .then(
+                () => this.succeeded(),
+                (error) => this.failed(error),
+            );
+    }
+
+    /** an init attempt succeeded */
+    succeeded() {
+        if (this.stopped) {
+            return;
+        }
+
+        this.clear();
+        if (this.failures > 0) {
+            this.logger.info(this.iface + ' connected after ' + (this.failures + 1) + ' attempts');
+        }
+
+        this.everConnected = true;
+        this.reset();
+        this.onState('connected');
+    }
+
+    clear() {
+        if (this.timer !== null) {
+            this.timers.clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+
+    /** no more attempts (node closed or redeployed, interface disabled) */
+    stop() {
+        this.stopped = true;
+        this.clear();
+    }
+}
+
+module.exports = {InitRetry, retryDelay, isFault, isRefused, describeError, RETRY_DELAYS, RETRY_MAX_DELAY};

package/nodes/lib/localccu.js

@@ -17,7 +17,15 @@
    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. */
+   the interface table is built in the connection node's constructor.
+
+   A listener alone misses a start before rfd: openccu-lite starts an addon
+   that copes with it before the interface processes (its early start), so
+   the ports are not open yet and the connection went through the proxy for
+   good. The CCU's own interface list, /etc/config/InterfacesList.xml, is
+   there from the first second on every CCU firmware (CCU3, OpenCCU,
+   openccu-lite), so a loopback host with that file is the CCU we run on as
+   well. */
 
 const fs = require('fs');
 
@@ -26,6 +34,9 @@ const LOCAL_PROBE_PORTS = [32001, 31999];
 
 const PROC_NET_TCP = ['/proc/net/tcp', '/proc/net/tcp6'];
 
+/** The CCU firmware's list of its interface processes. */
+const INTERFACES_LIST = '/etc/config/InterfacesList.xml';
+
 /** /proc/net/tcp connection state 0A = TCP_LISTEN. */
 const TCP_LISTEN = '0A';
 
@@ -67,6 +78,7 @@ function listeningPorts(files) {
  * @param {string} host the configured CCU host
  * @param {object} [options]
  * @param {string[]} [options.files] /proc files to read, for tests
+ * @param {string} [options.interfacesList] the CCU's interface list, for tests
  * @returns {boolean}
  */
 function isLocalCcu(host, options) {
@@ -75,7 +87,13 @@ function isLocalCcu(host, options) {
     }
 
     const ports = listeningPorts(options && options.files);
-    return LOCAL_PROBE_PORTS.some((port) => ports.has(port));
+    if (LOCAL_PROBE_PORTS.some((port) => ports.has(port))) {
+        return true;
+    }
+
+    // the interface processes are not up yet (a start before them): the
+    // firmware's interface list still says this is the CCU
+    return fs.existsSync((options && options.interfacesList) || INTERFACES_LIST);
 }
 
-module.exports = {isLocalCcu, listeningPorts, LOCAL_PROBE_PORTS};
+module.exports = {isLocalCcu, listeningPorts, LOCAL_PROBE_PORTS, INTERFACES_LIST};

package/nodes/lib/status.js

@@ -1,5 +1,10 @@
+const WAITING = {fill: 'yellow', shape: 'ring', text: 'waiting'};
+
 module.exports = (that, data) => {
     data = data || {};
+    // task 11: an interface whose process does not answer yet is retried; the
+    // nodes show "waiting" (yellow ring) for it instead of "disconnected"
+    const waiting = data.ifaceWaiting || {};
     if (!that.iface) {
         if (data.ifaceStatus) {
             let status = 0;
@@ -9,8 +14,13 @@ module.exports = (that, data) => {
                 }
             });
             if (status < 1) {
-                that.status({fill: 'red', shape: 'dot', text: 'disconnected'});
-                that.currentStatus = 'red';
+                if (Object.keys(waiting).some((s) => waiting[s])) {
+                    that.status(WAITING);
+                    that.currentStatus = 'waiting';
+                } else {
+                    that.status({fill: 'red', shape: 'dot', text: 'disconnected'});
+                    that.currentStatus = 'red';
+                }
             } else if (status === Object.keys(data.ifaceStatus).length) {
                 if (that.currentStatus !== 'green') {
                     that.status({fill: 'green', shape: 'dot', text: 'connected'});
@@ -29,6 +39,9 @@ module.exports = (that, data) => {
             that.status({fill: 'green', shape: 'dot', text: 'connected'});
             that.currentStatus = 'green';
         }
+    } else if (waiting[that.iface]) {
+        that.status(WAITING);
+        that.currentStatus = 'waiting';
     } else {
         that.status({fill: 'red', shape: 'dot', text: 'disconnected'});
         that.currentStatus = 'red';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-ccu",
-  "version": "4.4.3",
+  "version": "4.4.5",
   "license": "MIT",
   "main": "none",
   "keywords": [