Implement #141 - add remote instance configuration to config flow (#144)

* Implement #141 - add remote instance configuration to config flow

* Include Home Assistant Version and Installation Type into discovery API (#145)

Author: lukas-hetzenecker

custom_components/remote_homeassistant/__init__.py

@@ -16,7 +16,6 @@
 import homeassistant.components.websocket_api.auth as api
 import homeassistant.helpers.config_validation as cv
 import voluptuous as vol
-from homeassistant.components.http import HomeAssistantView
 from homeassistant.config import DATA_CUSTOMIZE
 from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
 from homeassistant.const import (CONF_ABOVE, CONF_ACCESS_TOKEN, CONF_BELOW,
@@ -35,11 +34,13 @@
 from homeassistant.helpers.typing import ConfigType, HomeAssistantType
 from homeassistant.setup import async_setup_component
 
+from custom_components.remote_homeassistant.views import DiscoveryInfoView
+
 from .const import (CONF_EXCLUDE_DOMAINS, CONF_EXCLUDE_ENTITIES,
                     CONF_INCLUDE_DOMAINS, CONF_INCLUDE_ENTITIES,
                     CONF_LOAD_COMPONENTS, CONF_OPTIONS, CONF_REMOTE_CONNECTION,
                     CONF_SERVICE_PREFIX, CONF_SERVICES, CONF_UNSUB_LISTENER,
-                    DOMAIN)
+                    DOMAIN, REMOTE_ID)
 from .proxy_services import ProxyServices
 from .rest_api import UnsupportedVersion, async_get_discovery_info
 
@@ -179,6 +180,10 @@ async def _async_update_config_entry_if_from_yaml(hass, entries_by_id, conf):
             hass.config_entries.async_update_entry(entry, data=data, options=options)
 
 
+async def setup_remote_instance(hass: HomeAssistantType):
+    hass.http.register_view(DiscoveryInfoView())
+
+
 async def async_setup(hass: HomeAssistantType, config: ConfigType):
     """Set up the remote_homeassistant component."""
     hass.data.setdefault(DOMAIN, {})
@@ -201,7 +206,7 @@ async def _handle_reload(service):
 
         await asyncio.gather(*update_tasks)
 
-    hass.http.register_view(DiscoveryInfoView())
+    hass.async_create_task(setup_remote_instance(hass))
 
     hass.helpers.service.async_register_admin_service(
         DOMAIN,
@@ -223,29 +228,33 @@ async def _handle_reload(service):
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
     """Set up Remote Home-Assistant from a config entry."""
     _async_import_options_from_yaml(hass, entry)
-    remote = RemoteConnection(hass, entry)
-
-    hass.data[DOMAIN][entry.entry_id] = {
-        CONF_REMOTE_CONNECTION: remote,
-        CONF_UNSUB_LISTENER: entry.add_update_listener(_update_listener),
-    }
-
-    async def setup_components_and_platforms():
-        """Set up platforms and initiate connection."""
-        for domain in entry.options.get(CONF_LOAD_COMPONENTS, []):
-            hass.async_create_task(async_setup_component(hass, domain, {}))
-
-        await asyncio.gather(
-            *[
-                hass.config_entries.async_forward_entry_setup(entry, platform)
-                for platform in PLATFORMS
-            ]
-        )
-        await remote.async_connect()
+    if entry.unique_id == REMOTE_ID:
+        hass.async_create_task(setup_remote_instance(hass))
+        return True
+    else:
+        remote = RemoteConnection(hass, entry)
+
+        hass.data[DOMAIN][entry.entry_id] = {
+            CONF_REMOTE_CONNECTION: remote,
+            CONF_UNSUB_LISTENER: entry.add_update_listener(_update_listener),
+        }
+
+        async def setup_components_and_platforms():
+            """Set up platforms and initiate connection."""
+            for domain in entry.options.get(CONF_LOAD_COMPONENTS, []):
+                hass.async_create_task(async_setup_component(hass, domain, {}))
+
+            await asyncio.gather(
+                *[
+                    hass.config_entries.async_forward_entry_setup(entry, platform)
+                    for platform in PLATFORMS
+                ]
+            )
+            await remote.async_connect()
 
-    hass.async_create_task(setup_components_and_platforms())
+        hass.async_create_task(setup_components_and_platforms())
 
-    return True
+        return True
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
@@ -425,7 +434,7 @@ def _async_instance_id_match(info):
             name=info.get("location_name"),
             manufacturer="Home Assistant",
             model=info.get("installation_type"),
-            sw_version=info.get("version"),
+            sw_version=info.get("ha_version"),
         )
 
         asyncio.ensure_future(self._recv())
@@ -729,20 +738,3 @@ def got_states(message):
         await self.call(got_states, "get_states")
 
         await self.proxy_services.load()
-
-
-class DiscoveryInfoView(HomeAssistantView):
-    """Get all logged errors and warnings."""
-
-    url = "/api/remote_homeassistant/discovery"
-    name = "api:remote_homeassistant:discovery"
-
-    async def get(self, request):
-        """Get discovery information."""
-        hass = request.app["hass"]
-        return self.json(
-            {
-                "uuid": await hass.helpers.instance_id.async_get(),
-                "location_name": hass.config.location_name,
-            }
-        )

custom_components/remote_homeassistant/config_flow.py

@@ -1,13 +1,15 @@
 """Config flow for Remote Home-Assistant integration."""
 import logging
+import enum
+
 from urllib.parse import urlparse
 
 import homeassistant.helpers.config_validation as cv
 import voluptuous as vol
 from homeassistant import config_entries, core
 from homeassistant.const import (CONF_ABOVE, CONF_ACCESS_TOKEN, CONF_BELOW,
                                  CONF_ENTITY_ID, CONF_HOST, CONF_PORT,
-                                 CONF_UNIT_OF_MEASUREMENT, CONF_VERIFY_SSL)
+                                 CONF_UNIT_OF_MEASUREMENT, CONF_VERIFY_SSL, CONF_TYPE)
 from homeassistant.core import callback
 from homeassistant.helpers.instance_id import async_get
 from homeassistant.util import slugify
