[core] Allow finding all devices as target that match mac suffix (#13135)

esphome/resolver.py

@@ -2,66 +2,52 @@
 
 from __future__ import annotations
 
-import asyncio
-import threading
-
 from aioesphomeapi.core import ResolveAPIError, ResolveTimeoutAPIError
 import aioesphomeapi.host_resolver as hr
 
+from esphome.async_thread import AsyncThreadRunner
 from esphome.core import EsphomeError
 
 RESOLVE_TIMEOUT = 10.0  # seconds
 
 
-class AsyncResolver(threading.Thread):
+class AsyncResolver:
     """Resolver using aioesphomeapi that runs in a thread for faster results.
 
-    This resolver uses aioesphomeapi's async_resolve_host to handle DNS resolution,
-    including proper .local domain fallback. Running in a thread allows us to get
-    the result immediately without waiting for asyncio.run() to complete its
-    cleanup cycle, which can take significant time.
+    This resolver uses aioesphomeapi's async_resolve_host to handle DNS
+    resolution, including proper .local domain fallback. Running in a thread
+    (via :class:`AsyncThreadRunner`) allows us to get the result immediately
+    without waiting for ``asyncio.run()`` to complete its cleanup cycle, which
+    can take significant time.
     """
 
     def __init__(self, hosts: list[str], port: int) -> None:
         """Initialize the resolver."""
-        super().__init__(daemon=True)
         self.hosts = hosts
         self.port = port
-        self.result: list[hr.AddrInfo] | None = None
-        self.exception: Exception | None = None
-        self.event = threading.Event()
 
-    async def _resolve(self) -> None:
+    async def _resolve(self) -> list[hr.AddrInfo]:
         """Resolve hostnames to IP addresses."""
-        try:
-            self.result = await hr.async_resolve_host(
-                self.hosts, self.port, timeout=RESOLVE_TIMEOUT
-            )
-        except Exception as e:  # pylint: disable=broad-except
-            # We need to catch all exceptions to ensure the event is set
-            # Otherwise the thread could hang forever
-            self.exception = e
-        finally:
-            self.event.set()
-
-    def run(self) -> None:
-        """Run the DNS resolution."""
-        asyncio.run(self._resolve())
+        return await hr.async_resolve_host(
+            self.hosts, self.port, timeout=RESOLVE_TIMEOUT
+        )
 
     def resolve(self) -> list[hr.AddrInfo]:
         """Start the thread and wait for the result."""
-        self.start()
+        runner: AsyncThreadRunner[list[hr.AddrInfo]] = AsyncThreadRunner(self._resolve)
+        runner.start()
 
-        if not self.event.wait(
+        if not runner.event.wait(
             timeout=RESOLVE_TIMEOUT + 1.0
         ):  # Give it 1 second more than the resolver timeout
             raise EsphomeError("Timeout resolving IP address")
 
-        if exc := self.exception:
+        if exc := runner.exception:
             if isinstance(exc, ResolveTimeoutAPIError):
                 raise EsphomeError(f"Timeout resolving IP address: {exc}") from exc
             if isinstance(exc, ResolveAPIError):
                 raise EsphomeError(f"Error resolving IP address: {exc}") from exc
             raise exc
 
-        return self.result
+        assert runner.result is not None  # guaranteed when event set and no exception
+        return runner.result