Store nmap tracker options as lists (home-assistant#154378)

Author: emontnemery

homeassistant/components/nmap_tracker/__init__.py

@@ -29,6 +29,8 @@
 
 from .const import (
     CONF_HOME_INTERVAL,
+    CONF_HOSTS_EXCLUDE,
+    CONF_HOSTS_LIST,
     CONF_MAC_EXCLUDE,
     CONF_OPTIONS,
     DOMAIN,
@@ -104,6 +106,40 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return unload_ok
 
 
+async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Migrate config entry."""
+    _LOGGER.debug(
+        "Migrating configuration from version %s.%s", entry.version, entry.minor_version
+    )
+
+    if entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
+    if entry.version == 1:
+        new_options = {**entry.options}
+        if entry.minor_version < 2:
+            new_options[CONF_HOSTS_LIST] = cv.ensure_list_csv(
+                new_options.get(CONF_HOSTS, [])
+            )
+            new_options[CONF_HOSTS_EXCLUDE] = cv.ensure_list_csv(
+                new_options.get(CONF_EXCLUDE, [])
+            )
+            new_options[CONF_MAC_EXCLUDE] = []
+
+    hass.config_entries.async_update_entry(
+        entry, options=new_options, minor_version=2, version=1
+    )
+
+    _LOGGER.debug(
+        "Migration to configuration version %s.%s successful",
+        entry.version,
+        entry.minor_version,
+    )
+
+    return True
+
+
 @callback
 def _async_untrack_devices(hass: HomeAssistant, entry: ConfigEntry) -> None:
     """Remove tracking for devices owned by this config entry."""
@@ -159,10 +195,8 @@ async def async_setup(self):
         self._scan_interval = timedelta(
             seconds=config.get(CONF_SCAN_INTERVAL, TRACKER_SCAN_INTERVAL)
         )
-        hosts_list = cv.ensure_list_csv(config[CONF_HOSTS])
-        self._hosts = [host for host in hosts_list if host != ""]
-        excludes_list = cv.ensure_list_csv(config[CONF_EXCLUDE])
-        self._exclude = [exclude for exclude in excludes_list if exclude != ""]
+        self._hosts = config.get(CONF_HOSTS_LIST, [])
+        self._exclude = config.get(CONF_HOSTS_EXCLUDE, [])
         self._mac_exclude = config.get(CONF_MAC_EXCLUDE, [])
         self._options = config[CONF_OPTIONS]
         self.home_interval = timedelta(

homeassistant/components/nmap_tracker/config_flow.py

@@ -21,15 +21,15 @@
     ConfigFlowResult,
     OptionsFlowWithReload,
 )
-from homeassistant.const import CONF_EXCLUDE, CONF_HOSTS
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.selector import TextSelector, TextSelectorConfig
 from homeassistant.helpers.typing import VolDictType
 
 from .const import (
     CONF_HOME_INTERVAL,
+    CONF_HOSTS_EXCLUDE,
+    CONF_HOSTS_LIST,
     CONF_MAC_EXCLUDE,
     CONF_OPTIONS,
     DEFAULT_OPTIONS,
@@ -56,11 +56,9 @@ async def async_get_network(hass: HomeAssistant) -> str:
     return str(ip_network(f"{local_ip}/{network_prefix}", False))
 
 
-def _normalize_ips_and_network(hosts_str: str) -> list[str] | None:
+def _normalize_ips_and_network(hosts: list[str]) -> list[str] | None:
     """Check if a list of hosts are all ips or ip networks."""
-
     normalized_hosts = []
-    hosts = [host for host in cv.ensure_list_csv(hosts_str) if host != ""]
 
     for host in sorted(hosts):
         try:
@@ -118,17 +116,17 @@ def _normalize_mac_addresses(mac_addresses: list[str]) -> list[str] | None:
 def normalize_input(user_input: dict[str, Any]) -> dict[str, str]:
     """Validate hosts and exclude are valid."""
     errors = {}
-    normalized_hosts = _normalize_ips_and_network(user_input[CONF_HOSTS])
+    normalized_hosts = _normalize_ips_and_network(user_input[CONF_HOSTS_LIST])
     if not normalized_hosts:
-        errors[CONF_HOSTS] = "invalid_hosts"
+        errors[CONF_HOSTS_LIST] = "invalid_hosts"
     else:
-        user_input[CONF_HOSTS] = ",".join(normalized_hosts)
+        user_input[CONF_HOSTS_LIST] = normalized_hosts
 
-    normalized_exclude = _normalize_ips_and_network(user_input[CONF_EXCLUDE])
+    normalized_exclude = _normalize_ips_and_network(user_input[CONF_HOSTS_EXCLUDE])
     if normalized_exclude is None:
-        errors[CONF_EXCLUDE] = "invalid_hosts"
+        errors[CONF_HOSTS_EXCLUDE] = "invalid_hosts"
     else:
-        user_input[CONF_EXCLUDE] = ",".join(normalized_exclude)
+        user_input[CONF_HOSTS_EXCLUDE] = normalized_exclude
 
     normalized_mac_exclude = _normalize_mac_addresses(user_input[CONF_MAC_EXCLUDE])
     if normalized_mac_exclude is None:
@@ -142,18 +140,23 @@ def normalize_input(user_input: dict[str, Any]) -> dict[str, str]:
 async def _async_build_schema_with_user_input(
     hass: HomeAssistant, user_input: dict[str, Any], include_options: bool
 ) -> vol.Schema:
-    hosts = user_input.get(CONF_HOSTS, await async_get_network(hass))
-    exclude = user_input.get(
-        CONF_EXCLUDE, await network.async_get_source_ip(hass, MDNS_TARGET_IP)
+    hosts = user_input.get(CONF_HOSTS_LIST, [await async_get_network(hass)])
+    ip_exclude = user_input.get(
+        CONF_HOSTS_EXCLUDE, [await network.async_get_source_ip(hass, MDNS_TARGET_IP)]
     )
+
     mac_exclude = user_input.get(CONF_MAC_EXCLUDE, [])
 
     schema: VolDictType = {
-        vol.Required(CONF_HOSTS, default=hosts): str,
+        vol.Required(CONF_HOSTS_LIST, default=hosts): TextSelector(
+            TextSelectorConfig(multiple=True)
+        ),
         vol.Required(
             CONF_HOME_INTERVAL, default=user_input.get(CONF_HOME_INTERVAL, 0)
         ): int,
-        vol.Optional(CONF_EXCLUDE, default=exclude): str,
+        vol.Optional(CONF_HOSTS_EXCLUDE, default=ip_exclude): TextSelector(
+            TextSelectorConfig(multiple=True)
+        ),
         vol.Optional(CONF_MAC_EXCLUDE, default=mac_exclude): TextSelector(
             TextSelectorConfig(multiple=True)
         ),
@@ -195,8 +198,9 @@ async def async_step_init(
             self.options.update(user_input)
 
             if not errors:
+                title_hosts = ", ".join(self.options[CONF_HOSTS_LIST])
                 return self.async_create_entry(
-                    title=f"Nmap Tracker {self.options[CONF_HOSTS]}", data=self.options
+                    title=f"Nmap Tracker {title_hosts}", data=self.options
                 )
 
         return self.async_show_form(
@@ -212,6 +216,7 @@ class NmapTrackerConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Nmap Tracker."""
 
     VERSION = 1
+    MINOR_VERSION = 2
 
     def __init__(self) -> None:
         """Initialize config flow."""
@@ -230,8 +235,9 @@ async def async_step_user(
             self.options.update(user_input)
 
             if not errors:
+                title_hosts = ", ".join(user_input[CONF_HOSTS_LIST])
                 return self.async_create_entry(
-                    title=f"Nmap Tracker {user_input[CONF_HOSTS]}",
+                    title=f"Nmap Tracker {title_hosts}",
                     data={},
                     options=user_input,
                 )
@@ -245,9 +251,9 @@ async def async_step_user(
         )
 
     def _async_is_unique_host_list(self, user_input: dict[str, Any]) -> bool:
-        hosts = _normalize_ips_and_network(user_input[CONF_HOSTS])
+        hosts = _normalize_ips_and_network(user_input[CONF_HOSTS_LIST])
         for entry in self._async_current_entries():
-            if _normalize_ips_and_network(entry.options[CONF_HOSTS]) == hosts:
+            if _normalize_ips_and_network(entry.options[CONF_HOSTS_LIST]) == hosts:
                 return False
         return True
 

homeassistant/components/nmap_tracker/const.py

@@ -13,6 +13,8 @@
 # Interval in minutes to exclude devices from a scan while they are home
 CONF_HOME_INTERVAL: Final = "home_interval"
 CONF_OPTIONS: Final = "scan_options"
+CONF_HOSTS_LIST: Final = "hosts_list"
+CONF_HOSTS_EXCLUDE: Final = "hosts_exclude"
 CONF_MAC_EXCLUDE: Final = "mac_exclude"
 DEFAULT_OPTIONS: Final = "-n -sn -PR -T4 --min-rate 10 --host-timeout 5s"
 

homeassistant/components/nmap_tracker/strings.json

@@ -24,9 +24,9 @@
       "user": {
         "description": "Configure hosts to be scanned by Nmap. IP address and excludes can be addresses (192.168.1.1), networks (192.168.0.0/24) or ranges (192.168.1.0-32).",
         "data": {
-          "hosts": "IP addresses or ranges (comma-separated) to scan",
+          "hosts": "IP address or range to scan",
           "home_interval": "Minimum number of minutes between scans of active devices (preserve battery)",
-          "exclude": "IP addresses (comma-separated) to exclude from tracking",
+          "exclude": "IP address to exclude from tracking",
           "mac_exclude": "MAC address to exclude from tracking",
           "scan_options": "Raw configurable scan options for Nmap"
         }