New registry scanning / startup procedure.

CirclePlus registry address mapping (also called network_address or zigbee_address) is no longer propagated to the nodes as it is unused.
CirclePlus registry address is no longer mapped, only MAC addresses are important for caching.
MAC + NodeType are loaded from cache at startup an initiate the node loading process instantly.
If empty (<4 nodes) inside cache, or disabled cache, the CirclePlus registry scan is executed with short delays
If a node is found, it is loaded / initialized instantly

Author: dirixmjm

plugwise_usb/api.py

@@ -145,7 +145,6 @@ class NodeInfo:
     """Node hardware information."""
 
     mac: str
-    zigbee_address: int
     is_battery_powered: bool = False
     features: tuple[NodeFeature, ...] = (NodeFeature.INFO,)
     firmware: datetime | None = None

plugwise_usb/network/__init__.py

@@ -77,7 +77,7 @@ def __init__(
         self._unsubscribe_node_rejoin: Callable[[], None] | None = None
 
         self._discover_sed_tasks: dict[str, Task[bool]] = {}
-        self._registry_stragglers: dict[int, str] = {}
+        self._registry_stragglers: list[str] = []
         self._discover_stragglers_task: Task[None] | None = None
         self._load_stragglers_task: Task[None] | None = None
 
@@ -232,7 +232,7 @@ async def node_awake_message(self, response: PlugwiseResponse) -> None:
             self._awake_discovery[mac] = response.timestamp
             return
 
-        if (address := self._register.network_address(mac)) is None:
+        if not self._register.node_is_registered(mac):
             if self._register.scan_completed:
                 return
 
@@ -248,7 +248,7 @@ async def node_awake_message(self, response: PlugwiseResponse) -> None:
                 or self._discover_sed_tasks[mac].done()
             ):
                 self._discover_sed_tasks[mac] = create_task(
-                    self._discover_battery_powered_node(address, mac)
+                    self._discover_battery_powered_node(mac)
                 )
             else:
                 _LOGGER.debug("duplicate maintenance awake discovery for %s", mac)
@@ -280,15 +280,15 @@ async def node_rejoin_message(self, response: PlugwiseResponse) -> bool:
                 f"Invalid response message type ({response.__class__.__name__}) received, expected NodeRejoinResponse"
             )
         mac = response.mac_decoded
-        if (address := self._register.network_address(mac)) is None:
-            if (address := self._register.update_node_registration(mac)) is None:
+        if not self._register.node_is_registered(mac):
+            if self._register.update_node_registration(mac) is None:
                 raise NodeError(f"Failed to obtain address for node {mac}")
 
         if self._nodes.get(mac) is None:
             task = self._discover_sed_tasks.get(mac)
             if task is None or task.done():
                 self._discover_sed_tasks[mac] = create_task(
-                    self._discover_battery_powered_node(address, mac)
+                    self._discover_battery_powered_node(mac)
                 )
             else:
                 _LOGGER.debug("duplicate awake discovery for %s", mac)
@@ -335,7 +335,7 @@ async def discover_network_coordinator(self, load: bool = False) -> bool:
             return False
 
         if await self._discover_node(
-            -1, self._controller.mac_coordinator, None, ping_first=False
+            self._controller.mac_coordinator, None, ping_first=False
         ):
             if load:
                 return await self._load_node(self._controller.mac_coordinator)
@@ -349,7 +349,6 @@ async def discover_network_coordinator(self, load: bool = False) -> bool:
     async def _create_node_object(
         self,
         mac: str,
-        address: int,
         node_type: NodeType,
     ) -> None:
         """Create node object and update network registry."""
