Merge pull request #104 from sirkirby/dev

New Networks, Port Profiles, Curated network lists, Smart Polling & Trigger system

Author: sirkirby

.cursor/rules/unr-rules.mdc

@@ -4,7 +4,7 @@ globs: custom_components/**/*.py
 alwaysApply: true
 ---
 
-## Rules
+# Rules
 
 - Always keep the code DRY for testability and separation of concerns
 - Prefer modern idiomatic Python 3.13 and open source conventions, Leverage type hints, use CONST over hard coded strings
@@ -15,6 +15,7 @@ alwaysApply: true
 - When fixing a problem or bug, avoid treating the symptom, look for the root cause.
 - Details matter, ensure to always preserve existing functionality unless otherwise instructed.
 - KISS
+- Maintain consistent code hygiene by addressing code and markdown linting errors and warnings.
 
 ## Notes
 
@@ -25,4 +26,4 @@ alwaysApply: true
 
 ## Purpose
 
-The focus of this home assistant custom integration is to extend the functionality of the Unifi Network application within the home assistant ecosystem. Build upon the home assistant unifi core integration and the aiounifi library. Bundling and enabling advanced automation, customizable backup and restore, and to be generally useful for homelab and home automation environments. Some examples: enhancing guest network access. Managing child device access. Promoting good security practices. This is open source and should remain accessible and usable by a wide variety of users and supported devices.
+The focus of this home assistant custom integration is to extend the functionality of the Unifi Network application within the home assistant ecosystem. Build upon the home assistant unifi core integration and the aiounifi library. Bundling and enabling advanced automation, customizable backup and restore, and to be generally useful for homelab and home automation environments. Some examples: enhancing guest network access. Managing child device access. Promoting good security practices. This is open source and should remain accessible and usable by a wide variety of users and supported devices.

.pylintrc

@@ -0,0 +1,2 @@
+[MESSAGES CONTROL]
+disable=line-too-long,trailing-whitespace,broad-exception-caught

README.md

@@ -1,10 +1,58 @@
 {
-    "version": "0.2",
+    "version": "0.2", 
     "language": "en",
+    "ignorePaths": [
+      "**/translations/*.json"
+    ],
     "words": [
       "homeassistant",
       "hass",
       "UDMAPI",
-      "unifi"
+      "unifi",
+      "aiounifi",
+      "clientsession",
+      "wlans",
+      "Wlans",
+      "WLAN",
+      "wlan",
+      "Wlan",
+      "Ubiquiti",
+      "unsub",
+      "trafficroutes",
+      "trafficrules",
+      "firewallrule",
+      "wlanconf",
+      "portforward",
+      "networkconf",
+      "portconf",
+      "wlanrate",
+      "radiusprofile",
+      "wansla",
+      "firewallgroup",
+      "networkconfs",
+      "mgmt",
+      "keepalive",
+      "retryable",
+      "cooldown",
+      "Cooldown",
+      "gmtime",
+      "traefik",
+      "networkgroup",
+      "Aiounifi",
+      "automations",
+      "hacs",
+      "HACS",
+      "Mjolnir",
+      "asyncio",
+      "codeowners",
+      "sirkirby",
+      "aiohttp",
+      "orjson",
+      "aabbccddeeff",
+      "elif",
+      "chrisiphone",
+      "venv",
+      "pytest",
+      "toggleable"
     ]
   }

cspell.json

@@ -1,22 +1,14 @@
 """Support for UniFi Network Rules."""
 from __future__ import annotations
-from typing import Any, Dict, List
-from datetime import timedelta
-import logging
-import importlib
+from typing import Any
 import asyncio
-import async_timeout
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD, CONF_VERIFY_SSL, Platform, CONF_PORT
-from homeassistant.helpers.typing import ConfigType
-from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv, entity_platform
+from homeassistant.const import CONF_HOST, CONF_USERNAME, CONF_PASSWORD, CONF_VERIFY_SSL
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_send
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity_registry import async_get as async_get_entity_registry
 
 # Import interface classes from aiounifi
