iobroker.zigbee2mqtt 3.2.2 → 3.2.5

package/lib/statesController.js

@@ -28,6 +28,76 @@ class StatesController {
         this._debugDeviceList = logCustomizations.debugDevices
             ? String(logCustomizations.debugDevices).split(',').map((s) => s.trim()).filter(Boolean)
             : [];
+
+        // PERFORMANCE: Map-Cache für Topic->Device Lookup (vermeidet concat().find() pro Nachricht)
+        this.deviceMap = new Map();
+
+        // PERFORMANCE: Session-Cache für bereits per setObjectNotExistsAsync erstellte IDs
+        // Vermeidet wiederholte js-controller-Roundtrips
+        this.ensuredObjects = new Set();
+    }
+
+    /**
+     * Invalidiert den Topic->Device Map-Cache sowie den Session-Cache der
+     * bereits sichergestellten Objekte. Muss aufgerufen werden, wenn
+     * deviceCache/groupCache zur Laufzeit neu aufgebaut werden.
+     */
+    clearDeviceMap() {
+        this.deviceMap.clear();
+        this.ensuredObjects.clear();
+    }
+
+    /**
+     * Findet ein Gerät oder eine Gruppe anhand des Topics.
+     * Nutzt einen Map-Cache und füllt diesen bei Bedarf über eine einmalige lineare Suche.
+     *
+     * @param {string} topic Das Topic (entspricht device.id)
+     * @returns {object|null} Das gefundene Geräte-/Gruppenobjekt oder null
+     */
+    findDeviceByTopic(topic) {        if (!topic) {
+            return null;
+        }
+        const t = String(topic);
+        if (this.deviceMap.has(t)) {
+            return this.deviceMap.get(t);
+        }
+
+        // Fallback: lineare Suche (einmalig) und Cache-Eintrag
+        for (const grp of this.groupCache || []) {
+            if (grp && grp.id === t) {
+                this.deviceMap.set(t, grp);
+                return grp;
+            }
+        }
+        for (const dev of this.deviceCache || []) {
+            if (dev && dev.id === t) {
+                this.deviceMap.set(t, dev);
+                return dev;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Legt ein ioBroker-Objekt nur einmal pro Session an (reduziert setObjectNotExistsAsync-Roundtrips).
+     *
+     * @param {string} id  Vollständige Objekt-ID
+     * @param {object} obj Objekt-Definition für setObjectNotExistsAsync
+     */
+    async ensureObjectOnce(id, obj) {
+        if (!id) {
+            return;
+        }
+        if (this.ensuredObjects.has(id)) {
+            return;
+        }
+        try {
+            await this.adapter.setObjectNotExistsAsync(id, obj);
+            this.ensuredObjects.add(id);
+        } catch (e) {
+            // Loggen, aber nicht wiederholend blockieren
+            this.adapter.log.warn(`ensureObjectOnce: setObjectNotExistsAsync failed for ${id}: ${e}`);
+        }
     }
 
     /**
@@ -45,7 +115,8 @@ class StatesController {
             return;
         }
 
-        const device = this.groupCache.concat(this.deviceCache).find((x) => x.id === messageObj.topic);
+        // PERFORMANCE: Map-basiertes Lookup statt concat().find()
+        const device = this.findDeviceByTopic(messageObj.topic);
         if (device) {
             try {
                 await this.setDeviceStateSafely(messageObj, device);
@@ -116,6 +187,35 @@ class StatesController {
             return;
         }
 
+        // Fix 3: Vorab prüfen, ob überhaupt ein State des Devices existiert.
+        // Nur wenn KEIN EINZIGER State existiert → requeue.
+        // Wenn mindestens einer existiert → verarbeite vorhandene, ignoriere fehlende.
+        let hasAnyExistingState = false;
+        for (const key of Object.keys(messageObj.payload)) {
+            if (hasAnyExistingState) { break; }
+            let states = device.states.filter(state => state.prop && state.prop === key);
+            if (states.length === 0) { states = device.states.filter(x => x.id === key); }
+            for (const state of states) {
+                if (this.createCache[device.ieee_address]
+                    && this.createCache[device.ieee_address][state.id]
+                    && this.createCache[device.ieee_address][state.id].created === true) {
+                    hasAnyExistingState = true;
+                    break;
+                }
+            }
+        }
+
+        if (!hasAnyExistingState) {
+            // Kein einziger State existiert → Nachricht in Queue stellen
+            pushToQueue(messageObj);
+            return;
+        }
+
+        // COLLECTION: Alle non-action state write-Promises sammeln und dann parallel ausführen
+        const stateWrites = [];
+        // Flag für available-Update (wenn last_seen vorhanden und config aktiv)
+        let needSetAvailableTrue = false;
+
         for (let [key, value] of Object.entries(messageObj.payload)) {
             if (value === undefined || value === null) {
                 continue;
@@ -136,14 +236,15 @@ class StatesController {
                     // some devices has addition information in payload
                     const fullPath = `${device.ieee_address}.additional`;
 
-                    await this.adapter.setObjectNotExistsAsync(fullPath, {
+                    // PERFORMANCE: ensure object only once per session
+                    await this.ensureObjectOnce(fullPath, {
                         type: 'channel',
                         common: {
                             name: 'hidden channelstate',
                         },
                         native: {},
                     });
-                    await this.adapter.setObjectNotExistsAsync(`${fullPath}.${key}`, {
+                    await this.ensureObjectOnce(`${fullPath}.${key}`, {
                         type: 'state',
                         common: {
                             name: key,
@@ -157,7 +258,14 @@ class StatesController {
                     if (typeof value === 'object') {
                         value = JSON.stringify(value);
                     }
-                    this.adapter.setState(`${fullPath}.${key}`, value, true);
+                    // write additional state without awaiting
+                    stateWrites.push((async () => {
+                        try {
+                            await this.adapter.setStateChangedAsync(`${fullPath}.${key}`, value, true);
+                        } catch (e) {
+                            this.adapter.log.warn(`Cannot set additional state ${fullPath}.${key}: ${e}`);
+                        }
+                    })());
                 }
                 continue;
             }
@@ -166,15 +274,17 @@ class StatesController {
                 const stateName = `${device.ieee_address}.${state.id}`;
 
                 // set available status if last_seen is set
-                if (state.id === 'last_seen' && this.adapter.config.allwaysUpdateAvailableState === true) {
-                    await this.setStateSafelyAsync(`${device.ieee_address}.available`, true);
+                if (state.id === 'last_seen' && this.adapter.config.alwaysUpdateAvailableState === true) {
+                    // mark flag to set available before other writes
+                    needSetAvailableTrue = true;
                 }
 
-                // State noch nicht erstellt? → einmal in Queue legen und weiter
+                // State noch nicht erstellt? → überspringen (Requeue erfolgt nur,
+                // wenn GAR KEIN State des Devices existiert – siehe Pre-Check oben)
                 if (!this.createCache[device.ieee_address]
                 ||  !this.createCache[device.ieee_address][state.id]
                 ||  this.createCache[device.ieee_address][state.id].created !== true) {
-                    pushToQueue(messageObj);
+                    // If none created we already pushed to queue earlier
                     continue;
                 }
 
@@ -183,14 +293,34 @@ class StatesController {
                     if (state.prop && state.prop === 'action') {
                         actionStates.push(state);
                     }
-                    else if (this.adapter.config.allwaysUpdateOccupancyState === true && state.id === 'occupancy' && value === true) {
-                        await this.setStateSafelyAsync(stateName, value);
+                    else if (this.adapter.config.alwaysUpdateOccupancyState === true && state.id === 'occupancy' && value === true) {
+                        // occupancy true: schedule write
+                        stateWrites.push((async () => {
+                            try {
+                                await this.setStateSafelyAsync(stateName, value);
+                            } catch (e) {
+                                this.adapter.log.warn(`Cannot set occupancy ${stateName}: ${e}`);
+                            }
+                        })());
                     }
                     else {
                         if (state.getter) {
-                            await this.setStateChangedSafelyAsync(stateName, state.getter(messageObj.payload));
+                            // schedule changed-safe write
+                            stateWrites.push((async () => {
+                                try {
+                                    await this.setStateChangedSafelyAsync(stateName, state.getter(messageObj.payload));
+                                } catch (e) {
+                                    this.adapter.log.warn(`Cannot set state ${stateName}: ${e}`);
+                                }
+                            })());
                         } else {
-                            await this.setStateChangedSafelyAsync(stateName, value);
+                            stateWrites.push((async () => {
+                                try {
+                                    await this.setStateChangedSafelyAsync(stateName, value);
+                                } catch (e) {
+                                    this.adapter.log.warn(`Cannot set state ${stateName}: ${e}`);
+                                }
+                            })());
                         }
                     }
                 } catch (err) {
@@ -199,25 +329,52 @@ class StatesController {
             }
         }
 
+        // Wenn last_seen vorhanden: setze available zuerst (nicht parallelisiert)
+        if (needSetAvailableTrue) {
+            try {
+                await this.setStateSafelyAsync(`${device.ieee_address}.available`, true);
+            } catch (e) {
+                this.adapter.log.warn(`Cannot set available for ${device.ieee_address}: ${e}`);
+            }
+        }
 
+        // Parallel ausführen: non-action states
+        try {
+            await Promise.all(stateWrites);
+        } catch (e) {
+            this.adapter.log.warn(`processDeviceMessage: parallel writes encountered error: ${e}`);
+        }
+
+        // ACTION states: auch parallel ausführen, berücksichtige setStateWithTimeoutAsync
+        const actionPromises = [];
         for (const state of actionStates) {
             const stateName = `${device.ieee_address}.${state.id}`;
-
-            try {
-                const getterPayload = state.getter(messageObj.payload);
-                if (getterPayload !== undefined) {
-                    if (state.isEvent && state.isEvent === true) {
-                        if (state.type === 'boolean') {
-                            await this.setStateWithTimeoutAsync(stateName, getterPayload, 250);
+            actionPromises.push((async () => {
+                try {
+                    const getterPayload = state.getter(messageObj.payload);
+                    if (getterPayload !== undefined) {
+                        if (state.isEvent && state.isEvent === true) {
+                            if (state.type === 'boolean') {
+                                // setStateWithTimeoutAsync kümmert sich intern um Timer/Optimierung
+                                await this.setStateWithTimeoutAsync(stateName, getterPayload, 250);
+                            } else {
+                                await this.setStateSafelyAsync(stateName, getterPayload);
+                            }
                         } else {
-                            await this.setStateSafelyAsync(stateName, getterPayload);
+                            await this.setStateChangedSafelyAsync(stateName, getterPayload);
                         }
-                    } else {
-                        await this.setStateChangedSafelyAsync(stateName, getterPayload);
                     }
+                } catch (err) {
+                    this.adapter.log.warn(`Cannot set action state ${stateName}: ${err}`);
                 }
-            } catch (err) {
-                this.adapter.log.warn(`Cannot set action state ${stateName}: ${err}`);
+            })());
+        }
+
+        if (actionPromises.length > 0) {
+            try {
+                await Promise.all(actionPromises);
+            } catch (e) {
+                this.adapter.log.warn(`processDeviceMessage: action state parallel writes error: ${e}`);
             }
         }
     }
@@ -264,22 +421,33 @@ class StatesController {
             return;
         }
 
-        this.adapter.setState(stateName, value, true);
+        // Prüfen, ob bereits ein Timer läuft (State ist dann schon auf true)
+        const wasAlreadyTrue = !!this.timeOutCache[stateName];
 
-        // Auto-Reset (false → nichts tun, true → nach timeout zurücksetzen)
-        // Wenn value=false (z.B. Stop-Aktion im simpleMoveStopState-Modus),
-        // soll der State dauerhaft false bleiben und NICHT nach timeout auf true springen.
+        // Timer immer clearen, wenn vorhanden
         if (this.timeOutCache[stateName]) {
             this.adapter.clearTimeout(this.timeOutCache[stateName]);
             delete this.timeOutCache[stateName];
         }
+
         if (value === true) {
+            // Nur setState aufrufen, wenn der State NICHT bereits auf true war.
+            // Bei Dauerfeuer (value=true→true schneller als timeout) spart das
+            // den unnötigen setState-Call und verhindert, dass der Timer
+            // nie ausgelöst wird (Timer-Leak).
+            if (!wasAlreadyTrue) {
+                await this.setStateSafelyAsync(stateName, true);
+            }
+            // Neuen Timer für Auto-Reset setzen
             this.timeOutCache[stateName] = this.adapter.setTimeout(() => {
                 delete this.timeOutCache[stateName];
                 this.adapter.setState(stateName, false, true).catch((err) => {
                     this.adapter.log.debug(`setStateWithTimeout reset error for ${stateName}: ${err}`);
                 });
             }, timeout);
+        } else {
+            // value === false: State setzen, Timer bereits gelöscht
+            await this.setStateSafelyAsync(stateName, false);
         }
     }
 

package/lib/websocketController.js

@@ -147,6 +147,11 @@ class WebsocketController {
         for (const key of Object.keys(this.adapter.createCache)) {
             delete this.adapter.createCache[key];
         }
+        // Topic->Device Map-Cache des StatesController invalidieren, da deviceCache/groupCache
+        // neu aufgebaut werden (verhindert veraltete Referenzen auf alte Geräteobjekte)
+        if (this.adapter.statesController && typeof this.adapter.statesController.clearDeviceMap === 'function') {
+            this.adapter.statesController.clearDeviceMap();
+        }
 
         // Nur reconnecten wenn kein intentionales Shutdown
         if (!this._intentionalClose) {

package/lib/z2mController.js

@@ -105,7 +105,15 @@ class Z2mController {
             for (const option of deviceState.options) {
                 // Fix: "in"-Prüfung statt === undefined, damit null als gültiger gecachter Wert behandelt wird
                 if (!(option in device.optionsValues)) {
-                    const optState = await this.adapter.getStateAsync(`${splitedID[0]}.${splitedID[1]}.${splitedID[2]}.${option}`);
+                    let optState;
+                    try {
+                        optState = await this.adapter.getStateAsync(`${splitedID[0]}.${splitedID[1]}.${splitedID[2]}.${option}`);
+                    } catch (e) {
+                        this.adapter.log.warn(
+                            `Cannot read state for option "${option}": ${e.message}`
+                        );
+                        optState = null;
+                    }
                     device.optionsValues[option] = optState ? optState.val : null;
                 }
 

package/main.js

@@ -40,6 +40,7 @@ class Zigbee2mqtt extends core.Adapter {
         this.websocketController = null;
         this.mqttServerController = null;
         this.messageParseMutex = Promise.resolve();
+        this.mqttReconnectAttempts = 0;
 
         this.on('ready', () => {
             this.onReady().catch((e) => this.log.error(`onReady error: ${e}`));
@@ -124,7 +125,12 @@ class Zigbee2mqtt extends core.Adapter {
             } else {
                 // Internal MQTT-Server
                 this.mqttServerController = new MqttServerController(this);
-                await this.mqttServerController.createMQTTServer();
+                const serverStarted = await this.mqttServerController.createMQTTServer();
+                if (!serverStarted) {
+                    this.log.error('Internal MQTT server could not be started. The adapter cannot connect to Zigbee2MQTT.');
+                    this.setState('info.connection', false, true);
+                    return;
+                }
                 // Kurze Pause damit der OS-Socket tatsächlich bereit ist (createMQTTServer wartet bereits auf listen)
                 await this.delay(200);
                 this.mqttClient = mqtt.connect(`mqtt://${this.config.mqttServerIPBind}:${this.config.mqttServerPort}`, {
@@ -137,6 +143,7 @@ class Zigbee2mqtt extends core.Adapter {
 
             // MQTT Client Events
             this.mqttClient.on('connect', () => {
+                this.mqttReconnectAttempts = 0;
                 this.log.info(
                     `Connect to Zigbee2MQTT over ${this.config.connectionType === 'exmqtt' ? 'external mqtt' : 'internal mqtt'} connection.`
                 );
@@ -155,7 +162,20 @@ class Zigbee2mqtt extends core.Adapter {
             });
 
             this.mqttClient.on('reconnect', () => {
-                this.log.info('MQTT client reconnecting to Zigbee2MQTT...');
+                this.mqttReconnectAttempts++;
+                if (this.mqttReconnectAttempts > 20) {
+                    this.log.error(
+                        `MQTT client gave up after ${this.mqttReconnectAttempts} reconnect attempts (10 seconds). ` +
+                        `Please check whether Zigbee2MQTT is running and the MQTT connection settings are correct.`
+                    );
+                    if (this.mqttClient) {
+                        this.mqttClient.end(true);
+                    }
+                    return;
+                }
+                this.log.info(
+                    `MQTT client reconnecting to Zigbee2MQTT... (attempt ${this.mqttReconnectAttempts}/20)`
+                );
             });
 
             this.mqttClient.on('offline', async () => {
@@ -214,7 +234,12 @@ class Zigbee2mqtt extends core.Adapter {
 
             if (this.config.dummyMqtt === true) {
                 this.mqttServerController = new MqttServerController(this);
-                await this.mqttServerController.createDummyMQTTServer();
+                const serverStarted = await this.mqttServerController.createDummyMQTTServer();
+                if (!serverStarted) {
+                    this.log.error('Dummy MQTT server could not be started – WebSocket mode cannot continue.');
+                    this.setState('info.connection', false, true);
+                    return;
+                }
                 await this.delay(200);
             }
 
@@ -527,7 +552,7 @@ class Zigbee2mqtt extends core.Adapter {
                         this.mqttClient.removeAllListeners();
                         this.mqttClient.end(true);
                     } catch (e) {
-                        this.log.error(e);
+                        this.log.error(`[onUnload] Fehler beim Schließen des MQTT-Clients: ${e.message}`);
                     }
                 }
             }
@@ -537,15 +562,16 @@ class Zigbee2mqtt extends core.Adapter {
                         this.mqttServerController.closeServer();
                     }
                 } catch (e) {
-                    this.log.error(e);
+                    this.log.error(`[onUnload] Fehler beim Schließen des MQTT-Servers: ${e.message}`);
                 }
-            } else if (this.config.connectionType === 'ws') {
+            }
+            if (this.config.connectionType === 'ws') {
                 try {
                     if (this.websocketController) {
                         this.websocketController.closeConnection();
                     }
                 } catch (e) {
-                    this.log.error(e);
+                    this.log.error(`[onUnload] Fehler beim Schließen der WebSocket-Verbindung: ${e.message}`);
                 }
             }
             try {
@@ -553,21 +579,21 @@ class Zigbee2mqtt extends core.Adapter {
                     await this.statesController.setAllAvailableToFalse();
                 }
             } catch (e) {
-                this.log.error(e);
+                this.log.error(`[onUnload] Fehler beim Setzen aller States auf false: ${e.message}`);
             }
             try {
                 if (this.websocketController) {
                     this.websocketController.allTimerClear();
                 }
             } catch (e) {
-                this.log.error(e);
+                this.log.error(`[onUnload] Fehler beim Zurücksetzen der WebSocket-Timer: ${e.message}`);
             }
             try {
                 if (this.statesController) {
                     this.statesController.allTimerClear();
                 }
             } catch (e) {
-                this.log.error(e);
+                this.log.error(`[onUnload] Fehler beim Zurücksetzen der States-Timer: ${e.message}`);
             }
 
             this.setState('info.connection', false, true);
@@ -595,14 +621,14 @@ class Zigbee2mqtt extends core.Adapter {
         if (state && state.ack === false) {
             if (id.endsWith('info.debugmessages')) {
                 this.logCustomizations.debugDevices = state.val != null ? String(state.val) : '';
-                this.setState(id, state.val, true);
+                await this.setState(id, state.val, true).catch(e => this.log.error(`[stateChange] Fehler beim Setzen von ${id}: ${e.message}`));
                 return;
             }
             if (id.endsWith('info.logfilter')) {
                 this.logCustomizations.logfilter = state.val != null
                     ? String(state.val).split(';').filter((x) => x)
                     : [];
-                this.setState(id, state.val, true);
+                await this.setState(id, state.val, true).catch(e => this.log.error(`[stateChange] Fehler beim Setzen von ${id}: ${e.message}`));
                 return;
             }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.zigbee2mqtt",
-  "version": "3.2.2",
+  "version": "3.2.5",
   "description": "Zigbee2MQTT adapter for ioBroker",
   "author": {
     "name": "Dennis Rathjen and Arthur Rupp",
@@ -24,27 +24,27 @@
     "node": ">= 22"
   },
   "dependencies": {
-    "@iobroker/adapter-core": "^3.3.2",
-    "@iobroker/dm-utils": "^3.0.17",
+    "@iobroker/adapter-core": "^3.4.1",
+    "@iobroker/dm-utils": "^3.1.3",
     "aedes": "^0.51.3",
     "aedes-persistence": "^9.1.2",
-    "axios": "^1.16.0",
-    "mqtt": "^5.15.1",
+    "axios": "^1.18.1",
+    "mqtt": "^5.15.2",
     "net": "^1.0.2",
     "node-schedule": "^2.1.1",
     "sharp": "^0.34.5",
-    "ws": "^8.20.0"
+    "ws": "^8.21.0"
   },
   "devDependencies": {
-    "@alcalzone/release-script": "^5.2.0",
+    "@alcalzone/release-script": "^5.2.1",
     "@alcalzone/release-script-plugin-iobroker": "^5.2.0",
     "@alcalzone/release-script-plugin-license": "^5.2.0",
     "@alcalzone/release-script-plugin-manual-review": "^5.2.0",
     "@iobroker/adapter-dev": "^1.5.0",
     "@iobroker/eslint-config": "^2.3.4",
-    "@iobroker/testing": "^5.1.1",
-    "@tsconfig/node14": "^14.1.8",
-    "@types/node": "^25.6.2",
+    "@iobroker/testing": "^5.2.2",
+    "@tsconfig/node22": "^22.0.5",
+    "@types/node": "^25.9.5",
     "@types/node-schedule": "^2.1.8",
     "typescript": "~6.0.3"
   },