iobroker.zigbee2mqtt 0.2.0 → 2.1.0

package/main.js

@@ -7,31 +7,29 @@
 // The adapter-core module gives you access to the core ioBroker functions
 // you need to create an adapter
 const core = require('@iobroker/adapter-core');
-const WebSocket = require('ws');
-const defineDeviceFromExposes = require('./lib/exposes').defineDeviceFromExposes;
-const defineGroupDevice = require('./lib/groups').defineGroupDevice;
-const clearArray = require('./lib/utils').clearArray;
-let wsClient;
-let adapter;
-let createDevicesOrReady = false;
-let isConnected = false;
-const incStatsQueue = [];
-const createCache = {};
+const mqtt = require('mqtt');
+const checkConfig = require('./lib/check').checkConfig;
+const adapterInfo = require('./lib/messages').adapterInfo;
+const zigbee2mqttInfo = require('./lib/messages').zigbee2mqttInfo;
+const Z2mController = require('./lib/z2mController').Z2mController;
+const DeviceController = require('./lib/deviceController').DeviceController;
+const StatesController = require('./lib/statesController').StatesController;
+const WebsocketController = require('./lib/websocketController').WebsocketController;
+const MqttServerController = require('./lib/mqttServerController').MqttServerController;
+
+
+let mqttClient;
 // eslint-disable-next-line prefer-const
 let deviceCache = [];
 // eslint-disable-next-line prefer-const
 let groupCache = [];
