Prevent tplink missing devices and unavailable state

.coveragerc

@@ -915,6 +915,7 @@ omit =
     homeassistant/components/torque/sensor.py
     homeassistant/components/totalconnect/*
     homeassistant/components/touchline/climate.py
+    homeassistant/components/tplink/common.py
     homeassistant/components/tplink/switch.py
     homeassistant/components/tplink_lte/*
     homeassistant/components/traccar/device_tracker.py

CODEOWNERS

@@ -453,7 +453,7 @@ homeassistant/components/tmb/* @alemuro
 homeassistant/components/todoist/* @boralyl
 homeassistant/components/toon/* @frenck
 homeassistant/components/totalconnect/* @austinmroczek
-homeassistant/components/tplink/* @rytilahti
+homeassistant/components/tplink/* @rytilahti @thegardenmonkey
 homeassistant/components/traccar/* @ludeeus
 homeassistant/components/tradfri/* @ggravlingen
 homeassistant/components/trafikverket_train/* @endor-force

homeassistant/components/tplink/common.py

@@ -1,8 +1,6 @@
 """Common code for tplink."""
-import asyncio
-from datetime import timedelta
 import logging
-from typing import Any, Callable, List
+from typing import List
 
 from pyHS100 import (
     Discover,
@@ -113,89 +111,19 @@ def get_static_devices(config_data) -> SmartDevices:
     for type_ in [CONF_LIGHT, CONF_SWITCH, CONF_STRIP, CONF_DIMMER]:
         for entry in config_data[type_]:
             host = entry["host"]
-
-            if type_ == CONF_LIGHT:
-                lights.append(SmartBulb(host))
-            elif type_ == CONF_SWITCH:
-                switches.append(SmartPlug(host))
-            elif type_ == CONF_STRIP:
-                try:
-                    ss_host = SmartStrip(host)
-                except SmartDeviceException as sde:
-                    _LOGGER.error(
-                        "Failed to setup SmartStrip at %s: %s; not retrying", host, sde
-                    )
-                    continue
-                for plug in ss_host.plugs.values():
-                    switches.append(plug)
-            # Dimmers need to be defined as smart plugs to work correctly.
-            elif type_ == CONF_DIMMER:
-                lights.append(SmartPlug(host))
-
-    return SmartDevices(lights, switches)
-
-
-async def async_add_entities_retry(
-    hass: HomeAssistantType,
-    async_add_entities: Callable[[List[Any], bool], None],
-    objects: List[Any],
-    callback: Callable[[Any, Callable], None],
-    interval: timedelta = timedelta(seconds=60),
-):
-    """
-    Add entities now and retry later if issues are encountered.
-
-    If the callback throws an exception or returns false, that
-    object will try again a while later.
-    This is useful for devices that are not online when hass starts.
-    :param hass:
-    :param async_add_entities: The callback provided to a
-    platform's async_setup.
-    :param objects: The objects to create as entities.
-    :param callback: The callback that will perform the add.
-    :param interval: THe time between attempts to add.
-    :return: A callback to cancel the retries.
-    """
-    add_objects = objects.copy()
-
-    is_cancelled = False
-
-    def cancel_interval_callback():
-        nonlocal is_cancelled
-        is_cancelled = True
-
-    async def process_objects_loop(delay: int):
-        if is_cancelled:
-            return
-
-        await process_objects()
-
-        if not add_objects:
-            return
-
-        await asyncio.sleep(delay)
-
-        hass.async_create_task(process_objects_loop(delay))
-
-    async def process_objects(*args):
-        # Process each object.
-        for add_object in list(add_objects):
-            # Call the individual item callback.
             try:
-                _LOGGER.debug("Attempting to add object of type %s", type(add_object))
-                result = await hass.async_add_job(
-                    callback, add_object, async_add_entities
+                if type_ == CONF_LIGHT:
+                    lights.append(SmartBulb(host))
+                elif type_ == CONF_SWITCH:
+                    switches.append(SmartPlug(host))
+                elif type_ == CONF_STRIP:
+                    for plug in SmartStrip(host).plugs.values():
+                        switches.append(plug)
+                # Dimmers need to be defined as smart plugs to work correctly.
+                elif type_ == CONF_DIMMER:
+                    lights.append(SmartPlug(host))
+            except SmartDeviceException as sde:
+                _LOGGER.error(
+                    "Failed to setup device %s due to %s; not retrying", host, sde
                 )
-            except SmartDeviceException as ex:
-                _LOGGER.debug(str(ex))
-                result = False
-
-            if result is True or result is None:
-                _LOGGER.debug("Added object")
-                add_objects.remove(add_object)
-            else:
-                _LOGGER.debug("Failed to add object, will try again later")
-
-    await process_objects_loop(interval.seconds)
-
-    return cancel_interval_callback
+    return SmartDevices(lights, switches)

homeassistant/components/tplink/light.py

@@ -1,4 +1,5 @@
 """Support for TPLink lights."""
+import asyncio
 from datetime import timedelta
 import logging
 import time
@@ -25,7 +26,6 @@
 import homeassistant.util.dt as dt_util
 
 from . import CONF_LIGHT, DOMAIN as TPLINK_DOMAIN
-from .common import async_add_entities_retry
 
 PARALLEL_UPDATES = 0
 SCAN_INTERVAL = timedelta(seconds=5)
@@ -54,23 +54,26 @@
 LIGHT_SYSINFO_IS_VARIABLE_COLOR_TEMP = "is_variable_color_temp"
 LIGHT_SYSINFO_IS_COLOR = "is_color"
 
+MAX_ATTEMPTS = 300
+SLEEP_TIME = 2
+
 
 async def async_setup_entry(hass: HomeAssistantType, config_entry, async_add_entities):
-    """Set up switches."""
-    await async_add_entities_retry(
-        hass, async_add_entities, hass.data[TPLINK_DOMAIN][CONF_LIGHT], add_entity
-    )
-    return True
+    """Set up lights."""
+    devices = hass.data[TPLINK_DOMAIN][CONF_LIGHT]
+    entities = []
+
+    await hass.async_add_executor_job(get_devices_sysinfo, devices)
+    for device in devices:
+        entities.append(TPLinkSmartBulb(device))
 
+    async_add_entities(entities, update_before_add=True)
 
-def add_entity(device: SmartBulb, async_add_entities):
-    """Check if device is online and add the entity."""
-    # Attempt to get the sysinfo. If it fails, it will raise an
-    # exception that is caught by async_add_entities_retry which
-    # will try again later.
-    device.get_sysinfo()
 
-    async_add_entities([TPLinkSmartBulb(device)], update_before_add=True)
+def get_devices_sysinfo(devices):
+    """Get sysinfo for all devices."""
+    for device in devices:
+        device.get_sysinfo()
 
 
 def brightness_to_percentage(byt):
@@ -134,6 +137,9 @@ def __init__(self, smartbulb: SmartBulb) -> None:
         self._last_historical_power_update = None
         self._emeter_params = {}
 
+        self._host = None
+        self._alias = None
+
     @property
     def unique_id(self):
         """Return a unique ID."""
@@ -235,40 +241,36 @@ def is_on(self):
         """Return True if device is on."""
         return self._light_state.state
 
-    def update(self):
-        """Update the TP-Link Bulb's state."""
+    def attempt_update(self, update_attempt):
+        """Attempt to get details the TP-Link bulb."""
         # State is currently being set, ignore.
         if self._is_setting_light_state:
-            return
+            return False
 
         try:
-            # Update light features only once.
             if not self._light_features:
-                self._light_features = self._get_light_features_retry()
-            self._light_state = self._get_light_state_retry()
-            self._is_available = True
+                self._light_features = self._get_light_features()
+                self._alias = self._light_features.alias
+                self._host = self.smartbulb.host
+            self._light_state = self._get_light_state()
+            return True
+
         except (SmartDeviceException, OSError) as ex:
-            if self._is_available:
-                _LOGGER.warning(
-                    "Could not read data for %s: %s", self.smartbulb.host, ex
+            if update_attempt == 0:
+                _LOGGER.debug(
+                    "Retrying in %s seconds for %s|%s due to: %s",
+                    SLEEP_TIME,
+                    self._host,
+                    self._alias,
+                    ex,
                 )
-            self._is_available = False
+            return False
 
     @property
     def supported_features(self):
         """Flag supported features."""
         return self._light_features.supported_features
 
-    def _get_light_features_retry(self) -> LightFeatures:
-        """Retry the retrieval of the supported features."""
-        try:
-            return self._get_light_features()
-        except (SmartDeviceException, OSError):
-            pass
-
-        _LOGGER.debug("Retrying getting light features")
-        return self._get_light_features()
-
     def _get_light_features(self):
         """Determine all supported features in one go."""
         sysinfo = self.smartbulb.sys_info
@@ -304,16 +306,6 @@ def _get_light_features(self):
             has_emeter=has_emeter,
         )
 
-    def _get_light_state_retry(self) -> LightState:
-        """Retry the retrieval of getting light states."""
-        try:
-            return self._get_light_state()
-        except (SmartDeviceException, OSError):
-            pass
-
-        _LOGGER.debug("Retrying getting light state")
-        return self._get_light_state()
-
     def _light_state_from_params(self, light_state_params) -> LightState:
         brightness = None
         color_temp = None
@@ -474,6 +466,33 @@ def _set_device_state(self, state):
 
         return self._get_device_state()
 
+    async def async_update(self):
+        """Update the TP-Link bulb's state."""
+        for update_attempt in range(MAX_ATTEMPTS):
+            is_ready = await self.hass.async_add_executor_job(
+                self.attempt_update, update_attempt
+            )
+
+            if is_ready:
+                self._is_available = True
+                if update_attempt > 0:
+                    _LOGGER.debug(
+                        "Device %s|%s responded after %s attempts",
+                        self._host,
+                        self._alias,
+                        update_attempt,
+                    )
+                break
+            await asyncio.sleep(SLEEP_TIME)
+        else:
+            if self._is_available:
+                _LOGGER.warning(
+                    "Could not read state for %s|%s",
+                    self._host,
+                    self._alias,
+                )
+            self._is_available = False
+
 
 def _light_state_diff(old_light_state: LightState, new_light_state: LightState):
     old_state_param = old_light_state.to_param()

homeassistant/components/tplink/manifest.json

@@ -3,6 +3,11 @@
   "name": "TP-Link Kasa Smart",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/tplink",
-  "requirements": ["pyHS100==0.3.5.1"],
-  "codeowners": ["@rytilahti"]
-}
+  "requirements": [
+    "pyHS100==0.3.5.1"
+  ],
+  "codeowners": [
+    "@rytilahti",
+    "@thegardenmonkey"
+  ]
+}