Use long lived TCP connection to hub and add heartbeat/ping sensor (#50)

* Use a long lived TCP connection to the hub

Instead of creating a new connection for each HTTP request, keep
a long lived TCP connection alive and use it for all requests.

This should use fewer resources on the hub and hopefully avoid
stability problems that can occur when the hub has been up
for many months.

* Add heartbeat sensor that pings the wunda hub

Periodically ping the hub to check it's still responding.

This should help keep the hub's network interface awake.

* Add missing requirement for tests

* Remove unnecessary logging

* Treat empty values from syncvalues as None

Elsewhere it's assumed that unavailable values are either not set
in state dictionary or are None. Where empty strings are used it's
logging some warnings about float conversions which aren't needed.

Author: tonyroberts

custom_components/wundasmart/__init__.py

@@ -6,6 +6,7 @@
 import aiohttp
 import logging
 from typing import Final
+from contextlib import AbstractAsyncContextManager
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_SCAN_INTERVAL, Platform
@@ -14,15 +15,16 @@
 from homeassistant.helpers.device_registry import DeviceInfo
 
 from .const import *
-from .session import get_session
+from .session import get_persistent_session
 from .pywundasmart import get_devices
 
 _LOGGER = logging.getLogger(__name__)
 
 PLATFORMS: Final[list[Platform]] = [
     Platform.CLIMATE,
     Platform.WATER_HEATER,
-    Platform.SENSOR
+    Platform.SENSOR,
+    Platform.BINARY_SENSOR
 ]
 
 
@@ -32,7 +34,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     wunda_ip = entry.data[CONF_HOST]
     wunda_user = entry.data[CONF_USERNAME]
     wunda_pass = entry.data[CONF_PASSWORD]
-    update_interval = timedelta(seconds=entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL))
+    update_interval = entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
     connect_timeout = entry.options.get(CONF_CONNECT_TIMEOUT, DEFAULT_CONNECT_TIMEOUT)
     read_timeout = entry.options.get(CONF_READ_TIMEOUT, DEFAULT_READ_TIMEOUT)
     timeout = aiohttp.ClientTimeout(sock_connect=connect_timeout, sock_read=read_timeout)
@@ -74,7 +76,13 @@ async def update_listener(hass: HomeAssistant, config_entry: ConfigEntry) -> Non
 class WundasmartDataUpdateCoordinator(DataUpdateCoordinator):
     """Class to manage fetching data from WundaSmart API."""
 
-    def __init__(self, hass, wunda_ip, wunda_user, wunda_pass, update_interval, timeout):
+    def __init__(self,
+                 hass: HomeAssistant,
+                 wunda_ip: str,
+                 wunda_user: str,
+                 wunda_pass: str,
+                 update_interval: int,
+                 timeout: aiohttp.ClientTimeout):
         """Initialize."""
         self._hass = hass
         self._wunda_ip = wunda_ip