@@ -29,8 +21,6 @@
 
 from .const import (
     DOMAIN,
-    CONF_UPDATE_INTERVAL,
-    DEFAULT_UPDATE_INTERVAL,
     DEFAULT_SITE,
     LOGGER,
     PLATFORMS,
@@ -41,9 +31,8 @@
 from .udm.api import UDMAPI
 
 # Import local modules at the module level - ORDER MATTERS HERE
-from .websocket import UnifiRuleWebsocket
 from .coordinator import UnifiRuleUpdateCoordinator
-from .services import async_setup_services, async_unload_services
+from .services import async_setup_services
 from .helpers.rule import get_rule_id
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -91,18 +80,31 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             # Initialize interfaces
             await api.controller.initialize()
 
-        # Create websocket
-        websocket_handler = UnifiRuleWebsocket(hass, api, entry.entry_id)
+        # Get smart polling configuration from entry options
+        smart_polling_config = {
+            "base_interval": entry.options.get("base_interval", 300),
+            "active_interval": entry.options.get("active_interval", 30),
+            "realtime_interval": entry.options.get("realtime_interval", 10),
+            "activity_timeout": entry.options.get("activity_timeout", 120),
+            "debounce_seconds": entry.options.get("debounce_seconds", 10),
+            "optimistic_timeout": entry.options.get("optimistic_timeout", 15),
+        }
 
-        # Setup the coordinator
-        coordinator = UnifiRuleUpdateCoordinator(hass, api, websocket_handler)
+        # Setup the coordinator with smart polling
+        # Use baseline interval from smart polling config for the coordinator
+        baseline_interval = smart_polling_config.get("base_interval", 300)
+        coordinator = UnifiRuleUpdateCoordinator(
+            hass, 
+            api, 
+            update_interval=baseline_interval,  # Use baseline for coordinator's built-in polling
+            smart_polling_config=smart_polling_config
+        )
 
         # Explicitly set the config_entry reference
         coordinator.config_entry = entry
 
-        # Connect the websocket handler to the coordinator
-        websocket_handler.set_callback(coordinator._handle_websocket_message)
-        LOGGER.debug("Set websocket handler callback to coordinator's message handler")
+        # WebSocket removed - using smart polling only
+        LOGGER.info("Smart polling architecture enabled - WebSocket disabled")
 
         # Define entity removal callback
         @callback
@@ -135,7 +137,6 @@ async def create_entity_wrapper(rule_type: str, rule: Any) -> bool:
         hass.data[DOMAIN][entry.entry_id] = {
             "api": api,
             "coordinator": coordinator,
-            "websocket": websocket_handler,
         }
 
         # Start initial data refresh
@@ -144,13 +145,8 @@ async def create_entity_wrapper(rule_type: str, rule: Any) -> bool:
         # Setup platforms
         await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-        # Start the websocket connection
-        try:
-            websocket_handler.start()
-            LOGGER.info("WebSocket connection established successfully")
-        except Exception as ws_err:  # pylint: disable=broad-except
-            LOGGER.error("Error setting up WebSocket: %s", ws_err)
-            # Continue even if WebSocket fails - we can still use polling
+        # WebSocket removed - smart polling handles all updates
+        LOGGER.info("Integration initialized with smart polling architecture")
 
         # Register the coordinator with the services registry
         if "services" in hass.data[DOMAIN] and "register_coordinator" in hass.data[DOMAIN]["services"]:
@@ -207,7 +203,7 @@ def _handle_entity_registry_updated(event):
                 return
 
             entity_id = event.data.get("entity_id", "")
-            if not entity_id.startswith("switch.") or not DOMAIN in entity_id:
+            if not entity_id.startswith("switch.") or DOMAIN not in entity_id:
                 return
 
             unique_id = event.data.get("unique_id", "")
@@ -255,7 +251,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         if unload_ok:
             # Clean up data if unload was successful
             api: UDMAPI = entry_data["api"]
-            websocket: UnifiRuleWebsocket = entry_data["websocket"]
             coordinator: UnifiRuleUpdateCoordinator = entry_data["coordinator"]
 
             # Clean up additional listeners if they exist
@@ -265,7 +260,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
             # Clean up everything
             await coordinator.async_shutdown()
-            await websocket.async_stop()
             await api.cleanup()
 
             # Remove entry from hass.data
@@ -382,6 +376,9 @@ async def async_create_entity(hass: HomeAssistant, rule_type: str, rule: Any) ->
         elif rule_type == "vpn_clients":
             from .switch import UnifiVPNClientSwitch
             entity = UnifiVPNClientSwitch(coordinator, rule, rule_type, config_entry_id)
+        elif rule_type == "vpn_servers":
+            from .switch import UnifiVPNServerSwitch
+            entity = UnifiVPNServerSwitch(coordinator, rule, rule_type, config_entry_id)
         else:
             LOGGER.warning("Unknown rule type for entity creation: %s", rule_type)
             return False
@@ -445,4 +442,4 @@ async def async_create_entity(hass: HomeAssistant, rule_type: str, rule: Any) ->
             LOGGER.error("Error creating entity: %s", err)
             return False
 
-    return False
+    return False

custom_components/unifi_network_rules/__init__.py

@@ -9,21 +9,25 @@
 from homeassistant import config_entries
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, CONF_VERIFY_SSL
 from homeassistant.data_entry_flow import FlowResult
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 
 from .const import (
     DOMAIN,
     CONF_UPDATE_INTERVAL,
     DEFAULT_UPDATE_INTERVAL,
     CONF_SITE,
     DEFAULT_SITE,
-    LOGGER
+    LOGGER,
+    CONF_SMART_POLLING_BASE_INTERVAL,
+    CONF_SMART_POLLING_ACTIVE_INTERVAL,
+    CONF_SMART_POLLING_REALTIME_INTERVAL,
+    CONF_SMART_POLLING_ACTIVITY_TIMEOUT,
+    CONF_SMART_POLLING_DEBOUNCE_SECONDS,
+    CONF_SMART_POLLING_OPTIMISTIC_TIMEOUT,
 )
 from .udm import CannotConnect, InvalidAuth, UDMAPI
 
 from aiounifi.errors import (
-    AiounifiException,
     LoginRequired,
     RequestError,
     ResponseError,
@@ -113,4 +117,73 @@ async def async_step_user(self, user_input: dict[str, Any] | None = None) -> Flo
 
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )
+        )
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry):
+        """Get the options flow."""
+        return UnifiNetworkRulesOptionsFlowHandler(config_entry)
+
+
+class UnifiNetworkRulesOptionsFlowHandler(config_entries.OptionsFlow):
+    """Handle options flow for UniFi Network Rules."""
+
+    def __init__(self, config_entry):
+        """Initialize options flow."""
+        self.config_entry = config_entry
+
+    async def async_step_init(self, user_input=None):
+        """Handle options flow."""
+        if user_input is not None:
+            return self.async_create_entry(title="", data=user_input)
+
+        # Get current options with defaults
+        options = self.config_entry.options
+        
+        # Smart polling configuration schema
+        options_schema = vol.Schema({
+            vol.Optional(
+                CONF_SMART_POLLING_BASE_INTERVAL,
+                default=options.get(CONF_SMART_POLLING_BASE_INTERVAL, 300),
+                description="Base polling interval when idle (seconds)"
+            ): vol.All(int, vol.Range(min=30, max=3600)),
+            
+            vol.Optional(
+                CONF_SMART_POLLING_ACTIVE_INTERVAL,
+                default=options.get(CONF_SMART_POLLING_ACTIVE_INTERVAL, 30),
+                description="Active polling interval during user activity (seconds)"
+            ): vol.All(int, vol.Range(min=10, max=300)),
+            
+            vol.Optional(
+                CONF_SMART_POLLING_REALTIME_INTERVAL,
+                default=options.get(CONF_SMART_POLLING_REALTIME_INTERVAL, 10),
+                description="Real-time polling interval during changes (seconds)"
+            ): vol.All(int, vol.Range(min=5, max=60)),
+            
+            vol.Optional(
+                CONF_SMART_POLLING_ACTIVITY_TIMEOUT,
+                default=options.get(CONF_SMART_POLLING_ACTIVITY_TIMEOUT, 120),
+                description="Time to return to base interval after activity (seconds)"
+            ): vol.All(int, vol.Range(min=60, max=600)),
+            
+            vol.Optional(
+                CONF_SMART_POLLING_DEBOUNCE_SECONDS,
+                default=options.get(CONF_SMART_POLLING_DEBOUNCE_SECONDS, 10),
+                description="Debounce window for rapid changes (seconds)"
+            ): vol.All(int, vol.Range(min=5, max=60)),
+            
+            vol.Optional(
+                CONF_SMART_POLLING_OPTIMISTIC_TIMEOUT,
+                default=options.get(CONF_SMART_POLLING_OPTIMISTIC_TIMEOUT, 15),
+                description="Maximum optimistic state duration (seconds)"
+            ): vol.All(int, vol.Range(min=10, max=60)),
+        })
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=options_schema,
+            description_placeholders={
+                "name": self.config_entry.title
+            }
+        )