Merge branch 'fix/scan-performance'

Author: jfmlima

packages/api/src/api/controllers/devices.py

@@ -66,7 +66,6 @@ async def scan_devices(
 
     scan_request = ScanRequest(
         targets=targets or [],
-        use_predefined=use_predefined,
         use_mdns=use_mdns,
         timeout=timeout,
         max_workers=max_workers,

packages/api/src/api/dependencies/container.py

@@ -107,7 +107,8 @@ def get_authentication_service(self) -> AuthenticationService:
     def get_rpc_client(self) -> AsyncShellyRPCClient:
         if self._rpc_client is None:
             self._rpc_client = AsyncShellyRPCClient(
-                timeout=int(core_settings.network.timeout),
+                timeout=core_settings.network.timeout,
+                connect_timeout=core_settings.network.connect_timeout,
                 verify=core_settings.network.verify_ssl,
                 authentication_service=self.get_authentication_service(),
                 auth_state_cache=self.get_auth_state_cache(),
@@ -141,6 +142,12 @@ async def close(self) -> None:
             except Exception:
                 pass
 
+        await self._aclose_legacy_http_client()
+
+        self._rpc_client = None
+        self._credentials_use_case = None
+        self._reset_device_caches()
+
 
 def get_dependencies(container: APIContainer) -> dict:
     return {

packages/cli/src/cli/commands/common.py

@@ -3,6 +3,7 @@
 """
 
 import asyncio
+import inspect
 import ipaddress
 from collections.abc import Callable
 from functools import wraps
@@ -45,12 +46,40 @@ def wrapper(*args: Any, **kwargs: Any) -> Any:
     return wrapper
 
 
+async def _close_container(container: Any) -> None:
+    """Close a CLI container's async resources, skipping mock containers.
+
+    The container's HTTP clients (httpx pools) are created inside the running
+    event loop, so they must be closed from within it. Guarded on a real async
+    ``close`` so unit tests using mock containers are unaffected.
+    """
+    close = getattr(container, "close", None)
+    if inspect.iscoroutinefunction(close):
+        try:
+            await close()
+        except Exception:
+            pass
+
+
+def _container_from_args(args: Any) -> Any:
+    if not args:
+        return None
+    return getattr(getattr(args[0], "obj", None), "container", None)
+
+
+async def _run_then_close(func: Callable, args: Any, kwargs: Any) -> Any:
+    try:
+        return await func(*args, **kwargs)
+    finally:
+        await _close_container(_container_from_args(args))
+
+
 def async_command(func: Callable) -> Callable:
     """Decorator to run async functions in Click commands."""
 
     @wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> Any:
-        return asyncio.run(func(*args, **kwargs))
+        return asyncio.run(_run_then_close(func, args, kwargs))
 
     return wrapper
 

packages/cli/src/cli/dependencies/container.py

@@ -3,7 +3,6 @@
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 
-import httpx
 from core.dependencies.container_base import BaseContainer
 from core.gateways.network.async_shelly_rpc_client import AsyncShellyRPCClient
 from core.repositories.db import async_session_factory
@@ -21,6 +20,7 @@
 )
 from core.services.authentication_service import AuthenticationService
 from core.services.encryption_service import EncryptionService
+from core.settings import settings as core_settings
 from core.use_cases.scan_devices import ScanDevicesUseCase
 
 
@@ -89,14 +89,34 @@ def get_authentication_service(self) -> AuthenticationService:
 
     def get_rpc_client(self) -> AsyncShellyRPCClient:
         if self._rpc_client is None:
-            # Shared session for connection pooling
-            http_session = httpx.AsyncClient(timeout=3.0)
             self._rpc_client = AsyncShellyRPCClient(
-                session=http_session,
+                timeout=core_settings.network.timeout,
+                connect_timeout=core_settings.network.connect_timeout,
+                verify=core_settings.network.verify_ssl,
                 authentication_service=self.get_authentication_service(),
+                auth_state_cache=self.get_auth_state_cache(),
             )
         return self._rpc_client
 
+    async def close(self) -> None:
+        """Gracefully close async resources (HTTP connection pools)."""
+        if self._rpc_client is not None:
+            try:
+                await self._rpc_client.close()
+            except Exception:
+                pass
+
+        if self._mdns_client is not None:
+            try:
+                await self._mdns_client.close()
+            except Exception:
+                pass
+
+        await self._aclose_legacy_http_client()
+
+        self._rpc_client = None
+        self._reset_device_caches()
+
     # Backwards compatibility helpers (optional convenience wrappers)
     def get_device_scan_interactor(self) -> ScanDevicesUseCase:
         return self.get_scan_interactor()

packages/core/src/core/dependencies/container_base.py

@@ -30,6 +30,7 @@
 class BaseContainer:
     def __init__(self) -> None:
         self._device_gateway: ShellyDeviceGateway | None = None
+        self._legacy_http_client: LegacyHttpClient | None = None
         self._mdns_client: MDNSGateway | None = None
         self._scan_interactor: ScanDevicesUseCase | None = None
         self._execute_component_action_interactor: (
@@ -55,7 +56,12 @@ def get_rpc_client(self) -> Any:
 
     def get_device_gateway(self) -> ShellyDeviceGateway:
         if self._device_gateway is None:
-            legacy_http_client = LegacyHttpClient()
+            from core.settings import settings as core_settings
+
+            legacy_http_client = LegacyHttpClient(
+                connect_timeout=core_settings.network.connect_timeout,
+            )
+            self._legacy_http_client = legacy_http_client
             legacy_component_mapper = LegacyComponentMapper()
             legacy_gateway = LegacyDeviceGateway(
                 http_client=legacy_http_client,
@@ -70,6 +76,36 @@ def get_device_gateway(self) -> ShellyDeviceGateway:
             )
         return self._device_gateway
 
+    async def _aclose_legacy_http_client(self) -> None:
+        """Close the legacy HTTP client's connection pool, if one was created."""
+        if self._legacy_http_client is not None:
+            try:
+                await self._legacy_http_client.close()
+            except Exception:
+                pass
+
+    def _reset_device_caches(self) -> None:
+        """Drop cached gateways/interactors that hold now-closed clients.
+
+        Called after close() so that a reused container rebuilds live
+        resources on next access instead of handing back closed ones.
+        """
+        self._device_gateway = None
+        self._legacy_http_client = None
+        self._mdns_client = None
+        self._scan_interactor = None
+        self._execute_component_action_interactor = None
+        self._component_actions_interactor = None
+        self._status_interactor = None
+        self._bulk_operations_interactor = None
+        self._manage_profiles_interactor = None
+        self._provision_device_interactor = None
+        self._ap_device_detector = None
+        self._backup_device_config_interactor = None
+        self._restore_device_config_interactor = None
+        self._manage_backup_schedules_interactor = None
+        self._run_due_backups_interactor = None
+
     def _get_authentication_service_optional(self) -> AuthenticationService | None:
         """Return AuthenticationService if available, None otherwise."""
         if hasattr(self, "get_authentication_service"):

packages/core/src/core/domain/entities/exceptions.py

@@ -34,6 +34,15 @@ def __init__(self, ip: str, error: str, message: str | None = None):
         super().__init__(msg, {"ip": ip, "error": error})
 
 
+class DeviceUnreachableError(DeviceCommunicationError):
+    """Raised when a host does not accept a TCP connection.
+
+    Signals that nothing is listening at the address (connect refused/timed
+    out), as opposed to a device that responded but failed at the HTTP/RPC
+    layer. Used to skip the legacy fallback probe for dead IPs during scans.
+    """
+
+
 class ConfigurationError(ShellyManagerError):
 
     def __init__(self, operation: str, message: str | None = None):

packages/core/src/core/gateways/device/device.py

@@ -14,7 +14,9 @@ class DeviceGateway(ABC):
     timeout: float = 10.0
 
     @abstractmethod
-    async def discover_device(self, ip: str) -> DiscoveredDevice | None:
+    async def discover_device(
+        self, ip: str, timeout: float | None = None
+    ) -> DiscoveredDevice | None:
         pass
 
     @abstractmethod

packages/core/src/core/gateways/device/legacy_device_gateway.py

@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
 from datetime import datetime
@@ -42,13 +43,15 @@ def __init__(
         self._ip_to_mac: dict[str, str] = {}
         self._basic_auth_cache: dict[str, tuple[str, str]] = {}
 
-    async def _ensure_mac(self, ip: str) -> str | None:
+    async def _ensure_mac(self, ip: str, timeout: float | None = None) -> str | None:
         """Get MAC address for an IP, fetching from /shelly if not cached."""
         normalized_ip = normalize_mac(ip)
         if normalized_ip in self._ip_to_mac:
             return self._ip_to_mac[normalized_ip]
         try:
-            shelly_data = await self._http_client.fetch_json(ip, "shelly")
+            shelly_data = await self._http_client.fetch_json(
+                ip, "shelly", timeout=timeout
+            )
             mac = shelly_data.get("mac")
             if mac:
                 normalized_mac = normalize_mac(mac)
@@ -58,12 +61,14 @@ async def _ensure_mac(self, ip: str) -> str | None:
             pass
         return None
 
-    async def _resolve_auth(self, ip: str) -> tuple[str, str] | None:
+    async def _resolve_auth(
+        self, ip: str, timeout: float | None = None
+    ) -> tuple[str, str] | None:
         """Resolve Basic Auth credentials for a device by IP."""
         if not self._authentication_service:
             return None
 
-        mac = await self._ensure_mac(ip)
+        mac = await self._ensure_mac(ip, timeout)
         if not mac:
             return None
 
@@ -82,18 +87,24 @@ def invalidate_credential_cache(self, mac: str) -> None:
         normalized_mac = normalize_mac(mac)
         self._basic_auth_cache.pop(normalized_mac, None)
 
-    async def discover_device(self, ip: str) -> DiscoveredDevice | None:
+    async def discover_device(
+        self, ip: str, timeout: float | None = None
+    ) -> DiscoveredDevice | None:
         """Discover a legacy Gen1 Shelly device.
 
         Args:
             ip: Device IP address
+            timeout: Per-request timeout in seconds; falls back to the HTTP
+                client default when not provided.
 
         Returns:
             DiscoveredDevice or None if discovery fails
         """
         try:
             start_time = time.perf_counter()
-            device_info = await self._http_client.fetch_json(ip, "shelly")
+            device_info = await self._http_client.fetch_json(
+                ip, "shelly", timeout=timeout
+            )
             response_time = time.perf_counter() - start_time
 
             # Detect auth requirement from /shelly response
@@ -105,13 +116,16 @@ async def discover_device(self, ip: str) -> DiscoveredDevice | None:
                 normalized_mac = normalize_mac(mac)
                 self._ip_to_mac[normalize_mac(ip)] = normalized_mac
                 self._auth_state_cache.mark_auth_required(normalized_mac)
-                auth = await self._resolve_auth(ip)
-
-            status_data = await self._http_client.fetch_json_optional(
-                ip, "status", auth=auth
-            )
-            settings_data = await self._http_client.fetch_json_optional(
-                ip, "settings", auth=auth
+                auth = await self._resolve_auth(ip, timeout)
+
+            # /status and /settings are independent; fetch them concurrently.
+            status_data, settings_data = await asyncio.gather(
+                self._http_client.fetch_json_optional(
+                    ip, "status", auth=auth, timeout=timeout
+                ),
+                self._http_client.fetch_json_optional(
+                    ip, "settings", auth=auth, timeout=timeout
+                ),
             )
 
             device_name = self._derive_device_name(device_info, settings_data)
@@ -154,29 +168,37 @@ async def discover_device(self, ip: str) -> DiscoveredDevice | None:
             )
             return None
 
-    async def get_device_status(self, ip: str) -> DeviceStatus | None:
+    async def get_device_status(
+        self, ip: str, timeout: float | None = None
+    ) -> DeviceStatus | None:
         """Get device status for a legacy Gen1 device.
 
         Args:
             ip: Device IP address
+            timeout: Per-request timeout in seconds; falls back to the HTTP
+                client default when not provided.
 
         Returns:
             DeviceStatus or None if retrieval fails
         """
         try:
-            device_info = await self._http_client.fetch_json(ip, "shelly")
+            device_info = await self._http_client.fetch_json(
+                ip, "shelly", timeout=timeout
+            )
 
             auth: tuple[str, str] | None = None
             if device_info.get("auth", False):
                 mac = device_info.get("mac")
                 if mac:
                     normalized_mac = normalize_mac(mac)
                     self._ip_to_mac[normalize_mac(ip)] = normalized_mac
-                auth = await self._resolve_auth(ip)
+                auth = await self._resolve_auth(ip, timeout)
 
-            status_data = await self._http_client.fetch_json(ip, "status", auth=auth)
+            status_data = await self._http_client.fetch_json(
+                ip, "status", auth=auth, timeout=timeout
+            )
             settings_data = await self._http_client.fetch_json_optional(
-                ip, "settings", auth=auth
+                ip, "settings", auth=auth, timeout=timeout
             )
         except DeviceAuthenticationError:
             raise