-let ping;
-let pingTimeout;
-let autoRestartTimeout;
-const wsHeartbeatIntervall = 5000;
-const restartTimeout = 1000;
-let debugLogEnabled;
-let proxyZ2MLogsEnabled;
-let checkAvailableTimout;
-let debugDevices = '';
-let logfilter = [];
-let useKelvin = false;
+const logCustomizations = { debugDevices: '', logfilter: [] };
+let showInfo = true;
+let statesController;
+let deviceController;
+let z2mController;
+let websocketController;
+let mqttServerController;
 
 class Zigbee2mqtt extends core.Adapter {
 
@@ -46,96 +44,87 @@ class Zigbee2mqtt extends core.Adapter {
 	}
 
 	async onReady() {
+		statesController = new StatesController(this, deviceCache, groupCache, logCustomizations);
+		deviceController = new DeviceController(this, deviceCache, groupCache, this.config);
+		z2mController = new Z2mController(this, deviceCache, groupCache, logCustomizations);
+
 		// Initialize your adapter here
-		adapter = this;
-		this.log.info(`Zigbee2MQTT Frontend Server: ${this.config.server}`);
-		this.log.info(`Zigbee2MQTT Frontend Port: ${this.config.port}`);
-		this.log.info(`Zigbee2MQTT Debug Log: ${this.config.debugLogEnabled ? 'activated' : 'deactivated'}`);
-		this.log.info(`Proxy Zigbee2MQTT Logs to ioBroker Logs: ${this.config.proxyZ2MLogs ? 'activated' : 'deactivated'}`);
-		this.log.info(`Use Kelvin: ${this.config.useKelvin ? 'yes' : 'no'}`);
+		adapterInfo(this.config, this.log);
 
 		this.setStateAsync('info.connection', false, true);
-		this.createWsClient(this.config.server, this.config.port);
-
-		debugLogEnabled = this.config.debugLogEnabled;
-		proxyZ2MLogsEnabled = this.config.proxyZ2MLogs;
-		useKelvin = this.config.useKelvin;
 
 		const debugDevicesState = await this.getStateAsync('info.debugmessages');
 		if (debugDevicesState && debugDevicesState.val) {
-			debugDevices = String(debugDevicesState.val);
+			logCustomizations.debugDevices = String(debugDevicesState.val);
 		}
 
 		const logfilterState = await this.getStateAsync('info.logfilter');
 		if (logfilterState && logfilterState.val) {
-			logfilter = String(logfilterState.val).split(';').filter(x => x); // filter removes empty strings here
+			// @ts-ignore
+			logCustomizations.logfilter = String(logfilterState.val).split(';').filter(x => x); // filter removes empty strings here
 		}
+		// MQTT
+		if (['exmqtt', 'intmqtt'].includes(this.config.connectionType)) {
+			// External MQTT-Server
+			if (this.config.connectionType == 'exmqtt') {
+				if (this.config.externalMqttServerIP == '') {
+					this.log.warn('Please configure the External MQTT-Server connection!');
+					return;
+				}
+				mqttClient = mqtt.connect(`mqtt://${this.config.externalMqttServerIP}:${this.config.externalMqttServerPort}`, { clientId: `ioBroker.zigbee2mqtt_${Math.random().toString(16).slice(2, 8)}`, clean: true, reconnectPeriod: 500 });
 
+			}
+			// Internal MQTT-Server
+			else {
+				mqttServerController = new MqttServerController(this);
+				await mqttServerController.createMQTTServer();
+				await this.delay(1500);
+				mqttClient = mqtt.connect(`mqtt://${this.config.mqttServerIPBind}:${this.config.mqttServerPort}`, { clientId: `ioBroker.zigbee2mqtt_${Math.random().toString(16).slice(2, 8)}`, clean: true, reconnectPeriod: 500 });
+			}
 
-		this.subscribeStatesAsync('*');
-	}
-
-	async createWsClient(server, port) {
-		try {
-			wsClient = new WebSocket(`ws://${server}:${port}/api`);
-			wsClient.on('open', () => {
-				this.logDebug('Websocket connectet');
-				// Set connection state
-				this.setState('info.connection', true, true);
-				this.log.info('Connect to server over websocket connection.');
-				isConnected = true;
-				// Send ping to server
-				this.sendPingToServer();
-				// Start Heartbeat
-				this.wsHeartbeat();
+			// MQTT Client
+			mqttClient.on('connect', () => {
+				this.log.info(`Connect to Zigbee2MQTT over ${this.config.connectionType == 'exmqtt' ? 'external mqtt' : 'internal mqtt'} connection.`);
 			});
-			wsClient.on('pong', () => {
-				//this.logDebug('Receive pong from server');
-				this.wsHeartbeat();
-			});
-			// On Close
-			wsClient.on('close', async () => {
-				this.setState('info.connection', false, true);
-				this.log.warn('Websocket disconnectet');
-				await this.setAllAvailableToFalse();
-				clearTimeout(ping);
-				clearTimeout(pingTimeout);
-				isConnected = false;
 
-				if (wsClient.readyState === WebSocket.CLOSED) {
-					this.autoRestart();
-				}
-			});
+			mqttClient.subscribe('zigbee2mqtt/#');
 
-			wsClient.on('message', (message) => { this.messageParse(message); });
-			wsClient.on('error', (err) => { adapter.logDebug(err); });
-		} catch (err) {
-			this.logDebug(err);
+			mqttClient.on('message', (topic, payload) => {
+				const newMessage = `{"payload":${payload.toString() == '' ? '"null"' : payload.toString()},"topic":"${topic.slice(topic.search('/') + 1)}"}`;
+				this.messageParse(newMessage);
+			});
 		}
-	}
+		// Websocket
+		else if (this.config.connectionType == 'ws') {
+			if (this.config.wsServerIP == '') {
+				this.log.warn('Please configure the Websoket connection!');
+				return;
+			}
 
-	async sendPingToServer() {
-		//this.logDebug('Send ping to server');
-		wsClient.ping();
-		ping = setTimeout(() => {
-			this.sendPingToServer();
-		}, wsHeartbeatIntervall);
-	}
+			// Dummy MQTT-Server
+			if (this.config.dummyMqtt == true) {
+				mqttServerController = new MqttServerController(this);
+				await mqttServerController.createDummyMQTTServer();
+				await this.delay(1500);
+			}
 
-	async wsHeartbeat() {
-		clearTimeout(pingTimeout);
-		pingTimeout = setTimeout(() => {
-			this.logDebug('Websocked connection timed out');
-			wsClient.terminate();
-			clearTimeout(checkAvailableTimout);
-		}, wsHeartbeatIntervall + 1000);
-	}
+			websocketController = new WebsocketController(this);
+			const wsClient = await websocketController.initWsClient(this.config.wsServerIP, this.config.wsServerPort);
 
-	async autoRestart() {
-		this.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
-		autoRestartTimeout = setTimeout(() => {
-			this.onReady();
-		}, restartTimeout);
+			wsClient.on('open', () => {
+				this.log.info('Connect to Zigbee2MQTT over websocket connection.');
+			});
+
+			wsClient.on('message', (message) => {
+				this.messageParse(message);
+			});
+
+			wsClient.on('clo', async () => {
+				this.setStateChangedAsync('info.connection', false, true);
+				await statesController.setAllAvailableToFalse();
+				this.log.warn('Websocket disconnectet');
+			});
+		}
 	}
 
 	async messageParse(message) {
@@ -145,36 +134,45 @@ class Zigbee2mqtt extends core.Adapter {
 			case 'bridge/config':
 				break;
 			case 'bridge/info':
+				if (showInfo) {
+					zigbee2mqttInfo(messageObj.payload, this.log);
+					checkConfig(messageObj.payload.config, this.log);
+					showInfo = false;
+				}
 				break;
 			case 'bridge/state':
+				if (messageObj.payload.state != 'online') {
+					statesController.setAllAvailableToFalse();
+				}
+				this.setStateChangedAsync('info.connection', messageObj.payload.state == 'online', true);
 				break;
 			case 'bridge/devices':
-				// As long as we are busy creating the devices, the states are written to the queue.
-				createDevicesOrReady = false;
-				await this.createDeviceDefinitions(deviceCache, messageObj.payload);
-				await this.createOrUpdateDevices(deviceCache);
-				this.subscribeWritableStates();
-				createDevicesOrReady = true;
-
-				// Now process all entries in the states queue
-				while (incStatsQueue.length > 0) {
-					this.processDeviceMessage(incStatsQueue.shift());
-				}
+				await deviceController.createDeviceDefinitions(messageObj.payload);
+				await deviceController.createOrUpdateDevices();
+				await statesController.subscribeWritableStates();
+				statesController.processQueue();
 				break;
 			case 'bridge/groups':
-				await this.createGroupDefinitions(groupCache, messageObj.payload);
-				await this.createOrUpdateDevices(groupCache);
-				this.subscribeWritableStates();
+				await deviceController.createGroupDefinitions(messageObj.payload);
+				await deviceController.createOrUpdateDevices();
+				await statesController.subscribeWritableStates();
+				statesController.processQueue();
 				break;
 			case 'bridge/event':
+				deviceController.processRemoveEvent(messageObj);
 				break;
 			case 'bridge/extensions':
 				break;
 			case 'bridge/logging':
-				if (proxyZ2MLogsEnabled == true) {
-					this.proxyZ2MLogs(messageObj);
+				if (this.config.proxyZ2MLogs == true) {
+					z2mController.proxyZ2MLogs(messageObj);
 				}
 				break;
+			case 'bridge/response/device/rename':
+				await deviceController.renameDeviceInCache(messageObj);
+				await deviceController.createOrUpdateDevices();
+				statesController.processQueue();
+				break;
 			case 'bridge/response/networkmap':
 				break;
 			case 'bridge/response/touchlink/scan':
@@ -188,296 +186,34 @@ class Zigbee2mqtt extends core.Adapter {
 					// {"payload":{"state":"online"},"topic":"FL.Licht.Links/availability"}  ---->  {"payload":{"available":true},"topic":"FL.Licht.Links"}
 					if (messageObj.topic.endsWith('/availability')) {
 						const topicSplit = messageObj.topic.split('/');
+
+						// If an availability message for an old device ID comes with a payload of NULL, this is the indicator that a device has been unnamed.
+						// If this is then still available in the cache, the messages must first be cached.
+						if (messageObj.payload == 'null') {
+							break;
+						}
+
 						if (topicSplit.length == 2 && messageObj.payload && messageObj.payload.state) {
 							const newMessage = {
 								payload: { available: messageObj.payload.state == 'online' },
 								topic: topicSplit[0]
 							};
-							// As long as we are busy creating the devices, the states are written to the queue.
-							if (createDevicesOrReady == false) {
-								incStatsQueue[incStatsQueue.length] = newMessage;
-								break;
-							}
-							this.processDeviceMessage(newMessage);
+							statesController.processDeviceMessage(newMessage);
 						}
 						// States
 					} else if (!messageObj.topic.includes('/')) {
-						// As long as we are busy creating the devices, the states are written to the queue.
-						if (createDevicesOrReady == false) {
-							incStatsQueue[incStatsQueue.length] = messageObj;
-							break;
-						}
-						this.processDeviceMessage(messageObj);
-					}
-				}
-				break;
-		}
-	}
-
-	async processDeviceMessage(messageObj) {
-		this.logDebug(`processDeviceMessage -> messageObj: ${JSON.stringify(messageObj)}`);
-		// Is payload present?
-		if (messageObj.payload == '') {
-			return;
-		}
-
-		const device = groupCache.concat(deviceCache).find(x => x.id == messageObj.topic);
-		if (device) {
-			this.logDebug(`processDeviceMessage -> device: ${JSON.stringify(device)}`);
-			try {
-				this.setDeviceState(messageObj, device);
-			} catch (error) {
-				adapter.log.error(error);
-			}
-		}
-		else {
-			adapter.log.warn(`Device: ${messageObj.topic} not found`);
-		}
-	}
-
-	async setDeviceState(messageObj, device) {
-
-		if (debugDevices.includes(device.ieee_address)) {
-			this.log.warn(`--->>> fromZ2M -> ${device.ieee_address} states: ${JSON.stringify(messageObj)}`);
-		}
-
-		for (const [key, value] of Object.entries(messageObj.payload)) {
-			this.logDebug(`setDeviceState -> key: ${key}`);
-			this.logDebug(`setDeviceState -> value: ${JSON.stringify(value)}`);
-
-			let states;
-			if (key == 'action') {
-				states = device.states.filter(x => (x.prop && x.prop == key) && x.id == value);
-			} else {
-				states = device.states.filter(x => (x.prop && x.prop == key) || x.id == key);
-			}
-			this.logDebug(`setDeviceState -> states: ${JSON.stringify(states)}`);
-
-			for (const state of states) {
-				if (!state) {
-					continue;
-				}
-
-				const stateName = `${device.ieee_address}.${state.id}`;
-
-				try {
-					if (state.getter) {
-						await this.setStateAsync(stateName, state.getter(messageObj.payload), true);
-					}
-					else {
-						await this.setStateAsync(stateName, value, true);
+						statesController.processDeviceMessage(messageObj);
 					}
-				} catch (err) {
-					this.log.warn(`Can not set ${stateName}`);
-				}
-			}
-		}
-	}
-
-	async createDeviceDefinitions(cache, exposes) {
-		clearArray(cache);
-		for (const expose of exposes) {
-			if (expose.definition != null) {
-				// search for scenes in the endpoints and build them into an array
-				let scenes = [];
-				for (const key in expose.endpoints) {
-					if (expose.endpoints[key].scenes) {
-						scenes = scenes.concat(expose.endpoints[key].scenes);
-					}
-				}
-
-				await defineDeviceFromExposes(cache, expose.friendly_name, expose.ieee_address, expose.definition, expose.power_source, scenes, useKelvin);
-			}
-		}
-	}
-
-	async createGroupDefinitions(cache, exposes) {
-		clearArray(cache);
-		for (const expose of exposes) {
-			await defineGroupDevice(cache, expose.friendly_name, `group_${expose.id}`, expose.scenes, useKelvin);
-		}
-	}
-
-	async createOrUpdateDevices(cache) {
-		for (const device of cache) {
-			const deviceName = device.id == device.ieee_address ? '' : device.id;
-			if (!createCache[device.ieee_address] || createCache[device.ieee_address].common.name != deviceName) {
-				const deviceObj = {
-					type: 'device',
-					common: {
-						name: deviceName,
-					},
-
-					native: {}
-				};
-
-				if (!device.ieee_address.includes('group_')) {
-					deviceObj.common.statusStates = {
-						onlineId: `${this.name}.${this.instance}.${device.ieee_address}.available`
-					};
 				}
-
-				//@ts-ignore
-				await this.extendObjectAsync(device.ieee_address, deviceObj);
-				createCache[device.ieee_address] = deviceObj;
-			}
-
-			// Here it is checked whether the scenes match the current data from z2m.
-			// If necessary, scenes are automatically deleted from ioBroker.
-			const sceneStates = await this.getStatesAsync(`${device.ieee_address}.scene_*`);
-			const sceneIDs = Object.keys(sceneStates);
-			for (const sceneID of sceneIDs) {
-				const stateID = sceneID.split('.')[3];
-				if (device.states.find(x => x.id == stateID) == null) {
-					this.delObject(sceneID);
-				}
-			}
-
-			for (const state of device.states) {
-				if (!createCache[device.ieee_address][state.id] || createCache[device.ieee_address][state.id].name != state.name) {
-					const iobState = await this.copyAndCleanStateObj(state);
-					this.logDebug(`Orig. state: ${JSON.stringify(state)}`);
-					this.logDebug(`Cleaned. state: ${JSON.stringify(iobState)}`);
-
-					await this.extendObjectAsync(`${device.ieee_address}.${state.id}`, {
-						type: 'state',
-						common: iobState,
-						native: {},
-					});
-					createCache[device.ieee_address][state.id] = state.name;
-				}
-			}
-		}
-	}
-
-	async copyAndCleanStateObj(state) {
-		const iobState = { ...state };
-		const blacklistedKeys = [
-			'setter',
-			'setterOpt',
-			'getter',
-			'setattr',
-			'readable',
-			'writable',
-			'isOption',
-			'inOptions'
-		];
-		for (const blacklistedKey of blacklistedKeys) {
-			delete iobState[blacklistedKey];
-		}
-		return iobState;
-	}
-
-	async subscribeWritableStates() {
-		await this.unsubscribeObjectsAsync('*');
-
-		for (const device of groupCache.concat(deviceCache)) {
-			for (const state of device.states) {
-				if (state.write == true) {
-					this.subscribeStatesAsync(`${device.ieee_address}.${state.id}`);
-				}
-			}
-		}
-	}
-
-	async createZ2MMessage(id, state) {
-
-		const splitedID = id.split('.');
-
-		if (splitedID.length < 4) {
-			this.log.warn(`state ${id} not valid`);
-			return;
-		}
-
-		const ieee_address = splitedID[2];
-		const stateName = splitedID[3];
-
-		const device = groupCache.concat(deviceCache).find(d => d.ieee_address == ieee_address);
-
-		if (!device) {
-			return;
-		}
-
-		const deviceState = device.states.find(s => s.id == stateName);
-
-		if (!deviceState) {
-			return;
-		}
-
-		let stateVal = state.val;
-		if (deviceState.setter) {
-			stateVal = deviceState.setter(state.val);
-		}
-
-
-		let stateID = deviceState.id;
-		if (deviceState.prop) {
-			stateID = deviceState.prop;
-		}
-
-		let topic = `${device.ieee_address}/set`;
-		if (device.ieee_address.includes('group_')) {
-			topic = `${device.id}/set`;
-		}
-
-		const controlObj = {
-			payload: {
-				[stateID]: stateVal
-			},
-			topic: topic
-		};
-		// set stats with the mentioned role or ids always immediately to ack = true, because these are not reported back by Zigbee2MQTT
-		if (isConnected == true && (['button'].includes(deviceState.role) || ['brightness_move', 'color_temp_move'].includes(stateID))) {
-			this.setState(id, state, true);
-		}
-
-		return JSON.stringify(controlObj);
-	}
-
-	async proxyZ2MLogs(messageObj) {
-		this.logDebug(`proxyZ2MLogs -> messageObj: ${JSON.stringify(messageObj)}`);
-
-		const logMessage = messageObj.payload.message;
-		if (logfilter.some(x => logMessage.includes(x))) {
-			return;
-		}
-
-		const logLevel = messageObj.payload.level;
-		switch (logLevel) {
-			case 'debug':
-			case 'info':
-			case 'error':
-				this.log[logLevel](logMessage);
-				break;
-			case 'warning':
-				this.log.warn(logMessage);
 				break;
 		}
 	}
 
-	async logDebug(message) {
-		if (debugLogEnabled == true) {
-			this.log.debug(message);
-		}
-	}
-
-	async setAllAvailableToFalse() {
-		for (const device of deviceCache) {
-			for (const state of device.states) {
-				if (state.id == 'available') {
-					await this.setStateAsync(`${device.ieee_address}.${state.id}`, false, true);
-				}
-			}
-		}
-	}
-
 	async onUnload(callback) {
 		try {
-			await this.setAllAvailableToFalse();
-			clearTimeout(ping);
-			clearTimeout(pingTimeout);
-			clearTimeout(autoRestartTimeout);
-			clearTimeout(checkAvailableTimout);
+			await statesController.setAllAvailableToFalse();
+			await websocketController.allTimerClear();
+			await statesController.allTimerClear();
 			callback();
 		} catch (e) {
 			callback();
@@ -486,16 +222,23 @@ class Zigbee2mqtt extends core.Adapter {
 
 	async onStateChange(id, state) {
 		if (state && state.ack == false) {
-			const message = await this.createZ2MMessage(id, state);
-			wsClient.send(message);
-
 			if (id.includes('info.debugmessages')) {
-				debugDevices = state.val;
+				logCustomizations.debugDevices = state.val;
 				this.setState(id, state.val, true);
+				return;
 			}
 			if (id.includes('info.logfilter')) {
-				logfilter = state.val.split(';').filter(x => x); // filter removes empty strings here
+				logCustomizations.logfilter = state.val.split(';').filter(x => x); // filter removes empty strings here
 				this.setState(id, state.val, true);
+				return;
+			}
+
+			const message = await z2mController.createZ2MMessage(id, state) || { topic: '', payload: '' };
+
+			if (['exmqtt', 'intmqtt'].includes(this.config.connectionType)) {
+				mqttClient.publish(`zigbee2mqtt/${message.topic}`, JSON.stringify(message.payload));
+			} else if (this.config.connectionType == 'ws') {
+				websocketController.send(JSON.stringify(message));
 			}
 		}
 	}
@@ -511,4 +254,4 @@ if (require.main !== module) {
 } else {
 	// otherwise start the instance directly
 	new Zigbee2mqtt();
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.zigbee2mqtt",
-  "version": "0.2.0",
+  "version": "2.1.0",
   "description": "Zigbee2MQTT adapter for ioBroker",
   "author": {
     "name": "Dennis Rathjen",
@@ -19,12 +19,16 @@
     "url": "https://github.com/o0shojo0o/ioBroker.zigbee2mqtt.git"
   },
   "dependencies": {
-    "@alcalzone/release-script-plugin-iobroker": "^3.5.9",
-    "@alcalzone/release-script-plugin-license": "^3.5.9",
-    "@iobroker/adapter-core": "^2.6.6",
+    "@iobroker/adapter-core": "^2.6.7",
+    "aedes": "^0.48.0",
+    "aedes-persistence-nedb": "^2.0.3",
+    "mqtt": "^4.3.7",
+    "net": "^1.0.2",
     "ws": "^8.9.0"
   },
   "devDependencies": {
+    "@alcalzone/release-script-plugin-iobroker": "^3.5.9",
+    "@alcalzone/release-script-plugin-license": "^3.5.9",
     "@alcalzone/release-script": "^3.5.9",
     "@iobroker/adapter-dev": "^1.1.0",
     "@iobroker/testing": "^4.1.0",
@@ -32,19 +36,19 @@
     "@types/chai": "^4.3.3",
     "@types/chai-as-promised": "^7.1.5",
     "@types/mocha": "^10.0.0",
-    "@types/node": "^18.7.23",
+    "@types/node": "^18.8.3",
     "@types/proxyquire": "^1.3.28",
     "@types/sinon": "^10.0.13",
     "@types/sinon-chai": "^3.2.8",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
-    "eslint": "^8.24.0",
+    "eslint": "^8.25.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",
     "mocha": "^10.0.0",
     "prettier": "^2.7.1",
     "proxyquire": "^2.1.3",
-    "sinon": "^14.0.0",
+    "sinon": "^14.0.1",
     "sinon-chai": "^3.7.0",
     "typescript": "~4.8.4"
   },