node-red-contrib-ccu 4.6.1 → 4.7.0

package/nodes/ccu-connection.js

@@ -17,10 +17,15 @@ 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, retryDelay} = require('./lib/initretry.js');
+const {InitRetry, retryDelay, RETRY_INTERVAL} = require('./lib/initretry.js');
+const lite = require('./lib/lite.js');
 const xmlrpc = require('homematic-xmlrpc');
 const binrpc = require('binrpc');
 
+/** how long the XML-RPC callback server keeps an idle keep-alive connection open: longer than
+ * hmipserver's HTTP client pool (1200 s), so the pool never reuses a connection this side closed */
+const KEEP_ALIVE_TIMEOUT_MS = 1300 * 1000;
+
 const pkg = require(path.join(__dirname, '..', 'package.json'));
 
 // B-37: how long after our init the process's listDevices/newDevices still belong to it -
@@ -51,8 +56,20 @@ function execToCallback(promise, callback) {
     );
 }
 
-/** B-28: how often an inconclusive metadata api detection is repeated (1, 2, 4, 8 s, then every 15 s) */
-const META_REDETECT_ATTEMPTS = 20;
+/**
+ * task 16: the pseudo-interface that carries the metadata stream's state on openccu-lite in
+ * ifaceTypes/ifaceStatus, where the ReGaHSS slot was borrowed before - the nodes' status logic
+ * works on those tables, and the system has no ReGaHSS to report. Never an RPC interface: no
+ * client, no init, not offered in the editors' interface lists (pseudo).
+ */
+const META_IFACE = 'Metadata';
+
+/**
+ * B-28: how often an inconclusive metadata api detection is repeated on the init retry's schedule
+ * (task 17: every 3 s for 90 s, then every 15 s - 41 attempts reach the same 255 s the 1/2/4/8/15 s
+ * steps covered in 20)
+ */
+const META_REDETECT_ATTEMPTS = 41;
 
 /**
  * task 9: has a device description changed in a way that changes its paramsets?
@@ -163,6 +180,11 @@ module.exports = function (RED) {
             switch (request.query.type) {
                 case 'ifaces': {
                     Object.keys(config.ifaceTypes).forEach((iface) => {
+                        if (config.ifaceTypes[iface].pseudo) {
+                            // task 16: the metadata stream is not an interface a node could address
+                            return;
+                        }
+
                         object[iface] = {
                             enabled: Boolean(config.ifaceTypes[iface].enabled),
                             connected: Boolean(config.ifaceStatus[iface]),
@@ -508,6 +530,8 @@ module.exports = function (RED) {
             const pass = auth ? config.password : undefined;
 
             this.ifaceTypes = {
+                // task 15: a port set in the dialog wins over the default of the transport (a CCU
+                // behind port forwarding, hm-simulator on a free port); blank is the default
                 ReGaHSS: {
                     conf: 'rega',
                     rpc: this.isLocal ? binrpc : xmlrpc,
@@ -519,7 +543,7 @@ module.exports = function (RED) {
                 'BidCos-RF': {
                     conf: 'bcrf',
                     rpc: this.isLocal || transport.bcrfBinRpc ? binrpc : xmlrpc,
-                    port: this.isLocal ? 32001 : tls ? 42001 : 2001,
+                    port: Number(config.bcrfPort) || (this.isLocal ? 32001 : tls ? 42001 : 2001),
                     protocol: this.isLocal || transport.bcrfBinRpc ? 'binrpc' : 'http',
                     auth,
                     user,
@@ -532,7 +556,7 @@ module.exports = function (RED) {
                 'BidCos-Wired': {
                     conf: 'bcwi',
                     rpc: this.isLocal ? binrpc : xmlrpc,
-                    port: this.isLocal ? 32000 : tls ? 42000 : 2000,
+                    port: Number(config.bcwiPort) || (this.isLocal ? 32000 : tls ? 42000 : 2000),
                     protocol: this.isLocal ? 'binrpc' : 'http',
                     auth,
                     user,
@@ -545,7 +569,7 @@ module.exports = function (RED) {
                 'HmIP-RF': {
                     conf: 'iprf',
                     rpc: xmlrpc,
-                    port: this.isLocal ? 32010 : tls ? 42010 : 2010,
+                    port: Number(config.iprfPort) || (this.isLocal ? 32010 : tls ? 42010 : 2010),
                     protocol: 'http',
                     auth,
                     user,
@@ -563,7 +587,7 @@ module.exports = function (RED) {
                 VirtualDevices: {
                     conf: 'virt',
                     rpc: xmlrpc,
-                    port: this.isLocal ? 39292 : tls ? 49292 : 9292,
+                    port: Number(config.virtPort) || (this.isLocal ? 39292 : tls ? 49292 : 9292),
                     path: 'groups',
                     protocol: 'http',
                     auth,
@@ -577,7 +601,7 @@ module.exports = function (RED) {
                 CUxD: {
                     conf: 'cuxd',
                     rpc: binrpc,
-                    port: 8701,
+                    port: Number(config.cuxdPort) || 8701,
                     protocol: 'binrpc',
                     init: true,
                     ping: true,
@@ -632,8 +656,10 @@ module.exports = function (RED) {
             this.lastRealEvent = {};
             this.ifaceStatus = {};
             // task 11: interfaces whose init failed and is retried (InitRetry per iface),
-            // and which of them are waiting for an unreachable process
+            // and which of them are waiting for an unreachable process; task 17: when this
+            // node started, for the retry's "connected … after the start" line
             this.initRetry = {};
+            this.startedAt = Date.now();
             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())
@@ -655,6 +681,17 @@ module.exports = function (RED) {
             this.inSecure = inSecure;
             this.metaPort = Number.parseInt(config.metaPort, 10) || (tls ? 443 : 80);
             this.metaToken = config.metaToken || metaProvider.readLocalToken();
+            // task 14: the way to the interfaces on openccu-lite - `auto` (the default) goes through
+            // the system's lite-rpc where the system is openccu-lite and a credential allows it,
+            // `openccu-lite` insists on it, `ccu` keeps the direct connection with callbacks there
+            // too. The credential for lite-rpc: the node's token, else the addon's own (RedMatic's,
+            // minted by the system); the local token reads names only and is no credential here.
+            this.connectionType = ['ccu', 'openccu-lite'].includes(config.connectionType)
+                ? config.connectionType
+                : 'auto';
+            this.liteToken = config.metaToken || lite.readAddonToken();
+            this.lite = null;
+            this.liteIfaces = [];
             this.metaMode = false;
             this.meta = null;
             // #167: minutes between re-reads of channel names, rooms and
@@ -738,6 +775,12 @@ module.exports = function (RED) {
                 RED.settings.userDir || path.join(__dirname, '..'),
                 'ccu_values_' + this.host + '.json',
             );
+            // task 14: written once, when a connection of type `auto` first went through lite-rpc -
+            // the one-time move is said in the log once, not at every start
+            this.liteMarkerFile = path.join(
+                RED.settings.userDir || path.join(__dirname, '..'),
+                'ccu_lite_' + this.host + '.json',
+            );
 
             this.loadMetadata();
             this.loadRegadata();
@@ -748,7 +791,7 @@ module.exports = function (RED) {
 
             this.rega = new Rega({
                 host: this.host,
-                port: this.isLocal ? 8183 : tls ? 48181 : 8181,
+                port: Number(config.regaPort) || (this.isLocal ? 8183 : tls ? 48181 : 8181),
                 tls,
                 insecure: inSecure,
                 username: user,
@@ -800,7 +843,7 @@ module.exports = function (RED) {
 
         /**
          * B-31: the password and the token, from the credentials or - once - from the
-         * plain properties of a flow written before 4.4.6.
+         * plain properties of a flow written before 4.5.0.
          * @param {object} config the node's configuration as deployed
          * @returns {{password: string, metaToken: string}}
          */