@@ -86,16 +94,20 @@ def __init__(self, hass, wunda_ip, wunda_user, wunda_pass, update_interval, time
         self._sw_version = None
         self._hw_version = None
         self._timeout = timeout
+        self._keepalive_timeout = update_interval * 2
 
-        super().__init__(hass, _LOGGER, name=DOMAIN, update_interval=update_interval)
+        super().__init__(hass,
+                         _LOGGER,
+                         name=DOMAIN,
+                         update_interval=timedelta(seconds=update_interval))
 
     async def _async_update_data(self):
         attempts = 0
         max_attempts = 5
         while attempts < max_attempts:
             attempts += 1
 
-            async with get_session(self._wunda_ip) as session:
+            async with self.get_session() as session:
                 result = await get_devices(
                     session,
                     self._wunda_ip,
@@ -138,6 +150,10 @@ async def _async_update_data(self):
 
         return self._devices
 
+    def get_session(self) -> AbstractAsyncContextManager:
+        """Context manager for getting aiohttp session for any request made to the Wunda hub."""
+        return get_persistent_session(wunda_ip=self._wunda_ip, keepalive_timeout=self._keepalive_timeout)
+
     @property
     def device_sn(self):
         return self._device_sn

custom_components/wundasmart/binary_sensor.py

@@ -0,0 +1,102 @@
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.components.binary_sensor import BinarySensorEntity, BinarySensorDeviceClass
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.helpers.event import async_track_time_interval
+from homeassistant.const import CONF_HOST
+from datetime import timedelta, datetime
+from . import WundasmartDataUpdateCoordinator
+from .const import DOMAIN, CONF_PING_INTERVAL, DEFAULT_PING_INTERVAL
+from icmplib import async_ping, NameLookupError
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+ICMP_TIMEOUT = 1
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
+) -> None:
+    coordinator: WundasmartDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    wunda_ip: str = entry.data[CONF_HOST]
+    ping_interval = entry.options.get(CONF_PING_INTERVAL, DEFAULT_PING_INTERVAL)
+    async_add_entities([WundaHeartbeatSensor(coordinator, wunda_ip, ping_interval)])
+
+
+class WundaHeartbeatSensor(BinarySensorEntity):
+    """Heartbeat sensor that pings the Wunda hub periodically."""
+
+    def __init__(self, coordinator, wunda_ip, poll_interval):
+        super().__init__()
+        self._attr_device_class = BinarySensorDeviceClass.CONNECTIVITY
+        self._attr_should_poll = False
+        self._attr_device_info = coordinator.device_info
+        self._attr_name = (coordinator.device_info or {}).get("name", "Smart HubSwitch")  + " Heartbeat"
+        if coordinator.device_sn:
+            self._attr_unique_id = f"wunda.{coordinator.device_sn}.heartbeat"
+        self._wunda_ip = wunda_ip
+        self._poll_interval = timedelta(seconds=poll_interval)
+        self._unsub_timer = None
+        self._state = False
+        self._attributes = {}
+
+    @property
+    def is_on(self):
+        return self._state
+
+    @property
+    def extra_state_attributes(self):
+        return self._attributes
+
+    async def async_added_to_hass(self):
+        await super().async_added_to_hass()
+
+        # Schedule periodic updates
+        self._unsub_timer = async_track_time_interval(
+            self.hass, self._async_poll, self._poll_interval
+        )
+
+        # Do first poll immediately
+        await self._async_poll(None)
+
+    async def async_will_remove_from_hass(self):
+        await super().async_will_remove_from_hass()
+        if self._unsub_timer:
+            self._unsub_timer()
+            self._unsub_timer = None
+
+    async def _async_poll(self, now):
+        await self.async_update_ha_state(force_refresh=True)
+
+    async def async_update(self):
+        try:
+            data = await async_ping(
+                self._wunda_ip,
+                count=1,
+                timeout=ICMP_TIMEOUT,
+                privileged=False
+            )
+        except NameLookupError:
+            _LOGGER.debug("Error resolving host: %s", self._wunda_ip)
+            self._state = False
+            self._attributes = {}
+            return
+        except Exception as err:
+            _LOGGER.debug("Ping failed for %s: %s", self._wunda_ip, err)
+            self._state = False
+            self._attributes = {}
+            return
+
+        self._state = data.is_alive
+        if not self._state:
+            self._attributes = {}
+            return
+
+        self._attributes = {
+            "lastseen": datetime.now().isoformat(),
+            "min": data.min_rtt,
+            "max": data.max_rtt,
+            "avg": data.avg_rtt,
+            "jitter": data.jitter,
+        }

custom_components/wundasmart/climate.py

@@ -1,14 +1,13 @@
 """Support for WundaSmart climate."""
 from __future__ import annotations
 
-import math
 import logging
 import aiohttp
 from typing import Any
 import voluptuous as vol
 
-from homeassistant.components.climate import (
-    ClimateEntity,
+from homeassistant.components.climate import ClimateEntity
+from homeassistant.components.climate.const import (
     ClimateEntityFeature,
     HVACAction,
     HVACMode,
@@ -29,7 +28,6 @@
 
 from . import WundasmartDataUpdateCoordinator
 from .pywundasmart import send_command, set_register, get_room_id_from_device
-from .session import get_session
 from .const import *
 
 _LOGGER = logging.getLogger(__name__)
@@ -165,7 +163,7 @@ def __trvs(self):
         for device in self.coordinator.data.values():
             if device.get("device_type") == "TRV":
                 room_id = get_room_id_from_device(device)
-                if int(room_id) == int(self._wunda_id):
+                if room_id is not None and int(room_id) == int(self._wunda_id):
                     yield device
 
     def __set_current_temperature(self):
@@ -301,7 +299,7 @@ async def async_added_to_hass(self) -> None:
 
     async def async_set_temperature(self, temperature, **kwargs):
         # Set the new target temperature
-        async with get_session(self._wunda_ip) as session:
+        async with self.coordinator.get_session() as session:
             await send_command(
                 session,
                 self._wunda_ip,
@@ -322,7 +320,7 @@ async def async_set_temperature(self, temperature, **kwargs):
     async def async_set_hvac_mode(self, hvac_mode: HVACMode):
         if hvac_mode == HVACMode.AUTO:
             # Set to programmed mode
-            async with get_session(self._wunda_ip) as session:
+            async with self.coordinator.get_session() as session:
                 await send_command(
                     session,
                     self._wunda_ip,
@@ -338,7 +336,7 @@ async def async_set_hvac_mode(self, hvac_mode: HVACMode):
                     })
         elif hvac_mode == HVACMode.HEAT:
             # Set the target temperature to the t_hi preset temp
-            async with get_session(self._wunda_ip) as session:
+            async with self.coordinator.get_session() as session:
                 await send_command(
                     session,
                     self._wunda_ip,
@@ -354,7 +352,7 @@ async def async_set_hvac_mode(self, hvac_mode: HVACMode):
                     })
         elif hvac_mode == HVACMode.OFF:
             # Set the target temperature to zero
-            async with get_session(self._wunda_ip) as session:
+            async with self.coordinator.get_session() as session:
                 await send_command(
                     session,
                     self._wunda_ip,
@@ -382,7 +380,7 @@ async def async_set_preset_mode(self, preset_mode) -> None:
 
             t_preset = float(self.__state[state_key])
 
-            async with get_session(self._wunda_ip) as session:
+            async with self.coordinator.get_session() as session:
                 await send_command(
                     session,
                     self._wunda_ip,
@@ -414,7 +412,7 @@ async def async_set_preset_temperature(self, service_data: ServiceCall) -> None:
         preset = service_data.data["preset"]
         temperature = service_data.data["temperature"]
 
-        async with get_session(self._wunda_ip) as session:
+        async with self.coordinator.get_session() as session:
             await set_register(
                 session,
                 self._wunda_ip,

custom_components/wundasmart/config_flow.py

@@ -4,11 +4,11 @@
 
 from homeassistant import config_entries, core, exceptions
 from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD, CONF_SCAN_INTERVAL
-from homeassistant.data_entry_flow import FlowResult
+from homeassistant.config_entries import ConfigFlowResult
 from homeassistant.core import callback
 
 from .const import *
-from .session import get_session
+from .session import get_transient_session
 from .pywundasmart import get_devices
 
 STEP_USER_DATA_SCHEMA = vol.Schema(
@@ -32,7 +32,7 @@ def __init__(self, hass, wunda_ip, wunda_user, wunda_pass):
 
     async def authenticate(self):
         """Wundasmart Hub class authenticate."""
-        async with get_session(self._wunda_ip) as session:
+        async with get_transient_session(self._wunda_ip) as session:
             return await get_devices(
                 session,
                 self._wunda_ip,
@@ -137,7 +137,7 @@ class OptionsFlow(config_entries.OptionsFlow):
     def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
         self.config_entry = config_entry
 
-    async def async_step_init(self, user_input: dict[str, Any] | None = None) -> FlowResult:
+    async def async_step_init(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult:
         if user_input is not None:
             return self.async_create_entry(title="", data=user_input)
 
@@ -156,6 +156,11 @@ async def async_step_init(self, user_input: dict[str, Any] | None = None) -> Flo
                 CONF_READ_TIMEOUT,
                 default=self.config_entry.options.get(
                     CONF_READ_TIMEOUT, DEFAULT_READ_TIMEOUT
+                )): int,
+            vol.Optional(
+                CONF_PING_INTERVAL,
+                default=self.config_entry.options.get(
+                    CONF_PING_INTERVAL, DEFAULT_PING_INTERVAL
                 )): int
         }
 

custom_components/wundasmart/const.py

@@ -1,6 +1,6 @@
 """Constants for the wundasmart integration."""
 from dataclasses import dataclass
-from homeassistant.components.climate import (
+from homeassistant.components.climate.const import (
     PRESET_ECO,
     PRESET_COMFORT
 )
@@ -9,10 +9,12 @@
 
 CONF_CONNECT_TIMEOUT = "connect_timeout"
 CONF_READ_TIMEOUT = "read_timeout"
+CONF_PING_INTERVAL = "ping_interval"
 
 DEFAULT_SCAN_INTERVAL = 300
 DEFAULT_CONNECT_TIMEOUT = 5
 DEFAULT_READ_TIMEOUT = 5
+DEFAULT_PING_INTERVAL = 180
 
 @dataclass
 class DeviceIdRanges: