Mark a device online from any reachability source, not just mDNS

A device whose network blocks mDNS but answers ping and MQTT showed
offline: the state monitor's priority gate dropped a lower-priority
source's ONLINE when a higher-priority source owned the device, and the
ICMP sweep only resolved the mDNS .local hostname, never the IP MQTT
already supplied via apply_ip.

apply() now lets a positive reachability from any source bring a
not-online device online (the gate still governs offline/downgrades so a
flaky low-priority source can't drop a higher one), and the ping sweep
falls back to the device's known IP addresses when its hostname won't
resolve. Restores the legacy dashboard's online-from-any-source
behaviour.

Author: bdraco

esphome_device_builder/controllers/_device_state_monitor/controller.py

@@ -231,7 +231,17 @@ def apply(self, name: str, state: DeviceState, source: str, *, claim: bool = Fal
             self.state.reachability.observe(name, source)
 
         current_source = self.state.state_source.get(name, ReachabilitySource.UNKNOWN)
-        if _SOURCE_PRIORITY.get(source, 0) < _SOURCE_PRIORITY.get(current_source, 0):
+        # Online-wins: a positive reachability from any source brings a
+        # not-online device online, even one a higher-priority source owns
+        # (ping/MQTT reviving a device a stale mdns/mqtt OFFLINE owns). The
+        # priority gate still governs OFFLINE/downgrades so a low-priority
+        # flap can't drop a device a higher source confirmed online.
+        online_takeover = state == DeviceState.ONLINE and any(
+            d.state != DeviceState.ONLINE for d in devices
+        )
+        if not online_takeover and _SOURCE_PRIORITY.get(source, 0) < _SOURCE_PRIORITY.get(
+            current_source, 0
+        ):
             return False
         # Dedupe must look at *every* matching device, not just the
         # first. Duplicate ``esphome.name`` entries (a config plus

esphome_device_builder/controllers/_device_state_monitor/ping.py

@@ -174,6 +174,12 @@ def _select_ping_targets(self) -> tuple[list[Device], list[Device]]:
                 monitor.apply_ip_addresses(device.name, cached)
                 continue
             if monitor.state.dns_cache.has_cached_failure(device.address):
+                if device.ip_addresses:
+                    # The ``.local`` won't resolve, but a prior MQTT/DNS
+                    # observation left a known IP — ping that instead of
+                    # marking the device offline (mDNS-less devices).
+                    pingable.append(device)
+                    continue
                 # Don't hand the bare hostname to icmplib (it would
                 # hammer the system resolver every sweep). Apply
                 # OFFLINE under the ``ping`` source so a future
@@ -189,6 +195,11 @@ async def _resolve_and_ping(self, device: Device) -> None:
         monitor = self._monitor
         async with self._concurrency:
             addresses = await monitor.state.dns_cache.async_resolve(device.address)
+            if not addresses:
+                # mDNS-less devices: the ``.local`` won't resolve but a
+                # prior MQTT/DNS observation left a usable IP. Ping that so
+                # ping can confirm a device the network won't resolve.
+                addresses = list(device.ip_addresses)
             if not addresses:
                 monitor.apply(device.name, DeviceState.OFFLINE, "ping")
                 return

tests/test_state_monitor_reachability.py

@@ -191,6 +191,61 @@ def test_apply_with_no_tracker_does_not_raise() -> None:
     monitor.apply("kitchen", DeviceState.ONLINE, "mdns")
 
 
+def test_lower_priority_online_revives_higher_priority_offline() -> None:
+    """A ping ONLINE brings online a device a higher-priority mqtt OFFLINE owns."""
+    devices = [_make_device(state=DeviceState.OFFLINE)]
+    monitor = _make_monitor(devices)
+    monitor.state.state_source["kitchen"] = "mqtt"
+
+    assert monitor.apply("kitchen", DeviceState.ONLINE, "ping") is True
+    assert devices[0].state is DeviceState.ONLINE
+    assert monitor.state.state_source["kitchen"] == "ping"
+
+
+def test_lower_priority_offline_does_not_drop_higher_priority_online() -> None:
+    """The gate still protects an mdns ONLINE from a ping OFFLINE flap."""
+    devices = [_make_device(state=DeviceState.ONLINE)]
+    monitor = _make_monitor(devices)
+    monitor.state.state_source["kitchen"] = "mdns"
+
+    assert monitor.apply("kitchen", DeviceState.OFFLINE, "ping") is False
+    assert devices[0].state is DeviceState.ONLINE
+    assert monitor.state.state_source["kitchen"] == "mdns"
+
+
+def test_select_ping_targets_keeps_device_with_known_ip_when_dns_failed() -> None:
+    """A cached DNS failure with a known IP pings the IP, not OFFLINE+dns_failed."""
+    devices = [_make_device(state=DeviceState.OFFLINE, ip_addresses=["10.0.0.5"])]
+    monitor = _make_monitor(devices)
+    monitor.get_cached_addresses = lambda _a: None
+    monitor.state.dns_cache.has_cached_failure = MagicMock(return_value=True)
+
+    pingable, dns_failed = monitor._ping._select_ping_targets()
+
+    assert devices[0] in pingable
+    assert dns_failed == []
+    assert devices[0].state is DeviceState.OFFLINE
+
+
+async def test_resolve_and_ping_falls_back_to_known_ip() -> None:
+    """When the .local won't resolve, ping the MQTT/last-known IP and go ONLINE."""
+    devices = [_make_device(state=DeviceState.OFFLINE, ip_addresses=["10.0.0.5"])]
+    monitor = _make_monitor(devices)
+    monitor.state.dns_cache.async_resolve = AsyncMock(return_value=[])
+
+    fake_result = MagicMock()
+    fake_result.is_alive = True
+    fake_result.min_rtt = 1.0
+    with patch(
+        "esphome_device_builder.controllers._device_state_monitor.ping.icmp_ping",
+        AsyncMock(return_value=fake_result),
+    ) as mock_ping:
+        await monitor._ping._resolve_and_ping(devices[0])
+
+    assert mock_ping.await_args.args[0] == "10.0.0.5"
+    assert devices[0].state is DeviceState.ONLINE
+
+
 async def test_ping_success_records_rtt_and_observation() -> None:
     """A successful ICMP probe captures ``min_rtt`` and stamps freshness."""
     devices = [_make_device()]