Make sure a node loads from cache even if it is offline.

If loading from cache fails while node is offline, retry loading from network_init.

Author: dirixmjm

plugwise_usb/network/__init__.py

@@ -74,6 +74,7 @@ def __init__(
         self._discover_sed_tasks: dict[str, Task[bool]] = {}
         self._registry_stragglers: dict[int, str] = {}
         self._discover_stragglers_task: Task[None] | None = None
+        self._load_stragglers_task: Task[None] | None = None
 
     # region - Properties
 
@@ -483,6 +484,12 @@ async def _load_node(self, mac: str) -> bool:
             return True
         return False
 
+    async def _discover_stragglers(self) -> None:
+        """Retry failed load operation."""
+        await sleep(60)
+        while not self._load_discovered_nodes():
+            await sleep(60)
+
     async def _load_discovered_nodes(self) -> bool:
         """Load all nodes currently discovered."""
         _LOGGER.debug("_load_discovered_nodes | START | %s", len(self._nodes))
@@ -532,7 +539,9 @@ async def discover_nodes(self, load: bool = True) -> bool:
             await self.start()
         await self._discover_registered_nodes()
         if load:
-            return await self._load_discovered_nodes()
+            if not await self._load_discovered_nodes():
+                self._load_stragglers_task = create_task(self._load_stragglers())
+                return False
 
         return True
 

plugwise_usb/nodes/circle.py

@@ -884,48 +884,30 @@ async def load(self) -> bool:
             _LOGGER.debug("Loading Circle node %s from cache", self._mac_in_str)
             if await self._load_from_cache():
                 self._loaded = True
-                self._setup_protocol(
-                    CIRCLE_FIRMWARE_SUPPORT,
-                    (
-                        NodeFeature.CIRCLE,
-                        NodeFeature.RELAY,
-                        NodeFeature.RELAY_INIT,
-                        NodeFeature.RELAY_LOCK,
-                        NodeFeature.ENERGY,
-                        NodeFeature.POWER,
-                    ),
-                )
-                if await self.initialize():
-                    await self._loaded_callback(NodeEvent.LOADED, self.mac)
-                    return True
+        if not self._loaded:
+            _LOGGER.debug("Retrieving Info For Circle node %s", self._mac_in_str)
 
-            _LOGGER.debug(
-                "Loading Circle node %s from cache failed",
-                self._mac_in_str,
-            )
-        else:
-            _LOGGER.debug("Loading Circle node %s", self._mac_in_str)
+            # Check if node is online
+            if not self._available and not await self.is_online():
+                _LOGGER.debug(
+                    "Failed to load Circle node %s because it is not online",
+                    self._mac_in_str,
+                )
+                return False
 
-        # Check if node is online
-        if not self._available and not await self.is_online():
-            _LOGGER.debug(
-                "Failed to load Circle node %s because it is not online",
-                self._mac_in_str,
-            )
-            return False
+            # Get node info
+            if (
+                self.skip_update(self._node_info, 30)
+                and await self.node_info_update() is None
+            ):
+                _LOGGER.debug(
+                    "Failed to load Circle node %s because it is not responding to information request",
+                    self._mac_in_str,
+                )
+                return False
 
-        # Get node info
-        if (
-            self.skip_update(self._node_info, 30)
-            and await self.node_info_update() is None
-        ):
-            _LOGGER.debug(
-                "Failed to load Circle node %s because it is not responding to information request",
-                self._mac_in_str,
-            )
-            return False
+            self._loaded = True
 
-        self._loaded = True
         self._setup_protocol(
             CIRCLE_FIRMWARE_SUPPORT,
             (
@@ -937,10 +919,8 @@ async def load(self) -> bool:
                 NodeFeature.POWER,
             ),
         )
-        if not await self.initialize():
-            return False
-
         await self._loaded_callback(NodeEvent.LOADED, self.mac)
+        await self.initialize()
         return True
 
     async def _load_from_cache(self) -> bool:

plugwise_usb/nodes/node.py

@@ -228,6 +228,11 @@ def node_info(self) -> NodeInfo:
         """Node information."""
         return self._node_info
 
+    @property
+    def initialized(self) -> bool:
+        """Node is Initialized."""
+        return self._initialized
+
     @property
     def mac(self) -> str:
         """Zigbee mac address of node."""
@@ -583,6 +588,8 @@ async def is_online(self) -> bool:
         if await self.ping_update() is None:
             _LOGGER.debug("No response to ping for %s", self.mac)
             return False
+        if not self._initialized:
+            await self.initialize()
         return True
 
     async def ping_update(