@@ -963,7 +1006,10 @@ module.exports = function (RED) {
             const waitingChanged = Boolean(this.ifaceWaiting[iface]) !== waiting;
             if (this.ifaceStatus[iface] !== connected || waitingChanged) {
                 if (this.ifaceStatus[iface] !== connected) {
-                    if (iface === 'ReGaHSS') {
+                    if (this.ifaceTypes[iface].pseudo) {
+                        // task 16: the stream of the system's metadata api, not an interface process
+                        this.logger.info(iface, 'stream', connected ? 'connected' : 'disconnected');
+                    } else 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
@@ -973,7 +1019,9 @@ module.exports = function (RED) {
                             'Interface',
                             iface,
                             connected
-                                ? this.ifaceTypes[iface].protocol +
+                                ? this.lite && this.lite.has(iface)
+                                    ? 'lite-rpc connected'
+                                    : this.ifaceTypes[iface].protocol +
                                       ' port ' +
                                       this.ifaceTypes[iface].port +
                                       ' connected'
@@ -989,11 +1037,7 @@ module.exports = function (RED) {
                     delete this.ifaceWaiting[iface];
                 }
 
-                Object.keys(this.users).forEach((id) => {
-                    if (typeof this.users[id].setStatus === 'function') {
-                        this.users[id].setStatus({ifaceStatus: this.ifaceStatus, ifaceWaiting: this.ifaceWaiting});
-                    }
-                });
+                this.pushStatus();
             }
         }
 
@@ -1007,6 +1051,7 @@ module.exports = function (RED) {
                 this.initRetry[iface] = new InitRetry({
                     iface,
                     logger: this.logger,
+                    startedAt: this.startedAt,
                     attempt: () => this.rpcInit(iface, {retry: true}),
                     onState: (state) => {
                         if (state === 'connected') {
@@ -1022,6 +1067,15 @@ module.exports = function (RED) {
             return this.initRetry[iface];
         }
 
+        /** the interface tables as they are now, to every node of this connection */
+        pushStatus() {
+            Object.keys(this.users).forEach((id) => {
+                if (typeof this.users[id].setStatus === 'function') {
+                    this.users[id].setStatus({ifaceStatus: this.ifaceStatus, ifaceWaiting: this.ifaceWaiting});
+                }
+            });
+        }
+
         /**
          * An init succeeded (the first one, a retry, or a re-init after a ping timeout).
          * @param iface
@@ -1032,6 +1086,21 @@ module.exports = function (RED) {
             } else {
                 this.setIfaceStatus(iface, true);
             }
+
+            this.retryMissingNow(iface);
+        }
+
+        /**
+         * task 17: an interface appeared - every other one whose init retry is waiting on its timer
+         * is tried at once (rfd and hmipserver come up close together on a booting system).
+         * @param {string} iface the one that appeared
+         */
+        retryMissingNow(iface) {
+            Object.keys(this.initRetry).forEach((other) => {
+                if (other !== iface) {
+                    this.initRetry[other].poke();
+                }
+            });
         }
 
         /**
@@ -1262,6 +1331,7 @@ module.exports = function (RED) {
             this.logger.debug('ccu-connection destructor');
             this.closing = true;
             this.stopInitRetries();
+            this.stopLite();
             this.stats(false);
 
             this.logger.debug('clear regaPollTimeout');
@@ -1392,9 +1462,10 @@ module.exports = function (RED) {
         /**
          * B-28: an inconclusive detection (the box busy or still starting) used
          * to leave the connection in ReGa mode for good - the only re-detection
-         * ran from rare error paths, at most every five minutes. Ask again after
-         * 1, 2, 4, 8 s, then every 15 s, up to META_REDETECT_ATTEMPTS times;
-         * after that the five-minute rule of recheckMeta() applies.
+         * ran from rare error paths, at most every five minutes. Ask again on the
+         * init retry's schedule (every 3 s for 90 s, then every 15 s - task 17), up
+         * to META_REDETECT_ATTEMPTS times; after that the five-minute rule of
+         * recheckMeta() applies.
          * @param {{inconclusive: boolean, reason?: string}} outcome
          */
         scheduleMetaRedetect(outcome) {
@@ -1416,7 +1487,7 @@ module.exports = function (RED) {
                 return;
             }
 
-            const delay = retryDelay(this.metaRedetectAttempt);
+            const delay = retryDelay((this.metaRedetectAttempt - 1) * RETRY_INTERVAL);
             const line =
                 'meta api detection inconclusive (' +
                 outcome.reason +
@@ -1483,6 +1554,21 @@ module.exports = function (RED) {
                 this.closeClient('ReGaHSS');
             }
 
+            // task 16: the metadata stream's state is the Metadata pseudo-interface's, not the
+            // ReGaHSS slot's - the system has none, and "Interface ReGaHSS connected" misled
+            this.ifaceTypes[META_IFACE] = {
+                conf: 'meta',
+                pseudo: true,
+                init: false,
+                ping: false,
+                protocol: this.tlsEnabled ? 'https' : 'http',
+                port: this.metaPort,
+                enabled: true,
+            };
+            delete this.ifaceStatus.ReGaHSS;
+            delete this.ifaceWaiting.ReGaHSS;
+            this.ifaceStatus[META_IFACE] = null;
+
             this.logger.info(
                 'openccu-lite detected (' +
                     (info.implementation || 'meta api') +
@@ -1525,12 +1611,29 @@ module.exports = function (RED) {
                         resolve();
                     },
                     onStatus: (connected) => {
-                        this.setIfaceStatus('ReGaHSS', connected);
+                        this.setIfaceStatus(META_IFACE, connected);
                     },
                     onGone: () => {
                         this.metaMode = false;
                         this.meta = null;
                         this.lastMetaProbe = 0;
+                        if (this.lite) {
+                            // task 14: lite-rpc went with the system's answer; the CCU way needs a deploy
+                            this.stopLite();
+                            this.liteIfaces.forEach((iface) => this.setIfaceStatus(iface, false));
+                            this.logger.warn(
+                                'lite-rpc closed: the system no longer answers as openccu-lite - deploy again to reach the interfaces the CCU way',
+                            );
+                        }
+
+                        // task 16: the ReGaHSS slot is the interface again
+                        delete this.ifaceTypes[META_IFACE];
+                        delete this.ifaceStatus[META_IFACE];
+                        if (this.ifaceTypes.ReGaHSS.enabled) {
+                            this.ifaceStatus.ReGaHSS = null;
+                        }
+
+                        this.pushStatus();
                         this.logger.warn('this box no longer answers as openccu-lite - detecting again');
                         this.detectMetaOutcome().then((outcome) => {
                             if (outcome.info) {
@@ -2213,9 +2316,16 @@ module.exports = function (RED) {
          * @param config
          */
         initIfaces(config) {
+            // task 14: the interfaces that go through lite-rpc get no client and no init of their own
+            const liteIfaces = this.liteInterfaces(config);
+            this.liteIfaces = liteIfaces;
             Object.keys(this.ifaceTypes).forEach((iface) => {
                 const enabled = config[this.ifaceTypes[iface].conf + 'Enabled'];
                 this.ifaceTypes[iface].enabled = enabled;
+                if (enabled && liteIfaces.includes(iface)) {
+                    return;
+                }
+
                 if (enabled && iface === 'ReGaHSS' && this.metaMode) {
                     // B-27: openccu-lite has no ReGaHSS, nothing listens on 31999.
                     // A client would only reconnect forever (with binrpc < 4.3.0
@@ -2245,6 +2355,249 @@ module.exports = function (RED) {
                 }
             });
             this.logger.info('Interfaces:', this.enabledIfaces.join(', '));
+            if (liteIfaces.length > 0) {
+                this.startLite(liteIfaces);
+            }
+        }
+
+        /**
+         * task 14: which of the enabled interfaces go through the system's lite-rpc - the ones
+         * lite-rpc carries (not CUxD, not CCU-Jack), on an openccu-lite system, with a credential,
+         * unless the connection type says `ccu`.
+         * @param {object} config the node's config
+         * @returns {string[]}
+         */
+        liteInterfaces(config) {
+            const enabled = lite.LITE_INTERFACES.filter((iface) => config[this.ifaceTypes[iface].conf + 'Enabled']);
+            if (this.connectionType === 'ccu') {
+                if (this.metaMode) {
+                    this.logger.info(
+                        'openccu-lite: the direct connection with callbacks by choice (connection type CCU) - the interfaces are reached on their own ports',
+                    );
+                }
+
+                return [];
+            }
+
+            if (!this.metaMode) {
+                if (this.connectionType === 'openccu-lite') {
+                    this.logger.warn(
+                        'connection type openccu-lite, but the system did not answer as openccu-lite - the interfaces are reached the CCU way until it does',
+                    );
+                }
+
+                return [];
+            }
+
+            if (!this.liteToken) {
+                this.logger.info(
+                    'openccu-lite without a credential for lite-rpc (no token in the connection node, no addon token in ' +
+                        lite.ADDON_TOKEN_FILE +
+                        ') - the interfaces are reached directly, with callbacks',
+                );
+                return [];
+            }
+
+            if (enabled.length === 0) {
+                return [];
+            }
+
+            return enabled;
+        }
+
+        /**
+         * task 14: the init id the callback table expects for an interface - the same shape rpcInit
+         * registers, so getIfaceFromIdInit() recognises the stream's calls.
+         * @param {string} iface
+         * @returns {string}
+         */
+        liteInitId(iface) {
+            const hash = base62(crypto.createHash('sha1').update(this.initUrl(iface)).digest()).slice(0, 6);
+            return 'nr_' + hash + '_' + iface;
+        }
+
+        /**
+         * task 14: the interfaces through the system's lite-rpc with occulite-client - one client,
+         * the stream's events into the same rpcMethods table the callback servers feed, the
+         * requests through methodCall. The one-time move of an `auto` connection is said once
+         * (the marker file); `ccu` in the connection node is never moved.
+         * @param {string[]} ifaces
+         */
+        startLite(ifaces) {
+            if (this.connectionType === 'auto') {
+                let marker = null;
+                try {
+                    marker = JSON.parse(fs.readFileSync(this.liteMarkerFile, 'utf8'));
+                } catch {
+                    marker = null;
+                }
+
+                if (!marker) {
+                    this.logger.info(
+                        'openccu-lite: ' +
+                            ifaces.join(', ') +
+                            " go through the system's lite-rpc from now on, the default on openccu-lite - moved once; connection type CCU in the connection node keeps the direct connection with callbacks, and is never changed again",
+                    );
+                    try {
+                        fs.writeFileSync(
+                            this.liteMarkerFile,
+                            JSON.stringify({migrated: new Date().toISOString(), host: this.host}),
+                        );
+                    } catch (error) {
+                        this.logger.warn('cannot write ' + this.liteMarkerFile + ': ' + error.message);
+                    }
+                }
+            }
+
+            const url = (this.tlsEnabled ? 'https' : 'http') + '://' + this.host + ':' + this.metaPort;
+            const running = (iface) => this.lite && this.lite.running(iface) !== false;
+            this.lite = new lite.LiteConnection({
+                url,
+                token: this.liteToken,
+                insecure: Boolean(this.inSecure),
+                interfaces: ifaces,
+                initId: (iface) => this.liteInitId(iface),
+                logger: this.logger,
+                createClient: this.liteCreateClient,
+                onCallback: (method, err, parameters, callback) => {
+                    if (err) {
+                        this.logger.error('rpc <', 'lite', method, err);
+                    }
+
+                    this.logger.debug('rpc <', 'lite', method, JSON.stringify(parameters));
+                    const handler = method === 'event' ? 'eventSingle' : method;
+                    if (isIterable(parameters)) {
+                        this.callRpcMethod(handler, err, parameters, callback);
+                    } else {
+                        this.logger.error(
+                            'rpc <',
+                            'lite',
+                            'method',
+                            method,
+                            'params not iterable',
+                            JSON.stringify(parameters),
+                        );
+                        callback(null, this.rpcDefaultAnswer(method));
+                    }
+                },
+                onInterface: (iface, state) => {
+                    if (!ifaces.includes(iface) || this.closing) {
+                        return;
+                    }
+
+                    this.logger.debug('lite-rpc interface', iface, state);
+                    if (state === 'up' || state === 'added' || state === 'restarted') {
+                        this.lastEvent[iface] = now();
+                        this.setIfaceStatus(iface, true);
+                        if (state === 'restarted' || state === 'added') {
+                            this.getDevices(iface).catch(() => {});
+                        }
+                    } else {
+                        this.setIfaceStatus(iface, false, true);
+                    }
+                },
+                onStatus: (state) => {
+                    if (this.closing) {
+                        return;
+                    }
+
+                    this.logger.debug('lite-rpc client', state);
+                    if (state === 'ready') {
+                        ifaces.forEach((iface) => this.setIfaceStatus(iface, running(iface), !running(iface)));
+                    } else if (state === 'degraded' || state === 'offline' || state === 'connecting') {
+                        ifaces.forEach((iface) => this.setIfaceStatus(iface, false, true));
+                    } else if (state === 'closed') {
+                        ifaces.forEach((iface) => this.setIfaceStatus(iface, false));
+                    }
+                },
+                onValues: (values) => this.applyLiteValues(values),
+            });
+            this.logger.info(
+                'lite-rpc: ' + ifaces.join(', ') + ' through ' + url + ' (occulite-client), no callback server',
+            );
+            ifaces.forEach((iface) => this.setIfaceStatus(iface, false, true));
+            this.lite
+                .start()
+                .then(() => {
+                    if (this.closing || !this.lite) {
+                        return;
+                    }
+
+                    const up = ifaces.filter((iface) => running(iface));
+                    this.logger.info('lite-rpc connected: ' + (up.join(', ') || 'no interface running'));
+                    return Promise.all(
+                        up.map((iface) =>
+                            this.getDevices(iface)
+                                .then(() => {
+                                    if (['BidCos-RF', 'BidCos-Wired', 'HmIP-RF'].includes(iface)) {
+                                        return this.methodCall(iface, 'getLinks', [], {quiet: true})
+                                            .then((res) => {
+                                                this.links[iface] = res;
+                                            })
+                                            .catch(() => {});
+                                    }
+                                })
+                                .catch((error) => {
+                                    this.logger.warn('lite-rpc ' + iface + ' listDevices: ' + error.message);
+                                }),
+                        ),
+                    );
+                })
+                .catch((error) => {
+                    if (this.closing) {
+                        return;
+                    }
+
+                    this.logger.warn('lite-rpc: ' + (error.message || error) + ' - the client keeps trying');
+                    ifaces.forEach((iface) => this.setIfaceStatus(iface, false, true));
+                });
+        }
+
+        /**
+         * task 14: the state store's picture into the values cache at connect (what a CCU's ReGa
+         * getValues gave): the nodes with "cache" get a value at deploy on openccu-lite as well.
+         * @param {Map<string, {value: *, ts: number, lc?: number, confirmed: boolean}>} values box.values
+         */
+        applyLiteValues(values) {
+            if (!values || typeof values.forEach !== 'function') {
+                return;
+            }
+
+            let count = 0;
+            values.forEach((entry, ref) => {
+                const [iface, channel, datapoint] = String(ref).split('.');
+                if (!this.liteIfaces.includes(iface) || !channel || !datapoint) {
+                    return;
+                }
+
+                const ts = entry.ts || 0;
+                const message = this.createMessage(iface, channel, datapoint, entry.value, {
+                    cache: true,
+                    change: false,
+                    working: false,
+                    uncertain: entry.confirmed === false,
+                    ts,
+                    lc: entry.lc || ts,
+                });
+                this.values[message.datapointName] = message;
+                count += 1;
+                if (!datapoint.startsWith('PRESS_')) {
+                    this.callCallbacks(message);
+                }
+            });
+            this.logger.debug('lite-rpc: ' + count + ' values from the state store');
+            this.cachedValuesReceived = true;
+            this.saveValues();
+            this.scheduleValuesPrune();
+        }
+
+        /** task 14: close the lite-rpc client, if any */
+        stopLite() {
+            if (this.lite) {
+                this.logger.debug('lite-rpc client closing');
+                this.lite.close();
+                this.lite = null;
+            }
         }
 
         /**
@@ -2862,6 +3215,17 @@ module.exports = function (RED) {
                     this.logger.info(protocol === 'binrpc' ? 'binrpc' : 'xmlrpc', 'server listening on', url);
                     this.serverError[iface] = null;
                 });
+                if (this.servers[protocol].httpServer) {
+                    // hmipserver delivers its events through a pooled HTTP keep-alive client whose idle
+                    // timeout is 1200 s, and sends the next event on a pooled connection without
+                    // checking it. Node closes an idle keep-alive connection after 5 s by default, so
+                    // at the idle boundary the two raced: the event went out onto a socket this side was
+                    // closing, hmipserver logged "Connection reset" and the event was lost, a few times a
+                    // day. The callback server keeps an idle connection longer than the client pool
+                    // does, so it is always the client that lets go.
+                    this.servers[protocol].httpServer.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
+                    this.servers[protocol].httpServer.headersTimeout = KEEP_ALIVE_TIMEOUT_MS + 5000;
+                }
 
                 // Todo binrpc module: emit error event on server object to eliminate the reach-in
                 const errorEmitter = protocol === 'binrpc' ? this.servers[protocol].server : this.servers[protocol];
@@ -4126,6 +4490,31 @@ module.exports = function (RED) {
          */
         methodCall(iface, method, parameters, {quiet = false} = {}) {
             return new Promise((resolve, reject) => {
+                if (this.lite && this.lite.has(iface)) {
+                    // task 14: through the system's lite-rpc; a fault keeps its code, a scope the
+                    // token lacks is said as such - the interface stays connected either way
+                    this.logger.debug('rpc >', iface, method, JSON.stringify(parameters));
+                    this.lite.call(iface, method, parameters).then(
+                        (res) => {
+                            this.logger.debug('    <', iface, method, JSON.stringify(res));
+                            resolve(res);
+                        },
+                        (error) => {
+                            this.logger[quiet ? 'debug' : 'error'](
+                                '    <',
+                                iface,
+                                method,
+                                JSON.stringify(parameters),
+                                error.faultCode === undefined
+                                    ? error.message
+                                    : 'fault ' + error.faultCode + ' ' + error.faultString,
+                            );
+                            reject(error);
+                        },
+                    );
+                    return;
+                }
+
                 if (this.clients[iface]) {
                     this.logger.debug('rpc >', iface, method, JSON.stringify(parameters));
                     this.clients[iface].methodCall(method, parameters, (err, res) => {