Added remove node logic

Author: Breina

custom_components/dmx/__init__.py

@@ -22,7 +22,7 @@
 
 from custom_components.dmx.bridge.artnet_controller import ArtNetController, DiscoveredNode
 from custom_components.dmx.client import PortAddress, ArtPollReply
-from custom_components.dmx.client.artnet_server import ArtNetServer
+from custom_components.dmx.client.artnet_server import ArtNetServer, Node
 from custom_components.dmx.const import DOMAIN, HASS_DATA_ENTITIES, ARTNET_CONTROLLER, CONF_DATA, UNDO_UPDATE_LISTENER
 from custom_components.dmx.fixture.fixture import Fixture
 from custom_components.dmx.fixture.parser import parse
@@ -309,15 +309,20 @@ def _get_node_handler():
         DynamicNodeHandler = _get_node_handler()
         node_handler = DynamicNodeHandler(hass, entry, controller)
 
-        def new_code_callback(artpoll_reply: ArtPollReply):
+        def node_new_callback(artpoll_reply: ArtPollReply):
             hass.async_create_task(node_handler.handle_new_node(artpoll_reply))
 
-        controller.new_node_callback = new_code_callback
+        controller.node_new_callback = node_new_callback
 
-        def existing_node_callback(artpoll_reply: ArtPollReply):
+        def node_update_callback(artpoll_reply: ArtPollReply):
             hass.async_create_task(node_handler.update_node(artpoll_reply))
 
-        controller.art_poll_reply_callback = existing_node_callback
+        controller.node_update_callback = node_update_callback
+
+        def node_lost_callback(node: Node):
+            hass.async_create_task(node_handler.disable_node(node))
+
+        controller.node_lost_callback = node_lost_callback
 
         for universe_dict in artnet_yaml[CONF_UNIVERSES]:
             (universe_str, universe_yaml), = universe_dict.items()

custom_components/dmx/client/artnet_server.py

@@ -34,6 +34,7 @@
 class Node:
     addr: bytes = [0x00] * 4,
     bind_index: int = 0,
+    mac_address: bytes = [0x00] * 6,
 
     last_seen: datetime.datetime = datetime.datetime.now(),
     net_switch: int = 0,
