iobroker.device-watcher 2.8.3 → 2.8.5

package/main.js

@@ -342,7 +342,7 @@ class DeviceWatcher extends utils.Adapter {
 		} else {
 			try {
 				// The object was deleted
-				this.log.info(`object ${id} deleted`);
+				this.log.debug(`object ${id} deleted`);
 
 				// delete instance data in map
 				if (this.listInstanceRaw.has(id)) {
@@ -379,9 +379,8 @@ class DeviceWatcher extends utils.Adapter {
 			let oldStatus;
 			let isLowBatValue;
 			let instanceStatusRaw;
-			let oldInstanceHostState;
-			let oldInstanceDeviceState;
 			let oldAdapterUpdatesCounts;
+			let oldIsHealthyValue;
 
 			try {
 				// adapter updates
@@ -404,74 +403,32 @@ class DeviceWatcher extends utils.Adapter {
 				}
 
 				// instances
-				for (const [instance, instanceData] of this.listInstanceRaw) {
+				for (const [instanceID, instanceData] of this.listInstanceRaw) {
 					switch (id) {
-						// instance alive
-						case instanceData.instanceAlivePath:
-							if (state.val !== instanceData.isAlive) {
-								instanceStatusRaw = await this.setInstanceStatus(
-									instanceData.instanceMode,
-									instanceData.schedule,
-									instanceData.instanceAlivePath,
-									instanceData.connectedHostPath,
-									instanceData.connectedDevicePath,
-								);
-								instanceData.isAlive = instanceStatusRaw[1];
-								instanceData.status = instanceStatusRaw[0];
-								instanceData.isHealthy = instanceStatusRaw[2];
-							}
-							if (this.config.checkSendInstanceDeactivatedMsg && !this.blacklistInstancesNotify.includes(instanceData.instanceAlivePath)) {
-								if (!instanceData.isHealthy) {
-									await this.sendStateNotifications('deactivatedInstance', instance);
+						case `system.adapter.${instanceID}.alive`:
+						case `system.adapter.${instanceID}.connected`:
+						case `${instanceID}.info.connection`:
+							if (!instanceData.checkIsRunning) {
+								instanceData.checkIsRunning = true;
+								oldIsHealthyValue = instanceData.isHealthy;
+								instanceStatusRaw = await this.setInstanceStatus(instanceData.instanceMode, instanceData.schedule, instanceID);
+								instanceData.isAlive = instanceStatusRaw[0];
+								instanceData.isHealthy = instanceStatusRaw[1];
+								instanceData.status = instanceStatusRaw[2];
+
+								if (oldIsHealthyValue === instanceData.isHealthy) continue;
+								// send message when instance was deactivated
+								if (this.config.checkSendInstanceDeactivatedMsg && !instanceData.isAlive) {
+									if (this.blacklistInstancesNotify.includes(instanceID)) continue;
+									await this.sendStateNotifications('deactivatedInstance', instanceID);
 								}
-							}
-							break;
-						// instance connected host
-						case instanceData.connectedHostPath:
-							oldInstanceHostState = instanceData.isConnectedHost;
-							instanceData.isConnectedHost = state.val;
-							if (oldInstanceHostState !== instanceData.isConnectedHost) {
-								instanceStatusRaw = await this.setInstanceStatus(
-									instanceData.instanceMode,
-									instanceData.schedule,
-									instanceData.instanceAlivePath,
-									instanceData.connectedHostPath,
-									instanceData.connectedDevicePath,
-								);
-								instanceData.isAlive = instanceStatusRaw[1];
-								instanceData.status = instanceStatusRaw[0];
-								instanceData.isHealthy = instanceStatusRaw[2];
-
-								if (!instanceData.isAlive) continue;
-								if (this.config.checkSendInstanceFailedMsg && !this.blacklistInstancesNotify.includes(instanceData.instanceAlivePath)) {
-									if (!instanceData.isHealthy) {
-										await this.sendStateNotifications('errorInstance', instance);
-									}
-								}
-							}
-							break;
-						// instance connected device
-						case instanceData.connectedDevicePath:
-							oldInstanceDeviceState = instanceData.isConnectedDevice;
-							instanceData.isConnectedDevice = state.val;
-							if (oldInstanceDeviceState !== instanceData.isConnectedDevice) {
-								instanceStatusRaw = await this.setInstanceStatus(
-									instanceData.instanceMode,
-									instanceData.schedule,
-									instanceData.instanceAlivePath,
-									instanceData.connectedHostPath,
-									instanceData.connectedDevicePath,
-								);
-								instanceData.isAlive = instanceStatusRaw[1];
-								instanceData.status = instanceStatusRaw[0];
-								instanceData.isHealthy = instanceStatusRaw[2];
-
-								if (!instanceData.isAlive) continue;
-								if (this.config.checkSendInstanceFailedMsg && !this.blacklistInstancesNotify.includes(instanceData.instanceAlivePath)) {
-									if (!instanceData.isHealthy) {
-										await this.sendStateNotifications('errorInstance', instance);
-									}
+								// send message when instance has an error
+								if (this.config.checkSendInstanceFailedMsg && instanceData.isAlive && !instanceData.isHealthy) {
+									if (this.blacklistInstancesNotify.includes(instanceID)) continue;
+									await this.sendStateNotifications('errorInstance', instanceID);
 								}
+
+								instanceData.checkIsRunning = false;
 							}
 							break;
 					}
@@ -648,12 +605,11 @@ class DeviceWatcher extends utils.Adapter {
 			case 'instancesList':
 				if (obj.message) {
 					try {
-						for (const instanceData of this.listInstanceRaw.values()) {
-							const label = `${instanceData.Adapter}: ${instanceData.InstanceName}`;
+						for (const [instance, instanceData] of this.listInstanceRaw) {
+							const label = `${instanceData.Adapter}: ${instance}`;
 							const valueObjectInstances = {
 								adapter: instanceData.Adapter,
-								instanceName: instanceData.InstanceName,
-								path: instanceData.instanceAlivePath,
+								instanceID: instance,
 							};
 							instances[countInstances] = { label: label, value: JSON.stringify(valueObjectInstances) };
 							countInstances++;
@@ -673,12 +629,11 @@ class DeviceWatcher extends utils.Adapter {
 			case 'instancesListTime':
 				if (obj.message) {
 					try {
-						for (const instanceData of this.listInstanceRaw.values()) {
-							const label = `${instanceData.Adapter}: ${instanceData.InstanceName}`;
+						for (const [instance, instanceData] of this.listInstanceRaw) {
+							const label = `${instanceData.Adapter}: ${instance}`;
 							const valueObjectInstances = {
 								adapter: instanceData.Adapter,
-								instanceName: instanceData.InstanceName,
-								path: instanceData.instanceAlivePath,
+								instanceName: instance,
 							};
 							instancesTime[countInstances] = { label: label, value: JSON.stringify(valueObjectInstances) };
 							countInstances++;
@@ -820,11 +775,11 @@ class DeviceWatcher extends utils.Adapter {
 					const blacklistParse = this.parseData(myBlacklistInstances[i].instances);
 					// push devices in list to ignor device in lists
 					if (myBlacklistInstances[i].checkIgnorLists) {
-						this.blacklistInstancesLists.push(blacklistParse.path);
+						this.blacklistInstancesLists.push(blacklistParse.instanceID);
 					}
 					// push devices in list to ignor device in notifications
 					if (myBlacklistInstances[i].checkIgnorNotify) {
-						this.blacklistInstancesNotify.push(blacklistParse.path);
+						this.blacklistInstancesNotify.push(blacklistParse.instanceID);
 					}
 				} catch (error) {
 					this.errorReporting('[createBlacklist]', error);
@@ -847,18 +802,15 @@ class DeviceWatcher extends utils.Adapter {
 				try {
 					const userTimeListparse = this.parseData(userTimeListInstances[i].instancesTime);
 					// push devices in list to ignor device in lists
-					if (userTimeListInstances[i].errorTime) {
-						this.userTimeInstancesList.set(userTimeListparse.path, {
-							instanceName: userTimeListparse.instanceName,
-							deactivationTime: userTimeListInstances[i].deactivationTime,
-							errorTime: userTimeListInstances[i].errorTime,
-						});
-					}
+					this.userTimeInstancesList.set(userTimeListparse.instanceName, {
+						deactivationTime: userTimeListInstances[i].deactivationTime,
+						errorTime: userTimeListInstances[i].errorTime,
+					});
 				} catch (error) {
 					this.errorReporting('[createTimeListInstances]', error);
 				}
 			}
-			if (this.userTimeInstancesList.size >= 1) this.log.info(`Found instances items on lists for timesettings: ${this.blacklistInstancesLists}`);
+			if (this.userTimeInstancesList.size >= 1) this.log.info(`Found instances items on lists for timesettings: ${Array.from(this.userTimeInstancesList.keys())}`);
 		}
 	}
 
@@ -2038,14 +1990,14 @@ class DeviceWatcher extends utils.Adapter {
 				if (!(typeof id === 'string' && id.startsWith(`system.adapter.`))) continue;
 
 				// get instance name
-				const instanceName = await this.getInstanceName(id);
+				const instanceID = await this.getInstanceName(id);
 
 				// get instance connected to host data
-				const instanceConnectedHostDP = `system.adapter.${instanceName}.connected`;
+				const instanceConnectedHostDP = `system.adapter.${instanceID}.connected`;
 				const instanceConnectedHostVal = await this.getInitValue(instanceConnectedHostDP);
 
 				// get instance connected to device data
-				const instanceConnectedDeviceDP = `${instanceName}.info.connection`;
+				const instanceConnectedDeviceDP = `${instanceID}.info.connection`;
 				let instanceConnectedDeviceVal;
 				if (instanceConnectedDeviceDP !== undefined && typeof instanceConnectedDeviceDP === 'boolean') {
 					instanceConnectedDeviceVal = await this.getInitValue(instanceConnectedDeviceDP);
@@ -2054,7 +2006,7 @@ class DeviceWatcher extends utils.Adapter {
 				}
 
 				// get adapter version
-				const instanceObjectPath = `system.adapter.${instanceName}`;
+				const instanceObjectPath = `system.adapter.${instanceID}`;
 				let adapterName;
 				let adapterVersion;
 				let adapterAvailableUpdate = '';
@@ -2082,11 +2034,20 @@ class DeviceWatcher extends utils.Adapter {
 					adapterAvailableUpdate = ' - ';
 				}
 
-				//const adapterVersionVal = await this.getInitValue(adapterVersionDP);
-				const instanceStatusRaw = await this.setInstanceStatus(instanceMode, scheduleTime, id, instanceConnectedHostDP, instanceConnectedDeviceDP);
-				const isAlive = instanceStatusRaw[1];
-				const instanceStatus = instanceStatusRaw[0];
-				const isHealthy = instanceStatusRaw[2];
+				let isAlive;
+				let isHealthy;
+				let instanceStatus;
+				if (instanceMode === 'schedule') {
+					const instanceStatusRaw = await this.checkScheduleisHealty(instanceID, scheduleTime);
+					isAlive = instanceStatusRaw[0];
+					isHealthy = instanceStatusRaw[1];
+					instanceStatus = instanceStatusRaw[2];
+				} else if (instanceMode === 'daemon') {
+					const instanceStatusRaw = await this.checkDaemonIsHealthy(instanceID);
+					isAlive = instanceStatusRaw[0];
+					isHealthy = instanceStatusRaw[1];
+					instanceStatus = instanceStatusRaw[2];
+				}
 
 				//subscribe to statechanges
 				this.subscribeForeignStates(id);
@@ -2095,22 +2056,19 @@ class DeviceWatcher extends utils.Adapter {
 				this.subscribeForeignObjects(`system.adapter.*`);
 
 				// create raw list
-				this.listInstanceRaw.set(instanceObjectPath, {
+				this.listInstanceRaw.set(instanceID, {
 					Adapter: adapterName,
-					InstanceName: instanceName,
 					instanceObjectPath: instanceObjectPath,
-					instanceAlivePath: id,
 					instanceMode: instanceMode,
 					schedule: scheduleTime,
 					adapterVersion: adapterVersion,
 					updateAvailable: adapterAvailableUpdate,
 					isAlive: isAlive,
 					isHealthy: isHealthy,
-					connectedHostPath: instanceConnectedHostDP,
 					isConnectedHost: instanceConnectedHostVal,
-					connectedDevicePath: instanceConnectedDeviceDP,
 					isConnectedDevice: instanceConnectedDeviceVal,
 					status: instanceStatus,
+					checkIsRunning: false,
 				});
 			}
 			await this.createInstanceList();
@@ -2132,136 +2090,197 @@ class DeviceWatcher extends utils.Adapter {
 	}
 
 	/**
-	 * Check if instance is alive
-	 * @param {any} instanceAlivePath
-	 * @param {number} instanceDeactivationTime
+	 * Check if instance is alive and ok
+	 * @param {string} instanceID
 	 */
-	async checkIsAlive(instanceAlivePath, instanceDeactivationTime) {
-		let aliveState = await this.getInitValue(instanceAlivePath);
-		if (aliveState) return true;
+	async checkDaemonIsHealthy(instanceID) {
+		const aliveState = await this.getInitValue(`system.adapter.${instanceID}.alive`);
+		const connectedHostState = await this.getInitValue(`system.adapter.${instanceID}.connected`);
+		let connectedDeviceState = await this.getInitValue(`${instanceID}.info.connection`);
+		if (connectedDeviceState === undefined) connectedDeviceState = true;
+
+		let isAlive = false;
+		let isHealthy = false;
+		let instanceStatusString = 'Instanz deaktiviert';
 
-		await this.delay(instanceDeactivationTime);
-		aliveState = await this.getInitValue(instanceAlivePath);
 		if (!aliveState) {
+			isAlive = false;
+			isHealthy = false;
+			instanceStatusString = 'Instanz deaktiviert';
+		} else {
+			if (connectedHostState && connectedDeviceState) {
+				isAlive = true;
+				isHealthy = true;
+				instanceStatusString = 'Instanz okay';
+			} else if (!connectedHostState) {
+				isAlive = true;
+				isHealthy = false;
+				instanceStatusString = 'Nicht verbunden mit Host';
+			} else if (!connectedDeviceState) {
+				isAlive = true;
+				isHealthy = false;
+				instanceStatusString = 'Nicht verbunden mit Gerät oder Dienst';
+			}
+		}
+
+		return [isAlive, isHealthy, instanceStatusString];
+	}
+
+	/**
+	 * Check if instance is alive and ok
+	 * @param {string} instanceID
+	 * @param {number} instanceDeactivationTime
+	 */
+	async checkDaemonIsAlive(instanceID, instanceDeactivationTime) {
+		const aliveState = await this.getInitValue(`system.adapter.${instanceID}.alive`);
+		let daemonIsAlive;
+
+		let isAlive = false;
+		let isHealthy = false;
+		let instanceStatusString = 'Instanz deaktiviert';
+
+		if (aliveState) {
+			daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
+			isAlive = Boolean(daemonIsAlive[0]);
+			isHealthy = Boolean(daemonIsAlive[1]);
+			instanceStatusString = String(daemonIsAlive[2]);
+		} else if (!aliveState) {
 			await this.delay(instanceDeactivationTime);
-			aliveState = await this.getInitValue(instanceAlivePath);
-			if (!aliveState) {
-				return false; // if instance is turned off
+			daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
+			if (!daemonIsAlive[0]) {
+				await this.delay(instanceDeactivationTime);
+				daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
+				if (!daemonIsAlive[0]) {
+					isAlive = Boolean(daemonIsAlive[0]);
+					isHealthy = Boolean(daemonIsAlive[1]);
+					instanceStatusString = String(daemonIsAlive[2]);
+				} else {
+					isAlive = Boolean(daemonIsAlive[0]);
+					isHealthy = Boolean(daemonIsAlive[1]);
+					instanceStatusString = String(daemonIsAlive[2]);
+				}
 			} else {
-				return true;
+				isAlive = Boolean(daemonIsAlive[0]);
+				isHealthy = Boolean(daemonIsAlive[1]);
+				instanceStatusString = String(daemonIsAlive[2]);
+			}
+		}
+
+		return [isAlive, isHealthy, instanceStatusString];
+	}
+
+	async checkScheduleisHealty(instanceID, scheduleTime) {
+		let lastUpdate;
+		let previousCronRun = null;
+		let lastCronRun;
+		let diff;
+		let isAlive = false;
+		let isHealthy = false;
+		let instanceStatusString = 'Instanz deaktiviert';
+
+		const isAliveSchedule = await this.getForeignStateAsync(`system.adapter.${instanceID}.alive`);
+
+		if (isAliveSchedule) {
+			lastUpdate = Math.round((Date.now() - isAliveSchedule.lc) / 1000); // Last state change in seconds
+			previousCronRun = this.getPreviousCronRun(scheduleTime); // When was the last cron run
+			if (previousCronRun) {
+				lastCronRun = Math.round(previousCronRun / 1000); // change distance to last run in seconds
+				diff = lastCronRun - lastUpdate;
+				if (diff > -300) {
+					// if 5 minutes difference exceeded, instance is not alive
+					isAlive = true;
+					isHealthy = true;
+					instanceStatusString = 'Instanz okay';
+				}
 			}
-		} else {
-			return true;
 		}
+
+		return [isAlive, isHealthy, instanceStatusString];
 	}
 
 	/**
 	 * set status for instance
 	 * @param {string} instanceMode
 	 * @param {string} scheduleTime
-	 * @param {object} instanceAlivePath
-	 * @param {string} hostConnectedPath
-	 * @param {string} isDeviceConnctedPath
+	 * @param {any} instanceID
 	 */
-	async setInstanceStatus(instanceMode, scheduleTime, instanceAlivePath, hostConnectedPath, isDeviceConnctedPath) {
-		const isAliveSchedule = await this.getForeignStateAsync(instanceAlivePath);
-		let isHostConnected = await this.getInitValue(hostConnectedPath);
-		let isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
-		let instanceStatusString = 'Instance deactivated';
-		let lastUpdate;
-		let lastCronRun;
-		let diff;
-		let isAlive;
-		let previousCronRun = null;
+	async setInstanceStatus(instanceMode, scheduleTime, instanceID) {
+		let instanceStatusString = 'Instanz deaktiviert';
+		let isAlive = false;
 		let isHealthy = false;
+		let scheduleIsAlive;
+		let daemonIsAlive;
+		let daemonIsNotAlive;
 		let instanceDeactivationTime = (this.config.offlineTimeInstances * 1000) / 2;
 		let instanceErrorTime = (this.config.errorTimeInstances * 1000) / 2;
 
 		switch (instanceMode) {
 			case 'schedule':
-				if (isAliveSchedule) {
-					lastUpdate = Math.round((Date.now() - isAliveSchedule.lc) / 1000); // Last state change in seconds
-					previousCronRun = this.getPreviousCronRun(scheduleTime); // When was the last cron run
-					if (previousCronRun) {
-						lastCronRun = Math.round(previousCronRun / 1000); // change distance to last run in seconds
-						diff = lastCronRun - lastUpdate;
-						if (diff > -300) {
-							// if 5 minutes difference exceeded, instance is not alive
-							isAlive = true;
-							isHealthy = true;
-							instanceStatusString = 'Instanz okay';
-						}
-					}
-				}
+				scheduleIsAlive = await this.checkScheduleisHealty(instanceID, scheduleTime);
+				isAlive = Boolean(scheduleIsAlive[0]);
+				isHealthy = Boolean(scheduleIsAlive[1]);
+				instanceStatusString = String(scheduleIsAlive[2]);
 				break;
 			case 'daemon':
-				if (this.userTimeInstancesList.has(instanceAlivePath)) {
+				// check with time the user did define for error and deactivation
+				if (this.userTimeInstancesList.has(instanceID)) {
 					// User set own setting for deactivation time
-					instanceDeactivationTime = this.userTimeInstancesList.get(instanceAlivePath).deactivationTime;
+					instanceDeactivationTime = this.userTimeInstancesList.get(instanceID).deactivationTime;
 					instanceDeactivationTime = (instanceDeactivationTime * 1000) / 2; // calculate sec to ms and divide into two
 
 					// User set own setting for error time
-					instanceErrorTime = this.userTimeInstancesList.get(instanceAlivePath).errorTime;
+					instanceErrorTime = this.userTimeInstancesList.get(instanceID).errorTime;
 					instanceErrorTime = (instanceErrorTime * 1000) / 2; // calculate sec to ms and divide into two
 				}
 
-				// if instance was deactivated
-				isAlive = await this.checkIsAlive(instanceAlivePath, instanceDeactivationTime);
-				if (!isAlive) return ['Instanz deaktiviert', false, null]; // if instance is turned off
-
-				if (isDeviceConnected === undefined) isDeviceConnected = true;
-
-				// if instance has an error
-				if (isHostConnected && isDeviceConnected) {
-					// In case of (re)start, connection may take some time. We take 3 attempts.
-					// Attempt 1/3 - immediately
-					isHealthy = true;
-					instanceStatusString = 'Instanz okay';
-				} else {
-					// 2/3 - after x seconds
-					await this.delay(instanceErrorTime);
-
-					isAlive = await this.checkIsAlive(instanceAlivePath, instanceDeactivationTime);
-					if (!isAlive) return ['Instanz deaktiviert', false, null]; // if instance is turned off
+				daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
 
-					isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
-					if (isDeviceConnected === undefined) isDeviceConnected = true;
-
-					isHostConnected = await this.getInitValue(hostConnectedPath);
-
-					if (isHostConnected && isDeviceConnected) {
-						isHealthy = true;
-						instanceStatusString = 'Instanz okay';
-					} else {
-						// 3/3 - after x seconds in total or user time setting
+				if (daemonIsAlive[0]) {
+					if (daemonIsAlive[1]) {
+						isAlive = Boolean(daemonIsAlive[0]);
+						isHealthy = Boolean(daemonIsAlive[1]);
+						instanceStatusString = String(daemonIsAlive[2]);
+					} else if (daemonIsAlive[0] && !daemonIsAlive[1]) {
+						// wait first time
 						await this.delay(instanceErrorTime);
-
-						isAlive = await this.checkIsAlive(instanceAlivePath, instanceDeactivationTime);
-						if (!isAlive) return ['Instanz deaktiviert', false, null]; // if instance is turned off
-
-						isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
-						if (isDeviceConnected === undefined) isDeviceConnected = true;
-
-						isHostConnected = await this.getInitValue(hostConnectedPath);
-
-						if (isHostConnected && isDeviceConnected) {
-							isHealthy = true;
-							instanceStatusString = 'Instanz okay';
-						} else {
-							if (!isDeviceConnected) {
-								instanceStatusString = 'Nicht verbunden mit Gerät oder Dienst';
-								isHealthy = false;
-							} else if (!isHostConnected) {
-								instanceStatusString = 'Nicht verbunden mit Host';
-								isHealthy = false;
+						daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
+						if (daemonIsAlive[0] && !daemonIsAlive[1]) {
+							// wait second time
+							await this.delay(instanceErrorTime);
+							daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
+							if (daemonIsAlive[0] && !daemonIsAlive[1]) {
+								// finally
+								isAlive = Boolean(daemonIsAlive[0]);
+								isHealthy = Boolean(daemonIsAlive[1]);
+								instanceStatusString = String(daemonIsAlive[2]);
+							} else if (!daemonIsAlive[0]) {
+								daemonIsNotAlive = await this.checkDaemonIsAlive(instanceID, instanceDeactivationTime);
+								isAlive = Boolean(daemonIsNotAlive[0]);
+								isHealthy = Boolean(daemonIsNotAlive[1]);
+								instanceStatusString = String(daemonIsNotAlive[2]);
 							}
+						} else if (!daemonIsAlive[0]) {
+							daemonIsNotAlive = await this.checkDaemonIsAlive(instanceID, instanceDeactivationTime);
+							isAlive = Boolean(daemonIsNotAlive[0]);
+							isHealthy = Boolean(daemonIsNotAlive[1]);
+							instanceStatusString = String(daemonIsNotAlive[2]);
 						}
+					} else if (!daemonIsAlive[0]) {
+						daemonIsNotAlive = await this.checkDaemonIsAlive(instanceID, instanceDeactivationTime);
+						isAlive = Boolean(daemonIsNotAlive[0]);
+						isHealthy = Boolean(daemonIsNotAlive[1]);
+						instanceStatusString = String(daemonIsNotAlive[2]);
 					}
+				} else if (!daemonIsAlive[0]) {
+					daemonIsNotAlive = await this.checkDaemonIsAlive(instanceID, instanceDeactivationTime);
+					isAlive = Boolean(daemonIsNotAlive[0]);
+					isHealthy = Boolean(daemonIsNotAlive[1]);
+					instanceStatusString = String(daemonIsNotAlive[2]);
 				}
 				break;
 		}
 
-		return [instanceStatusString, isAlive, isHealthy];
+		return [isAlive, isHealthy, instanceStatusString];
 	}
 
 	/**
@@ -2346,54 +2365,54 @@ class DeviceWatcher extends utils.Adapter {
 		this.listErrorInstanceRaw = [];
 		this.listErrorInstance = [];
 
-		for (const instance of this.listInstanceRaw.values()) {
+		for (const [instance, instanceData] of this.listInstanceRaw) {
 			// fill raw list
-			if (instance.isAlive && !instance.isHealthy) {
+			if (instanceData.isAlive && !instanceData.isHealthy) {
 				this.listErrorInstanceRaw.push({
-					Adapter: instance.Adapter,
-					Instance: instance.InstanceName,
-					Mode: instance.instanceMode,
-					Status: instance.status,
+					Adapter: instanceData.Adapter,
+					Instance: instance,
+					Mode: instanceData.instanceMode,
+					Status: instanceData.status,
 				});
 			}
 
-			if (this.blacklistInstancesLists.includes(instance.instanceAlivePath)) continue;
+			if (this.blacklistInstancesLists.includes(instance)) continue;
 			// all instances
 			this.listAllInstances.push({
-				Adapter: instance.Adapter,
-				Instance: instance.InstanceName,
-				Mode: instance.instanceMode,
-				Schedule: instance.schedule,
-				Version: instance.adapterVersion,
-				Updateable: instance.updateAvailable,
-				Status: instance.status,
+				Adapter: instanceData.Adapter,
+				Instance: instance,
+				Mode: instanceData.instanceMode,
+				Schedule: instanceData.schedule,
+				Version: instanceData.adapterVersion,
+				Updateable: instanceData.updateAvailable,
+				Status: instanceData.status,
 			});
 
-			if (!instance.isAlive) {
+			if (!instanceData.isAlive) {
 				// list with deactivated instances
 				this.listDeactivatedInstances.push({
-					Adapter: instance.Adapter,
-					Instance: instance.InstanceName,
-					Status: instance.status,
+					Adapter: instanceData.Adapter,
+					Instance: instance,
+					Status: instanceData.status,
 				});
 			} else {
 				// list with active instances
 				this.listAllActiveInstances.push({
-					Adapter: instance.Adapter,
-					Instance: instance.InstanceName,
-					Mode: instance.instanceMode,
-					Schedule: instance.schedule,
-					Status: instance.status,
+					Adapter: instanceData.Adapter,
+					Instance: instance,
+					Mode: instanceData.instanceMode,
+					Schedule: instanceData.schedule,
+					Status: instanceData.status,
 				});
 			}
 
 			// list with error instances
-			if (instance.isAlive && !instance.isHealthy) {
+			if (instanceData.isAlive && !instanceData.isHealthy) {
 				this.listErrorInstance.push({
-					Adapter: instance.Adapter,
-					Instance: instance.InstanceName,
-					Mode: instance.instanceMode,
-					Status: instance.status,
+					Adapter: instanceData.Adapter,
+					Instance: instance,
+					Mode: instanceData.instanceMode,
+					Status: instanceData.status,
 				});
 			}
 		}
@@ -2976,12 +2995,12 @@ class DeviceWatcher extends utils.Adapter {
 				break;
 			case 'errorInstance':
 				objectData = this.listInstanceRaw.get(id);
-				message = `Instanz Watchdog:\n${objectData.InstanceName}: ${objectData.status}`;
+				message = `Instanz Watchdog:\n${id}: ${objectData.status}`;
 				setMessage(message);
 				break;
 			case 'deactivatedInstance':
 				objectData = this.listInstanceRaw.get(id);
-				message = `Instanz Watchdog:\n${objectData.InstanceName}: ${objectData.status}`;
+				message = `Instanz Watchdog:\n${id}: ${objectData.status}`;
 				setMessage(message);
 				break;
 		}
@@ -3165,8 +3184,8 @@ class DeviceWatcher extends utils.Adapter {
 					list = '';
 
 					for (const id of this.listErrorInstanceRaw) {
-						if (this.blacklistInstancesNotify.includes(id.instanceAlivePath)) continue;
-						list = `${list}\n${id.Instance}: ${id.Status}`;
+						if (this.blacklistInstancesNotify.includes(id)) continue;
+						list = `${list}\n${id}: ${id.Status}`;
 					}
 					if (list.length === 0) return;
 					message = `Tägliche Meldung über fehlerhafte Instanzen: ${list}`;
@@ -3195,8 +3214,8 @@ class DeviceWatcher extends utils.Adapter {
 					list = '';
 
 					for (const id of this.listDeactivatedInstances) {
-						if (this.blacklistInstancesNotify.includes(id.instanceAlivePath)) continue;
-						list = `${list}\n${id.Instance}`;
+						if (this.blacklistInstancesNotify.includes(id)) continue;
+						list = `${list}\n${id}`;
 					}
 					if (list.length === 0) return;
 					message = `Tägliche Meldung über deaktivierte Instanzen: ${list}`;