Simplify datamodel

matter_server/server/device_controller.py

@@ -53,6 +53,7 @@ def __init__(
         self.wifi_credentials_set: bool = False
         self.thread_credentials_set: bool = False
         self.compressed_fabric_id: int | None = None
+        self._interview_task: asyncio.Task | None = None
 
     @property
     def fabric_id(self) -> int:
@@ -83,7 +84,9 @@ async def start(self) -> None:
             self._nodes[node_id] = node
         # setup subscriptions and (re)interviews as task in the background
         # as we do not want it to block our startup
-        asyncio.create_task(self._check_subscriptions_and_interviews())
+        self._interview_task = asyncio.create_task(
+            self._check_subscriptions_and_interviews()
+        )
         LOGGER.debug("Loaded %s nodes", len(self._nodes))
 
     async def stop(self) -> None:
@@ -323,7 +326,8 @@ async def subscribe_node(self, node_id: int) -> None:
                 f"Node {node_id} does not exist or has not been interviewed."
             )
         assert node_id not in self._subscriptions, "Already subscribed to node"
-        LOGGER.debug("Setup subscription for node %s", node_id)
+        node_logger = LOGGER.getChild(str(node_id))
+        node_logger.debug("Setting up subscriptions...")
 
         node = self._nodes[node_id]
 
@@ -348,7 +352,9 @@ def attribute_updated_callback(
         ) -> None:
             assert self.server.loop is not None
             new_value = transaction.GetAttribute(path)
-            LOGGER.debug("attribute updated -- %s - new value: %s", path, new_value)
+            node_logger.debug(
+                "Attribute updated -- %s - new value: %s", path, new_value
+            )
             node = self._nodes[node_id]
             attr_path = str(path.Path)
             node.attributes[attr_path] = new_value
@@ -374,7 +380,7 @@ def event_callback(
         ) -> None:
             # pylint: disable=unused-argument
             assert self.server.loop is not None
-            LOGGER.debug("received node event: %s", data)
+            node_logger.debug("Received node event: %s", data)
             self.event_history.append(data)
             # TODO: This callback does not seem to fire ever or my test devices do not have events
             self.server.loop.call_soon_threadsafe(
@@ -385,15 +391,15 @@ def error_callback(
             chipError: int, transaction: Attribute.SubscriptionTransaction
         ) -> None:
             # pylint: disable=unused-argument, invalid-name
-            LOGGER.error("Got error from node: %s", chipError)
+            node_logger.error("Got error from node: %s", chipError)
 
         def resubscription_attempted(
             transaction: Attribute.SubscriptionTransaction,
             terminationError: int,
             nextResubscribeIntervalMsec: int,
         ) -> None:
             # pylint: disable=unused-argument, invalid-name
-            LOGGER.debug(
+            node_logger.debug(
                 "Previous subscription failed with Error: %s - re-subscribing in %s ms...",
                 terminationError,
                 nextResubscribeIntervalMsec,
@@ -407,7 +413,7 @@ def resubscription_succeeded(
             transaction: Attribute.SubscriptionTransaction,
         ) -> None:
             # pylint: disable=unused-argument, invalid-name
-            LOGGER.debug("Subscription succeeded for node %s", node_id)
+            node_logger.debug("Re-Subscription succeeded")
             # mark node as available and signal consumers
             if not node.available:
                 node.available = True
@@ -422,6 +428,7 @@ def resubscription_succeeded(
         # if we reach this point, it means the node could be resolved
         # and the initial subscription succeeded, mark the node available.
         node.available = True
+        node_logger.debug("Subscription succeeded")
         self.server.signal_event(EventType.NODE_UPDATED, node)
 
     def _get_next_node_id(self) -> int:
@@ -463,27 +470,27 @@ async def _check_subscriptions_and_interviews(self) -> None:
                     continue
 
             # setup subscriptions for the node
-            if node_id not in self._subscriptions:
+            if node_id in self._subscriptions:
+                continue
+            try:
+                await self.subscribe_node(node_id)
+            except NodeNotResolving as err:
                 # If the node is unreachable on the network now,
                 # it will throw a NodeNotResolving exception, catch this,
                 # log this and just try to resolve this node in the next run.
-                try:
-                    await self.subscribe_node(node_id)
-                except NodeNotResolving as err:
-                    LOGGER.warning(
-                        "Unable to contact Node %s,"
-                        " we will retry later in the background.",
-                        node_id,
-                        exc_info=err,
-                    )
-                    continue
+                LOGGER.warning(
+                    "Unable to contact Node %s,"
+                    " we will retry later in the background.",
+                    node_id,
+                    exc_info=err,
+                )
 
         # reschedule self to run every hour
         def _schedule():
-            asyncio.create_task(self._check_subscriptions_and_interviews())
+            self._interview_task = asyncio.create_task(
+                self._check_subscriptions_and_interviews()
+            )
 
-        # NOTE: do not do this in one call otherwise asyncio will start
-        # complaining about non awaited coroutines at shutdown
         self.server.loop.call_later(3600, _schedule)
 
     @staticmethod