@@ -84,8 +85,11 @@ def __init__(self, hass: HomeAssistant, state_update_callback=None,
 
         self.__hass = hass
         self.__state_update_callback = state_update_callback
-        self.new_node_callback = None
-        self.art_poll_reply_callback = None
+
+        self.node_new_callback = None
+        self.node_update_callback = None
+        self.node_lost_callback = None
+
         self.firmware_version = firmware_version
         self.oem = oem
         self.esta = esta
@@ -161,9 +165,6 @@ def add_node_by_port_address(self, port_address: PortAddress, node: Node):
         else:
             self.nodes_by_port_address[port_address] = {node}
 
-    def remove_node_by_ip(self, addr: bytes, bind_index: int = 1):
-        del self.nodes_by_ip[addr, bind_index]
-
     def remove_node_by_port_address(self, port_address: PortAddress, node: Node):
         nodes = self.nodes_by_port_address[port_address]
         if not nodes:
@@ -177,6 +178,7 @@ def remove_node_by_port_address(self, port_address: PortAddress, node: Node):
             ip_str = inet_ntoa(node.addr)
             if ip_str in self.node_change_subscribers:
                 self.node_change_subscribers.remove(ip_str)
+                self.node_lost_callback(node)
 
     def update_subscribers(self):
         for subscriber in self.node_change_subscribers:
@@ -491,25 +493,26 @@ def handle_poll_reply(self, addr, reply):
         # Maintain data structures
         bind_index = reply.bind_index
         node = self.get_node_by_ip(source_ip, bind_index)
+        mac_address = reply.mac_address
 
         current_time = datetime.datetime.now()
         if not node:
-            node = Node(source_ip, bind_index, current_time)
+            node = Node(source_ip, bind_index, mac_address, current_time)
             self.add_node_by_ip(node, source_ip, bind_index)
             log.info(f"Discovered new node at {inet_ntoa(source_ip)}@{bind_index} with "
                      f"{reply.net_switch}:{reply.sub_switch}:[{','.join([str(p.sw_out) for p in reply.ports if p.output])}]"
                      )
 
-            if self.new_node_callback:
-                self.new_node_callback(reply)
+            if self.node_new_callback:
+                self.node_new_callback(reply)
 
         else:
             node.last_seen = current_time
             log.debug(f"Existing node checking in {inet_ntoa(source_ip)}@{bind_index} with "
                       f"{reply.net_switch}:{reply.sub_switch}:[{','.join([str(p.sw_out) for p in reply.ports])}]"
                       )
-            if self.art_poll_reply_callback:
-                self.art_poll_reply_callback(reply)
+            if self.node_update_callback:
+                self.node_update_callback(reply)
 
         old_addresses = node.get_addresses()
         node.net_switch = reply.net_switch

custom_components/dmx/entity/node.py

@@ -8,13 +8,17 @@
 from homeassistant.components.sensor import SensorEntity, SensorDeviceClass
 from homeassistant.const import EntityCategory
 from homeassistant.helpers.entity import DeviceInfo
-from homeassistant.helpers.entity_platform import EntityPlatform
 
 from custom_components.dmx import ArtPollReply
 from custom_components.dmx.client import StyleCode, IndicatorState, BootProcess, FailsafeState, PortAddressProgrammingAuthority
 
 _LOGGER = logging.getLogger(__name__)
 
+def bind_index_str(artpoll_reply: ArtPollReply):
+    if artpoll_reply.bind_index == 0:
+        return ""
+    return f" {artpoll_reply.bind_index}"
+
 
 class ArtNetEntity:
     """Representation of an ArtNet entity."""
@@ -47,14 +51,14 @@ class ArtNetOnlineBinarySensor(ArtNetEntity, BinarySensorEntity):
 
     def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the binary sensor."""
-        super().__init__(art_poll_reply, f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Online", "online", device_info)
+        super().__init__(art_poll_reply, f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Online", "online", device_info)
         self._attr_device_class = BinarySensorDeviceClass.CONNECTIVITY
+        self.connected = True
 
     @property
     def is_on(self) -> bool:
         """Return true if the binary sensor is on."""
-        # TODO
-        return True
+        return self.connected
 
     @property
     def extra_state_attributes(self) -> Dict[str, Any]:
@@ -77,7 +81,7 @@ class ArtNetIndicatorStateSensor(ArtNetEntity, SensorEntity):
 
     def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the sensor."""
-        super().__init__(art_poll_reply, f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Indicator", "indicator", device_info)
+        super().__init__(art_poll_reply, f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Indicator", "indicator", device_info)
         self._attr_device_class = SensorDeviceClass.ENUM
         self._attr_icon = "mdi:lightbulb"
         self._attr_options = [member.name for member in IndicatorState]
@@ -98,7 +102,7 @@ class ArtNetBootProcessSensor(ArtNetEntity, SensorEntity):
 
     def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the sensor."""
-        super().__init__(art_poll_reply, f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Boot Process", "boot_process", device_info)
+        super().__init__(art_poll_reply, f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Boot Process", "boot_process", device_info)
         self._attr_device_class = SensorDeviceClass.ENUM
         self._attr_options = [member.name for member in BootProcess]
         self._attr_entity_category = EntityCategory.DIAGNOSTIC
@@ -118,7 +122,7 @@ class ArtNetRDMBinarySensor(ArtNetEntity, BinarySensorEntity):
 
     def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the binary sensor."""
-        super().__init__(art_poll_reply, f"{art_poll_reply.short_name} {art_poll_reply.bind_index} RDM Support", "rdm_support", device_info)
+        super().__init__(art_poll_reply, f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} RDM Support", "rdm_support", device_info)
         self._attr_entity_category = EntityCategory.DIAGNOSTIC
 
     @property
@@ -143,7 +147,7 @@ class ArtNetDHCPBinarySensor(ArtNetEntity, BinarySensorEntity):
 
     def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the binary sensor."""
-        super().__init__(art_poll_reply, f"{art_poll_reply.short_name} {art_poll_reply.bind_index} DHCP", "dhcp", device_info)
+        super().__init__(art_poll_reply, f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} DHCP", "dhcp", device_info)
         self._attr_icon = "mdi:network"
         self._attr_entity_category = EntityCategory.DIAGNOSTIC
 
@@ -173,7 +177,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo, port_index):
         self.port = art_poll_reply.ports[port_index]
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Port {port_index + 1} Input Active",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Port {port_index + 1} Input Active",
             f"port_{port_index}_input_active",
             device_info
         )
@@ -220,7 +224,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo, port_index):
         self.port = art_poll_reply.ports[port_index]
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Port {port_index + 1} Output Active",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Port {port_index + 1} Output Active",
             f"port_{port_index}_output_active",
             device_info
         )
@@ -267,7 +271,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo, port_index):
         self.port = art_poll_reply.ports[port_index]
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Port {port_index + 1} Merge Mode",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Port {port_index + 1} Merge Mode",
             f"port_{port_index}_merge_mode",
             device_info
         )
@@ -308,7 +312,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo, port_index):
         self.port = art_poll_reply.ports[port_index]
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Port {port_index + 1} sACN Mode",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Port {port_index + 1} sACN Mode",
             f"port_{port_index}_sacn_mode",
             device_info
         )
@@ -343,7 +347,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo, port_index):
         self.port = art_poll_reply.ports[port_index]
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Port {port_index + 1} RDM",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Port {port_index + 1} RDM",
             f"port_{port_index}_rdm",
             device_info
         )
@@ -378,7 +382,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo, port_index):
         self.port = art_poll_reply.ports[port_index]
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Port {port_index + 1} Output Mode",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Port {port_index + 1} Output Mode",
             f"port_{port_index}_output_mode",
             device_info
         )
@@ -413,7 +417,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo, port_index, is_input
         direction = "Input" if is_input else "Output"
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Port {port_index + 1} {direction} Universe",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Port {port_index + 1} {direction} Universe",
             f"port_{port_index}_{direction.lower()}_universe",
             device_info
         )
@@ -443,7 +447,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the sensor."""
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Failsafe State",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Failsafe State",
             "failsafe_state",
             device_info
         )
@@ -468,7 +472,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the sensor."""
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} ACN Priority",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} ACN Priority",
             "acn_priority",
             device_info
         )
@@ -491,7 +495,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the sensor."""
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Node Report",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Node Report",
             "node_report",
             device_info
         )
@@ -514,7 +518,7 @@ def __init__(self, art_poll_reply, device_info: DeviceInfo):
         """Initialize the sensor."""
         super().__init__(
             art_poll_reply,
-            f"{art_poll_reply.short_name} {art_poll_reply.bind_index} Port Programming Authority",
+            f"{art_poll_reply.short_name}{bind_index_str(art_poll_reply)} Port Programming Authority",
             "port_programming_authority",
             device_info
         )

custom_components/dmx/entity/node_handler.py

@@ -5,12 +5,16 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import async_get_platforms
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.entity_registry import RegistryEntryDisabler
 
-from custom_components.dmx import ArtPollReply, DOMAIN, PortAddress, DmxUniverse
+from custom_components.dmx import ArtPollReply, DOMAIN, Node
 from custom_components.dmx.entity.node import ArtNetOnlineBinarySensor, ArtNetIndicatorStateSensor, ArtNetBootProcessSensor, ArtNetRDMBinarySensor, ArtNetDHCPBinarySensor, \
     ArtNetFailsafeStateSensor, ArtNetACNPrioritySensor, ArtNetNodeReportSensor, ArtNetPortAddressProgrammingAuthoritySensor, ArtNetPortInputBinarySensor, \
     ArtNetPortUniverseSensor, ArtNetPortOutputBinarySensor, ArtNetPortMergeModeSelect, ArtNetPortSACNBinarySensor, ArtNetPortRDMBinarySensor, ArtNetPortOutputModeSensor
 
+NODE_ENTITIES = "node_entities"
+
 log = logging.getLogger(__name__)
 
 
@@ -29,6 +33,8 @@ async def handle_new_node(self, artpoll_reply: ArtPollReply) -> None:
         unique_id = f"{artpoll_reply.mac_address}{artpoll_reply.bind_index}"
 
         if unique_id in self.discovered_nodes:
+            # Previously disabled, but found again
+            await self.reenable_node(artpoll_reply)
             return
 
         log.info(f"Discovered new ArtNet node: {artpoll_reply.short_name}")
@@ -87,8 +93,8 @@ async def update_node(self, artpoll_reply: ArtPollReply) -> None:
         self.discovered_nodes[unique_id] = artpoll_reply
 
         # Find all entities for this node and update their art_poll_reply reference
-        if "entities" in self.hass.data[DOMAIN][self.entry.entry_id]:
-            entities = self.hass.data[DOMAIN][self.entry.entry_id]["entities"]
+        if NODE_ENTITIES in self.hass.data[DOMAIN][self.entry.entry_id]:
+            entities = self.hass.data[DOMAIN][self.entry.entry_id][NODE_ENTITIES]
 
             # Find entities belonging to this node and update them
             mac_string = ":".join(f"{b:02x}" for b in artpoll_reply.mac_address)
@@ -105,14 +111,70 @@ async def update_node(self, artpoll_reply: ArtPollReply) -> None:
                     if hasattr(entity, "async_schedule_update_ha_state"):
                         entity.async_schedule_update_ha_state()
 
-        log.debug(f"Updated ArtNet node: {artpoll_reply.long_name})")
+        log.debug(f"Updated ArtNet node: {artpoll_reply.long_name}")
+
+    async def disable_node(self, node: Node) -> None:
+        unique_id = f"{node.mac_address}{node.bind_index}"
+
+        if unique_id not in self.discovered_nodes:
+            return
+
+        entity_reg = er.async_get(self.hass)
+
+        if NODE_ENTITIES in self.hass.data[DOMAIN][self.entry.entry_id]:
+            entities = self.hass.data[DOMAIN][self.entry.entry_id][NODE_ENTITIES]
+
+            # Find entities belonging to this node and update them
+            mac_string = ":".join(f"{b:02x}" for b in node.mac_address)
+            for entity in entities:
+                # Check if this entity belongs to the node being updated
+                if hasattr(entity, "_mac_address") and entity._mac_address == mac_string and \
+                        hasattr(entity, "art_poll_reply") and \
+                        entity.art_poll_reply.bind_index == node.bind_index:
+
+                    if isinstance(entity, ArtNetOnlineBinarySensor):
+                        entity.connected = False
+
+                        if hasattr(entity, "async_schedule_update_ha_state"):
+                            entity.async_schedule_update_ha_state()
+                        continue
+
+                    entity_reg.async_update_entity(entity.registry_entry, disabled_by=RegistryEntryDisabler.INTEGRATION)
+
+    async def reenable_node(self, artpoll_reply: ArtPollReply) -> None:
+        unique_id = f"{artpoll_reply.mac_address}{artpoll_reply.bind_index}"
+
+        if unique_id not in self.discovered_nodes:
+            return
+
+        entity_reg = er.async_get(self.hass)
+
+        if NODE_ENTITIES in self.hass.data[DOMAIN][self.entry.entry_id]:
+            entities = self.hass.data[DOMAIN][self.entry.entry_id][NODE_ENTITIES]
+
+            # Find entities belonging to this node and update them
+            mac_string = ":".join(f"{b:02x}" for b in artpoll_reply.mac_address)
+            for entity in entities:
+                # Check if this entity belongs to the node being updated
+                if hasattr(entity, "_mac_address") and entity._mac_address == mac_string and \
+                        hasattr(entity, "art_poll_reply") and \
+                        entity.art_poll_reply.bind_index == artpoll_reply.bind_index:
+
+                    if isinstance(entity, ArtNetOnlineBinarySensor):
+                        entity.connected = True
+
+                        if hasattr(entity, "async_schedule_update_ha_state"):
+                            entity.async_schedule_update_ha_state()
+                        continue
+
+                    entity_reg.async_update_entity(entity.registry_entry, enabled_by=RegistryEntryDisabler.INTEGRATION)
 
     async def _add_entities(self, entities) -> None:
         """Add entities to Home Assistant."""
-        if "entities" not in self.hass.data[DOMAIN][self.entry.entry_id]:
-            self.hass.data[DOMAIN][self.entry.entry_id]["entities"] = []
+        if NODE_ENTITIES not in self.hass.data[DOMAIN][self.entry.entry_id]:
+            self.hass.data[DOMAIN][self.entry.entry_id][NODE_ENTITIES] = []
 
-        self.hass.data[DOMAIN][self.entry.entry_id]["entities"].extend(entities)
+        self.hass.data[DOMAIN][self.entry.entry_id][NODE_ENTITIES].extend(entities)
 
         for platform in async_get_platforms(self.hass, DOMAIN):
             platform_entities = [e for e in entities if e.platform_type == platform.domain]