@@ -16,9 +18,9 @@
 from .const import (CONF_ENTITY_PREFIX,  # pylint:disable=unused-import
                     CONF_EXCLUDE_DOMAINS, CONF_EXCLUDE_ENTITIES, CONF_FILTER,
                     CONF_INCLUDE_DOMAINS, CONF_INCLUDE_ENTITIES,
-                    CONF_LOAD_COMPONENTS, CONF_OPTIONS, CONF_REMOTE_CONNECTION,
+                    CONF_LOAD_COMPONENTS, CONF_MAIN, CONF_OPTIONS, CONF_REMOTE, CONF_REMOTE_CONNECTION,
                     CONF_SECURE, CONF_SERVICE_PREFIX, CONF_SERVICES,
-                    CONF_SUBSCRIBE_EVENTS, DOMAIN)
+                    CONF_SUBSCRIBE_EVENTS, DOMAIN, REMOTE_ID)
 from .rest_api import (ApiProblem, CannotConnect, EndpointMissing, InvalidAuth,
                        UnsupportedVersion, async_get_discovery_info)
 
@@ -54,6 +56,13 @@ async def validate_input(hass: core.HomeAssistant, conf):
     return {"title": info["location_name"], "uuid": info["uuid"]}
 
 
+class InstanceType(enum.Enum):
+    """Possible options for instance type."""
+
+    remote = "Setup as remote node"
+    main = "Add a remote"
+
+
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Remote Home-Assistant."""
 
@@ -73,11 +82,36 @@ def async_get_options_flow(config_entry):
     async def async_step_user(self, user_input=None):
         """Handle the initial step."""
         errors = {}
+
+        if user_input is not None:
+            if user_input[CONF_TYPE] == CONF_REMOTE:
+                await self.async_set_unique_id(REMOTE_ID)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(title="Remote instance", data=user_input)
+
+            elif user_input[CONF_TYPE] == CONF_MAIN:
+                return await self.async_step_connection_details()
+            
+            errors["base"] = "unknown"
+            
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_TYPE): vol.In([CONF_REMOTE, CONF_MAIN])
+                }
+            ),
+            errors=errors,
+        )
+
+
+    async def async_step_connection_details(self, user_input=None):
+        """Handle the connection details step."""
+        errors = {}
         if user_input is not None:
             try:
                 info = await validate_input(self.hass, user_input)
             except ApiProblem:
-                _LOGGER.exception("test")
                 errors["base"] = "api_problem"
             except CannotConnect:
                 errors["base"] = "cannot_connect"
@@ -99,7 +133,7 @@ async def async_step_user(self, user_input=None):
         port = self.prefill.get(CONF_PORT) or vol.UNDEFINED
         secure = self.prefill.get(CONF_SECURE) or vol.UNDEFINED
         return self.async_show_form(
-            step_id="user",
+            step_id="connection_details",
             data_schema=vol.Schema(
                 {
                     vol.Required(CONF_HOST, default=host): str,
@@ -138,7 +172,7 @@ async def async_step_zeroconf(self, info):
         # pylint: disable=no-member # https://github.com/PyCQA/pylint/issues/3167
         self.context["identifier"] = self.unique_id
         self.context["title_placeholders"] = {"name": properties["location_name"]}
-        return await self.async_step_user()
+        return await self.async_step_connection_details()
 
     async def async_step_import(self, user_input):
         """Handle import from YAML."""
@@ -164,14 +198,17 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
     """Handle options flow for the Home Assistant remote integration."""
 
     def __init__(self, config_entry):
-        """Initialize localtuya options flow."""
+        """Initialize remote_homeassistant options flow."""
         self.config_entry = config_entry
         self.filters = None
         self.events = None
         self.options = None
 
     async def async_step_init(self, user_input=None):
         """Manage basic options."""
+        if self.config_entry.unique_id == REMOTE_ID:
+            return
+        
         if user_input is not None:
             self.options = user_input.copy()
             return await self.async_step_domain_entity_filters()

custom_components/remote_homeassistant/const.py

@@ -19,4 +19,10 @@
 CONF_EXCLUDE_DOMAINS = "exclude_domains"
 CONF_EXCLUDE_ENTITIES = "exclude_entities"
 
+# FIXME: There seems to be ne way to make these strings translateable
+CONF_MAIN = "Add a remote node"
+CONF_REMOTE = "Setup as remote node"
+
 DOMAIN = "remote_homeassistant"
+
+REMOTE_ID = "remote"

custom_components/remote_homeassistant/sensor.py

@@ -1,7 +1,7 @@
 """Sensor platform for connection status.."""
 from homeassistant.const import CONF_HOST, CONF_PORT, CONF_VERIFY_SSL
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.entity import DeviceInfo, Entity
 
 from .const import CONF_ENTITY_PREFIX, CONF_SECURE
 
@@ -12,37 +12,31 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
 
 
 class ConnectionStatusSensor(Entity):
-    """Representation of a Tuya sensor."""
+    """Representation of a remote_homeassistant sensor."""
 
     def __init__(self, config_entry):
-        """Initialize the Tuya sensor."""
+        """Initialize the remote_homeassistant sensor."""
         self._state = None
         self._entry = config_entry
 
-    @property
-    def name(self):
-        """Return name of sensor."""
-        host = self._entry.data[CONF_HOST]
-        port = self._entry.data[CONF_PORT]
-        return f"Remote connection to {host}:{port}"
+        proto = 'http' if config_entry.data.get(CONF_SECURE) else 'https'
+        host = config_entry.data[CONF_HOST]
+        port = config_entry.data[CONF_PORT]
+        self._attr_name = f"Remote connection to {host}:{port}"
+        self._attr_unique_id = config_entry.unique_id
+        self._attr_should_poll = False
+        self._attr_device_info = DeviceInfo(
+            name="Home Assistant",
+            configuration_url=f"{proto}://{host}:{port}",
+        )
 
     @property
     def state(self):
         """Return sensor state."""
         return self._state
 
     @property
-    def unique_id(self):
-        """Return unique device identifier."""
-        return self._entry.unique_id
-
-    @property
-    def should_poll(self):
-        """Return if entity should be polled."""
-        return False
-
-    @property
-    def device_state_attributes(self):
+    def extra_state_attributes(self):
         """Return device state attributes."""
         return {
             "host": self._entry.data[CONF_HOST],

custom_components/remote_homeassistant/translations/en.json

@@ -3,6 +3,11 @@
     "flow_title": "Remote: {name}",
     "step": {
       "user": {
+        "title": "Select installation type",
+        "description": "The remote node is the instance on which the states are gathered from"
+      },
+      "connection_details": {
+        "title": "Connection details",
         "data": {
           "host": "Host",
           "port": "Port",

custom_components/remote_homeassistant/views.py

@@ -0,0 +1,25 @@
+import homeassistant
+from homeassistant.components.http import HomeAssistantView
+from homeassistant.helpers.system_info import async_get_system_info
+
+ATTR_INSTALLATION_TYPE = "installation_type"
+
+
+class DiscoveryInfoView(HomeAssistantView):
+    """Get all logged errors and warnings."""
+
+    url = "/api/remote_homeassistant/discovery"
+    name = "api:remote_homeassistant:discovery"
+
+    async def get(self, request):
+        """Get discovery information."""
+        hass = request.app["hass"]
+        system_info = await async_get_system_info(hass)
+        return self.json(
+            {
+                "uuid": await hass.helpers.instance_id.async_get(),
+                "location_name": hass.config.location_name,
+                "ha_version": homeassistant.const.__version__,
+                "installation_type": system_info[ATTR_INSTALLATION_TYPE],
+            }
+        )