@@ -361,7 +360,6 @@ async def _create_node_object(
             return
         node = get_plugwise_node(
             mac,
-            address,
             self._controller,
             self._notify_node_event_subscribers,
             node_type,
@@ -371,7 +369,7 @@ async def _create_node_object(
             return
         self._nodes[mac] = node
         _LOGGER.debug("%s node %s added", node.__class__.__name__, mac)
-        await self._register.update_network_registration(address, mac, node_type)
+        await self._register.update_network_nodetype(mac, node_type)
 
         if self._cache_enabled:
             _LOGGER.debug(
@@ -385,16 +383,13 @@ async def _create_node_object(
 
     async def _discover_battery_powered_node(
         self,
-        address: int,
         mac: str,
     ) -> bool:
         """Discover a battery powered node and add it to list of nodes.
 
         Return True if discovery succeeded.
         """
-        if not await self._discover_node(
-            address, mac, node_type=None, ping_first=False
-        ):
+        if not await self._discover_node(mac, node_type=None, ping_first=False):
             return False
         if await self._load_node(mac):
             await self._notify_node_event_subscribers(NodeEvent.AWAKE, mac)
@@ -403,7 +398,6 @@ async def _discover_battery_powered_node(
 
     async def _discover_node(
         self,
-        address: int,
         mac: str,
         node_type: NodeType | None,
         ping_first: bool = True,
@@ -420,16 +414,18 @@ async def _discover_node(
             return True
 
         if node_type is not None:
-            await self._create_node_object(mac, address, node_type)
+            await self._create_node_object(mac, node_type)
             await self._notify_node_event_subscribers(NodeEvent.DISCOVERED, mac)
             return True
 
         # Node type is unknown, so we need to discover it first
         _LOGGER.debug("Starting the discovery of node %s with unknown NodeType", mac)
         node_info, node_ping = await self._controller.get_node_details(mac, ping_first)
         if node_info is None:
+            _LOGGER.debug("Node %s with unknown NodeType not responding", mac)
+            self._registry_stragglers.append(mac)
             return False
-        await self._create_node_object(mac, address, node_info.node_type)
+        await self._create_node_object(mac, node_info.node_type)
 
         # Forward received NodeInfoResponse message to node
         await self._nodes[mac].message_for_node(node_info)
@@ -438,41 +434,16 @@ async def _discover_node(
         await self._notify_node_event_subscribers(NodeEvent.DISCOVERED, mac)
         return True
 
-    async def _discover_registered_nodes(self) -> None:
-        """Discover nodes."""
-        _LOGGER.debug("Start discovery of registered nodes")
-        registered_counter = 0
-        for address, registration in self._register.registry.items():
-            mac, node_type = registration
-            if mac != "":
-                if self._nodes.get(mac) is None:
-                    if not await self._discover_node(address, mac, node_type):
-                        self._registry_stragglers[address] = mac
-                registered_counter += 1
-                await sleep(0)
-        if len(self._registry_stragglers) > 0 and (
-            self._discover_stragglers_task is None
-            or self._discover_stragglers_task.done()
-        ):
-            self._discover_stragglers_task = create_task(self._discover_stragglers())
-        _LOGGER.debug(
-            "Total %s online of %s registered node(s)",
-            str(len(self._nodes)),
-            str(registered_counter),
-        )
-
     async def _discover_stragglers(self) -> None:
         """Repeat Discovery of Nodes with unknown NodeType."""
         while len(self._registry_stragglers) > 0:
             await sleep(NODE_RETRY_DISCOVER_INTERVAL)
-            stragglers: dict[int, str] = {}
-            for address, mac in self._registry_stragglers.items():
-                if not await self._discover_node(address, mac, None):
-                    stragglers[address] = mac
-            self._registry_stragglers = stragglers
+            for mac in self._registry_stragglers:
+                if not await self._discover_node(mac, None):
+                    self._registry_stragglers.remove(mac)
             _LOGGER.debug(
                 "Total %s nodes unreachable having unknown NodeType",
-                str(len(stragglers)),
+                str(len(self._registry_stragglers)),
             )
 
     async def _load_node(self, mac: str) -> bool:
@@ -526,19 +497,22 @@ async def _unload_discovered_nodes(self) -> None:
     # region - Network instance
     async def start(self) -> None:
         """Start and activate network."""
-        self._register.quick_scan_finished(self._discover_registered_nodes)
-        self._register.full_scan_finished(self._discover_registered_nodes)
+        self._register.start_node_discover(self._discover_node)
         await self._register.start()
         self._subscribe_to_protocol_events()
         await self._subscribe_to_node_events()
         self._is_running = True
+        if len(self._registry_stragglers) > 0 and (
+            self._discover_stragglers_task is None
+            or self._discover_stragglers_task.done()
+        ):
+            self._discover_stragglers_task = create_task(self._discover_stragglers())
 
     async def discover_nodes(self, load: bool = True) -> bool:
         """Discover nodes."""
         await self.discover_network_coordinator(load=load)
         if not self._is_running:
             await self.start()
-        await self._discover_registered_nodes()
         if load and not await self._load_discovered_nodes():
             self._load_stragglers_task = create_task(self._load_stragglers())
             return False

plugwise_usb/network/cache.py

@@ -77,3 +77,14 @@ async def update_nodetypes(self, mac: str, node_type: NodeType | None) -> None:
     def get_nodetype(self, mac: str) -> NodeType | None:
         """Return NodeType from cache."""
         return self._nodetypes.get(mac)
+
+    async def prune_cache(self, registry: list(str)) -> None:
+        """Remove items from cache which are not found in registry scan."""
+        _new_nodetypes: dict[str, NodeType] = {}
+        for mac in registry:
+            if mac == "":
+                continue
+            if (node_type := self.get_nodetype(mac)) is not None:
+                _new_nodetypes[mac] = node_type
+        self._nodetypes = _new_nodetypes
+        await self.save_cache()