Merge pull request #745 from home-assistant/dev

Release 134

.dockerignore

@@ -7,3 +7,7 @@
 
 # Temporary files
 **/__pycache__
+
+# virtualenv
+venv/
+ENV/

.github/release-drafter.yml

@@ -0,0 +1,4 @@
+template: |
+  ## What's Changed
+
+  $CHANGES

.gitignore

@@ -90,3 +90,6 @@ ENV/
 
 # pylint
 .pylint.d/
+
+# VS Code
+.vscode/

.travis.yml

@@ -1,12 +1,6 @@
-sudo: false
-matrix:
-  fast_finish: true
-  include:
-    - python: "3.6"
-
-cache:
-  directories:
-    - $HOME/.cache/pip
+sudo: true
+dist: xenial
 install: pip install -U tox
 language: python
+python: 3.7
 script: tox

API.md

@@ -1,4 +1,4 @@
-# Hass.io Server
+# Hass.io
 
 ## Hass.io RESTful API
 
@@ -27,6 +27,9 @@ For access to API you need set the `X-HASSIO-KEY` they will be available for Add
 ### Hass.io
 
 - GET `/supervisor/ping`
+
+This API call don't need a token.
+
 - GET `/supervisor/info`
 
 The addons from `addons` are only installed one.
@@ -36,7 +39,7 @@ The addons from `addons` are only installed one.
     "version": "INSTALL_VERSION",
     "last_version": "LAST_VERSION",
     "arch": "armhf|aarch64|i386|amd64",
-    "beta_channel": "true|false",
+    "channel": "stable|beta|dev",
     "timezone": "TIMEZONE",
     "wait_boot": "int",
     "addons": [
@@ -72,7 +75,7 @@ Optional:
 
 ```json
 {
-    "beta_channel": "true|false",
+    "channel": "stable|beta|dev",
     "timezone": "TIMEZONE",
     "wait_boot": "int",
     "addons_repositories": [
@@ -217,22 +220,22 @@ return:
 ### Host
 
 - POST `/host/reload`
+
 - POST `/host/shutdown`
+
 - POST `/host/reboot`
+
 - GET `/host/info`
 
 ```json
 {
-    "type": "",
-    "version": "",
-    "last_version": "",
-    "features": ["shutdown", "reboot", "update", "hostname", "network_info", "network_control"],
-    "hostname": "",
-    "os": "",
-    "audio": {
-        "input": "0,0",
-        "output": "0,0"
-    }
+    "hostname": "hostname|null",
+    "features": ["shutdown", "reboot", "hostname", "services", "hassos"],
+    "operating_system": "HassOS XY|Ubuntu 16.4|null",
+    "kernel": "4.15.7|null",
+    "chassis": "specific|null",
+    "deployment": "stable|beta|dev|null",
+    "cpe": "xy|null",
 }
 ```
 
@@ -240,22 +243,67 @@ return:
 
 ```json
 {
-    "audio_input": "0,0",
-    "audio_output": "0,0"
+    "hostname": "",
 }
 ```
 
-- POST `/host/update`
+- POST `/host/reload`
 
-Optional:
+#### Services
 
+- GET `/host/services`
 ```json
 {
-    "version": "VERSION"
+    "services": [
+        {
+            "name": "xy.service",
+            "description": "XY ...",
+            "state": "active|"
+        }
+    ]
 }
 ```
 
-- GET `/host/hardware`
+- POST `/host/service/{unit}/stop`
+
+- POST `/host/service/{unit}/start`
+
+- POST `/host/service/{unit}/reload`
+
+### HassOS
+
+- GET `/hassos/info`
+```json
+{
+    "version": "2.3",
+    "version_cli": "7",
+    "version_latest": "2.4",
+    "version_cli_latest": "8",
+    "board": "ova|rpi"
+}
+```
+
+- POST `/hassos/update`
+```json
+{
+    "version": "optional"
+}
+```
+
+- POST `/hassos/update/cli`
+```json
+{
+    "version": "optional"
+}
+```
+
+- POST `/hassos/config/sync`
+
+Load host configs from a USB stick.
+
+### Hardware
+
+- GET `/hardware/info`
 ```json
 {
     "serial": ["/dev/xy"],
@@ -274,23 +322,18 @@ Optional:
 }
 ```
 
-- POST `/host/reload`
-
-### Network
-
-- GET `/network/info`
-
+- GET `/hardware/audio`
 ```json
 {
-    "hostname": ""
-}
-```
-
-- POST `/network/options`
-
-```json
-{
-    "hostname": "",
+    "audio": {
+        "input": {
+            "0,0": "Mic"
+        },
+        "output": {
+            "1,0": "Jack",
+            "1,1": "HDMI"
+        }
+    }
 }
 ```
 
@@ -302,6 +345,7 @@ Optional:
 {
     "version": "INSTALL_VERSION",
     "last_version": "LAST_VERSION",
+    "machine": "Image machine type",
     "image": "str",
     "custom": "bool -> if custom image",
     "boot": "bool",
@@ -340,6 +384,7 @@ Output is the raw Docker log.
     "port": "port for access hass",
     "ssl": "bool",
     "password": "",
+    "refresh_token": "",
     "watchdog": "bool",
     "startup_time": 600
 }
@@ -370,6 +415,8 @@ Proxy to real websocket instance.
 
 ### RESTful for API addons
 
+If a add-on will call itself, you can use `/addons/self/...`.
+
 - GET `/addons`
 
 Get all available addons.
@@ -381,11 +428,11 @@ Get all available addons.
             "name": "xy bla",
             "slug": "xy",
             "description": "description",
-            "arch": ["armhf", "aarch64", "i386", "amd64"],
             "repository": "core|local|REP_ID",
             "version": "LAST_VERSION",
             "installed": "none|INSTALL_VERSION",
             "detached": "bool",
+            "available": "bool",
             "build": "bool",
             "url": "null|url",
             "icon": "bool",
@@ -410,11 +457,15 @@ Get all available addons.
 ```json
 {
     "name": "xy bla",
+    "slug": "xdssd_xybla",
     "description": "description",
     "long_description": "null|markdown",
     "auto_update": "bool",
     "url": "null|url of addon",
     "detached": "bool",
+    "available": "bool",
+    "arch": ["armhf", "aarch64", "i386", "amd64"],
+    "machine": "[raspberrypi2, tinker]",
     "repository": "12345678|null",
     "version": "null|VERSION_INSTALLED",
     "last_version": "LAST_VERSION",
@@ -424,24 +475,32 @@ Get all available addons.
     "options": "{}",
     "network": "{}|null",
     "host_network": "bool",
+    "host_pid": "bool",
     "host_ipc": "bool",
     "host_dbus": "bool",
     "privileged": ["NET_ADMIN", "SYS_ADMIN"],
+    "apparmor": "disable|default|profile",
     "devices": ["/dev/xy"],
     "auto_uart": "bool",
     "icon": "bool",
     "logo": "bool",
     "changelog": "bool",
     "hassio_api": "bool",
+    "hassio_role": "default|homeassistant|manager|admin",
     "homeassistant_api": "bool",
+    "full_access": "bool",
+    "protected": "bool",
+    "rating": "1-6",
     "stdin": "bool",
     "webui": "null|http(s)://[HOST]:port/xy/zx",
     "gpio": "bool",
+    "devicetree": "bool",
+    "docker_api": "bool",
     "audio": "bool",
     "audio_input": "null|0,0",
     "audio_output": "null|0,0",
-    "services": "null|['mqtt']",
-    "discovery": "null|['component/platform']"
+    "services_role": "['service:access']",
+    "discovery": "['service']"
 }
 ```
 
@@ -468,6 +527,16 @@ Get all available addons.
 
 Reset custom network/audio/options, set it `null`.
 
+- POST `/addons/{addon}/security`
+
+This function is not callable by itself.
+
+```json
+{
+    "protected": "bool",
+}
+```
+
 - POST `/addons/{addon}/start`
 
 - POST `/addons/{addon}/stop`
@@ -505,39 +574,36 @@ Write data to add-on stdin
 }
 ```
 
-### Service discovery
+### discovery
 
-- GET `/services/discovery`
+- GET `/discovery`
 ```json
 {
     "discovery": [
         {
-            "provider": "name",
+            "addon": "slug",
+            "service": "name",
             "uuid": "uuid",
-            "component": "component",
-            "platform": "null|platform",
             "config": {}
         }
     ]
 }
 ```
 
-- GET `/services/discovery/{UUID}`
+- GET `/discovery/{UUID}`
 ```json
 {
-    "provider": "name",
+    "addon": "slug",
+    "service": "name",
     "uuid": "uuid",
-    "component": "component",
-    "platform": "null|platform",
     "config": {}
 }
 ```
 
-- POST `/services/discovery`
+- POST `/discovery`
 ```json
 {
-    "component": "component",
-    "platform": "null|platform",
+    "service": "name",
     "config": {}
 }
 ```
@@ -549,7 +615,9 @@ return:
 }
 ```
 
-- DEL `/services/discovery/{UUID}`
+- DEL `/discovery/{UUID}`
+
+### Services
 
 - GET `/services`
 ```json
@@ -558,28 +626,18 @@ return:
         {
             "slug": "name",
             "available": "bool",
-            "provider": "null|name|list"
+            "providers": "list"
         }
     ]
 }
 ```
 
-- GET `/services/xy`
-```json
-{
-    "available": "bool",
-    "xy": {}
-}
-```
-
 #### MQTT
 
-This service perform a auto discovery to Home-Assistant.
-
 - GET `/services/mqtt`
 ```json
 {
-    "provider": "name",
+    "addon": "name",
     "host": "xy",
     "port": "8883",
     "ssl": "bool",
@@ -603,45 +661,16 @@ This service perform a auto discovery to Home-Assistant.
 
 - DEL `/services/mqtt`
 
-## Host Control
-
-Communicate over UNIX socket with a host daemon.
-
-- commands
+### Misc
 
+- GET `/version`
+```json
+{
+    "supervisor": "version",
+    "homeassistant": "version",
+    "hassos": "null|version",
+    "machine": "type",
+    "arch": "arch",
+    "channel": "stable|beta|dev"
+}
 ```
-# info
--> {'type', 'version', 'last_version', 'features', 'hostname'}
-# reboot
-# shutdown
-# host-update [v]
-
-# hostname xy
-
-# network info
--> {}
-# network wlan ssd xy
-# network wlan password xy
-# network int ip xy
-# network int netmask xy
-# network int route xy
-```
-
-Features:
-
-- shutdown
-- reboot
-- update
-- hostname
-- network_info
-- network_control
-
-Answer:
-```
-{}|OK|ERROR|WRONG
-```
-
-- {}: json
-- OK: call was successfully
-- ERROR: error on call
-- WRONG: not supported

Dockerfile

@@ -1,24 +1,22 @@
 ARG BUILD_FROM
 FROM $BUILD_FROM
 
-# Add env
-ENV LANG C.UTF-8
-
-# Setup base
+# Install base
 RUN apk add --no-cache \
-        python3 \
-        git \
-        socat \
-        libstdc++ \
-    && apk add --no-cache --virtual .build-dependencies \
+    git \
+    socat \
+    glib \
+    libstdc++ \
+    eudev-libs
+
+# Install requirements
+COPY requirements.txt /usr/src/
+RUN apk add --no-cache --virtual .build-dependencies \
         make \
-        python3-dev \
         g++ \
-    && pip3 install --no-cache-dir \
-        uvloop==0.9.1 \
-        cchardet==2.1.1 \
-        pycryptodome==3.4.11 \
-    && apk del .build-dependencies
+    && pip3 install --no-cache-dir -r /usr/src/requirements.txt \
+    && apk del .build-dependencies \
+    && rm -f /usr/src/requirements.txt
 
 # Install HassIO
 COPY . /usr/src/hassio

hassio/__init__.py

@@ -1 +1 @@
-"""Init file for HassIO."""
+"""Init file for Hass.io."""

hassio/__main__.py

@@ -1,11 +1,10 @@
-"""Main file for HassIO."""
+"""Main file for Hass.io."""
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
 import logging
 import sys
 
-import hassio.bootstrap as bootstrap
-import hassio.core as core
+from hassio import bootstrap
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -32,26 +31,25 @@ if __name__ == "__main__":
     executor = ThreadPoolExecutor(thread_name_prefix="SyncWorker")
     loop.set_default_executor(executor)
 
-    _LOGGER.info("Initialize Hassio setup")
+    _LOGGER.info("Initialize Hass.io setup")
     coresys = bootstrap.initialize_coresys(loop)
-    hassio = core.HassIO(coresys)
 
     bootstrap.migrate_system_env(coresys)
 
     _LOGGER.info("Setup HassIO")
-    loop.run_until_complete(hassio.setup())
+    loop.run_until_complete(coresys.core.setup())
 
-    loop.call_soon_threadsafe(loop.create_task, hassio.start())
+    loop.call_soon_threadsafe(loop.create_task, coresys.core.start())
     loop.call_soon_threadsafe(bootstrap.reg_signal, loop)
 
     try:
-        _LOGGER.info("Run HassIO")
+        _LOGGER.info("Run Hass.io")
         loop.run_forever()
     finally:
-        _LOGGER.info("Stopping HassIO")
-        loop.run_until_complete(hassio.stop())
+        _LOGGER.info("Stopping Hass.io")
+        loop.run_until_complete(coresys.core.stop())
         executor.shutdown(wait=False)
         loop.close()
 
-    _LOGGER.info("Close Hassio")
+    _LOGGER.info("Close Hass.io")
     sys.exit(0)

hassio/addons/__init__.py

@@ -1,11 +1,11 @@
-"""Init file for HassIO addons."""
+"""Init file for Hass.io add-ons."""
 import asyncio
 import logging
 
 from .addon import Addon
 from .repository import Repository
 from .data import AddonsData
-from ..const import REPOSITORY_CORE, REPOSITORY_LOCAL, BOOT_AUTO
+from ..const import REPOSITORY_CORE, REPOSITORY_LOCAL, BOOT_AUTO, STATE_STARTED
 from ..coresys import CoreSysAttributes
 
 _LOGGER = logging.getLogger(__name__)
@@ -14,10 +14,10 @@ BUILTIN_REPOSITORIES = set((REPOSITORY_CORE, REPOSITORY_LOCAL))
 
 
 class AddonManager(CoreSysAttributes):
-    """Manage addons inside HassIO."""
+    """Manage add-ons inside Hass.io."""
 
     def __init__(self, coresys):
-        """Initialize docker base wrapper."""
+        """Initialize Docker base wrapper."""
         self.coresys = coresys
         self.data = AddonsData(coresys)
         self.addons_obj = {}
@@ -25,48 +25,48 @@ class AddonManager(CoreSysAttributes):
 
     @property
     def list_addons(self):
-        """Return a list of all addons."""
+        """Return a list of all add-ons."""
         return list(self.addons_obj.values())
 
     @property
     def list_installed(self):
-        """Return a list of installed addons."""
+        """Return a list of installed add-ons."""
         return [addon for addon in self.addons_obj.values()
                 if addon.is_installed]
 
     @property
     def list_repositories(self):
-        """Return list of addon repositories."""
+        """Return list of add-on repositories."""
         return list(self.repositories_obj.values())
 
     def get(self, addon_slug):
-        """Return a add-on from slug."""
+        """Return an add-on from slug."""
         return self.addons_obj.get(addon_slug)
 
-    def from_uuid(self, uuid):
-        """Return a add-on from uuid."""
+    def from_token(self, token):
+        """Return an add-on from Hass.io token."""
         for addon in self.list_addons:
-            if addon.is_installed and uuid == addon.uuid:
+            if addon.is_installed and token == addon.hassio_token:
                 return addon
         return None
 
     async def load(self):
-        """Startup addon management."""
+        """Start up add-on management."""
         self.data.reload()
 
-        # init hassio built-in repositories
+        # Init Hass.io built-in repositories
         repositories = \
-            set(self._config.addons_repositories) | BUILTIN_REPOSITORIES
+            set(self.sys_config.addons_repositories) | BUILTIN_REPOSITORIES
 
-        # init custom repositories & load addons
+        # Init custom repositories and load add-ons
         await self.load_repositories(repositories)
 
     async def reload(self):
-        """Update addons from repo and reload list."""
+        """Update add-ons from repository and reload list."""
         tasks = [repository.update() for repository in
                  self.repositories_obj.values()]
         if tasks:
-            await asyncio.wait(tasks, loop=self._loop)
+            await asyncio.wait(tasks)
 
         # read data from repositories
         self.data.reload()
@@ -90,30 +90,30 @@ class AddonManager(CoreSysAttributes):
 
             # don't add built-in repository to config
             if url not in BUILTIN_REPOSITORIES:
-                self._config.add_addon_repository(url)
+                self.sys_config.add_addon_repository(url)
 
         tasks = [_add_repository(url) for url in new_rep - old_rep]
         if tasks:
-            await asyncio.wait(tasks, loop=self._loop)
+            await asyncio.wait(tasks)
 
         # del new repository
         for url in old_rep - new_rep - BUILTIN_REPOSITORIES:
             self.repositories_obj.pop(url).remove()
-            self._config.drop_addon_repository(url)
+            self.sys_config.drop_addon_repository(url)
 
         # update data
         self.data.reload()
         await self.load_addons()
 
     async def load_addons(self):
-        """Update/add internal addon store."""
+        """Update/add internal add-on store."""
         all_addons = set(self.data.system) | set(self.data.cache)
 
         # calc diff
         add_addons = all_addons - set(self.addons_obj)
         del_addons = set(self.addons_obj) - all_addons
 
-        _LOGGER.info("Load addons: %d all - %d new - %d remove",
+        _LOGGER.info("Load add-ons: %d all - %d new - %d remove",
                      len(all_addons), len(add_addons), len(del_addons))
 
         # new addons
@@ -125,21 +125,34 @@ class AddonManager(CoreSysAttributes):
             self.addons_obj[addon_slug] = addon
 
         if tasks:
-            await asyncio.wait(tasks, loop=self._loop)
+            await asyncio.wait(tasks)
 
         # remove
         for addon_slug in del_addons:
             self.addons_obj.pop(addon_slug)
 
-    async def auto_boot(self, stage):
-        """Boot addons with mode auto."""
+    async def boot(self, stage):
+        """Boot add-ons with mode auto."""
         tasks = []
         for addon in self.addons_obj.values():
             if addon.is_installed and addon.boot == BOOT_AUTO and \
                     addon.startup == stage:
                 tasks.append(addon.start())
 
-        _LOGGER.info("Startup %s run %d addons", stage, len(tasks))
+        _LOGGER.info("Startup %s run %d add-ons", stage, len(tasks))
         if tasks:
-            await asyncio.wait(tasks, loop=self._loop)
-            await asyncio.sleep(self._config.wait_boot, loop=self._loop)
+            await asyncio.wait(tasks)
+            await asyncio.sleep(self.sys_config.wait_boot)
+
+    async def shutdown(self, stage):
+        """Shutdown addons."""
+        tasks = []
+        for addon in self.addons_obj.values():
+            if addon.is_installed and \
+                    await addon.state() == STATE_STARTED and \
+                    addon.startup == stage:
+                tasks.append(addon.stop())
+
+        _LOGGER.info("Shutdown %s stop %d add-ons", stage, len(tasks))
+        if tasks:
+            await asyncio.wait(tasks)

hassio/addons/addon.py

@@ -1,4 +1,5 @@
-"""Init file for HassIO addons."""
+"""Init file for Hass.io add-ons."""
+from contextlib import suppress
 from copy import deepcopy
 import logging
 import json
@@ -12,8 +13,9 @@ import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
 from .validate import (
-    validate_options, SCHEMA_ADDON_SNAPSHOT, RE_VOLUME, RE_SERVICE)
-from .utils import check_installed
+    validate_options, SCHEMA_ADDON_SNAPSHOT, RE_VOLUME, RE_SERVICE,
+    MACHINE_ALL)
+from .utils import check_installed, remove_data
 from ..const import (
     ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON, ATTR_BOOT, ATTR_MAP,
     ATTR_OPTIONS, ATTR_PORTS, ATTR_SCHEMA, ATTR_IMAGE, ATTR_REPOSITORY,
@@ -23,10 +25,17 @@ from ..const import (
     ATTR_STATE, ATTR_TIMEOUT, ATTR_AUTO_UPDATE, ATTR_NETWORK, ATTR_WEBUI,
     ATTR_HASSIO_API, ATTR_AUDIO, ATTR_AUDIO_OUTPUT, ATTR_AUDIO_INPUT,
     ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY, ATTR_HOST_IPC,
-    ATTR_HOST_DBUS, ATTR_AUTO_UART, ATTR_DISCOVERY, ATTR_SERVICES)
+    ATTR_HOST_DBUS, ATTR_AUTO_UART, ATTR_DISCOVERY, ATTR_SERVICES,
+    ATTR_APPARMOR, ATTR_DEVICETREE, ATTR_DOCKER_API, ATTR_FULL_ACCESS,
+    ATTR_PROTECTED, ATTR_ACCESS_TOKEN, ATTR_HOST_PID, ATTR_HASSIO_ROLE,
+    ATTR_MACHINE,
+    SECURITY_PROFILE, SECURITY_DISABLE, SECURITY_DEFAULT)
 from ..coresys import CoreSysAttributes
 from ..docker.addon import DockerAddon
+from ..utils import create_token
 from ..utils.json import write_json_file, read_json_file
+from ..utils.apparmor import adjust_profile
+from ..exceptions import HostAppArmorError
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,7 +45,7 @@ RE_WEBUI = re.compile(
 
 
 class Addon(CoreSysAttributes):
-    """Hold data for addon inside HassIO."""
+    """Hold data for add-on inside Hass.io."""
 
     def __init__(self, coresys, slug):
         """Initialize data holder."""
@@ -52,29 +61,38 @@ class Addon(CoreSysAttributes):
 
     @property
     def slug(self):
-        """Return slug/id of addon."""
+        """Return slug/id of add-on."""
         return self._id
 
     @property
     def _mesh(self):
-        """Return addon data from system or cache."""
+        """Return add-on data from system or cache."""
         return self._data.system.get(self._id, self._data.cache.get(self._id))
 
     @property
     def _data(self):
-        """Return addons data storage."""
-        return self._addons.data
+        """Return add-ons data storage."""
+        return self.sys_addons.data
 
     @property
     def is_installed(self):
-        """Return True if a addon is installed."""
+        """Return True if an add-on is installed."""
         return self._id in self._data.system
 
     @property
     def is_detached(self):
-        """Return True if addon is detached."""
+        """Return True if add-on is detached."""
         return self._id not in self._data.cache
 
+    @property
+    def available(self):
+        """Return True if this add-on is available on this platform."""
+        if self.sys_arch not in self.supported_arch:
+            return False
+        if self.sys_machine not in self.supported_machine:
+            return False
+        return True
+
     @property
     def version_installed(self):
         """Return installed version."""
@@ -90,19 +108,19 @@ class Addon(CoreSysAttributes):
         self._data.save_data()
 
     def _set_uninstall(self):
-        """Set addon as uninstalled."""
+        """Set add-on as uninstalled."""
         self._data.system.pop(self._id, None)
         self._data.user.pop(self._id, None)
         self._data.save_data()
 
     def _set_update(self, version):
-        """Update version of addon."""
+        """Update version of add-on."""
         self._data.system[self._id] = deepcopy(self._data.cache[self._id])
         self._data.user[self._id][ATTR_VERSION] = version
         self._data.save_data()
 
     def _restore_data(self, user, system):
-        """Restore data to addon."""
+        """Restore data to add-on."""
         self._data.user[self._id] = deepcopy(user)
         self._data.system[self._id] = deepcopy(system)
         self._data.save_data()
@@ -119,7 +137,7 @@ class Addon(CoreSysAttributes):
 
     @options.setter
     def options(self, value):
-        """Store user addon options."""
+        """Store user add-on options."""
         if value is None:
             self._data.user[self._id][ATTR_OPTIONS] = {}
         else:
@@ -151,7 +169,7 @@ class Addon(CoreSysAttributes):
 
     @property
     def name(self):
-        """Return name of addon."""
+        """Return name of add-on."""
         return self._mesh[ATTR_NAME]
 
     @property
@@ -161,14 +179,21 @@ class Addon(CoreSysAttributes):
 
     @property
     def uuid(self):
-        """Return a API token for this add-on."""
+        """Return an API token for this add-on."""
         if self.is_installed:
             return self._data.user[self._id][ATTR_UUID]
         return None
 
+    @property
+    def hassio_token(self):
+        """Return access token for Hass.io API."""
+        if self.is_installed:
+            return self._data.user[self._id].get(ATTR_ACCESS_TOKEN)
+        return None
+
     @property
     def description(self):
-        """Return description of addon."""
+        """Return description of add-on."""
         return self._mesh[ATTR_DESCRIPTON]
 
     @property
@@ -186,44 +211,55 @@ class Addon(CoreSysAttributes):
 
     @property
     def repository(self):
-        """Return repository of addon."""
+        """Return repository of add-on."""
         return self._mesh[ATTR_REPOSITORY]
 
     @property
     def last_version(self):
-        """Return version of addon."""
+        """Return version of add-on."""
         if self._id in self._data.cache:
             return self._data.cache[self._id][ATTR_VERSION]
         return self.version_installed
 
+    @property
+    def protected(self):
+        """Return if add-on is in protected mode."""
+        if self.is_installed:
+            return self._data.user[self._id][ATTR_PROTECTED]
+        return True
+
+    @protected.setter
+    def protected(self, value):
+        """Set add-on in protected mode."""
+        self._data.user[self._id][ATTR_PROTECTED] = value
+
     @property
     def startup(self):
-        """Return startup type of addon."""
+        """Return startup type of add-on."""
         return self._mesh.get(ATTR_STARTUP)
 
     @property
-    def services(self):
+    def services_role(self):
         """Return dict of services with rights."""
         raw_services = self._mesh.get(ATTR_SERVICES)
         if not raw_services:
-            return None
+            return {}
 
-        formated_services = {}
+        services = {}
         for data in raw_services:
             service = RE_SERVICE.match(data)
-            formated_services[service.group('service')] = \
-                service.group('rights') or 'ro'
+            services[service.group('service')] = service.group('rights')
 
-        return formated_services
+        return services
 
     @property
     def discovery(self):
         """Return list of discoverable components/platforms."""
-        return self._mesh.get(ATTR_DISCOVERY)
+        return self._mesh.get(ATTR_DISCOVERY, [])
 
     @property
     def ports(self):
-        """Return ports of addon."""
+        """Return ports of add-on."""
         if self.host_network or ATTR_PORTS not in self._mesh:
             return None
 
@@ -234,7 +270,7 @@ class Addon(CoreSysAttributes):
 
     @ports.setter
     def ports(self, value):
-        """Set custom ports of addon."""
+        """Set custom ports of add-on."""
         if value is None:
             self._data.user[self._id].pop(ATTR_NETWORK, None)
         else:
@@ -278,59 +314,83 @@ class Addon(CoreSysAttributes):
 
     @property
     def host_network(self):
-        """Return True if addon run on host network."""
+        """Return True if add-on run on host network."""
         return self._mesh[ATTR_HOST_NETWORK]
 
+    @property
+    def host_pid(self):
+        """Return True if add-on run on host PID namespace."""
+        return self._mesh[ATTR_HOST_PID]
+
     @property
     def host_ipc(self):
-        """Return True if addon run on host IPC namespace."""
+        """Return True if add-on run on host IPC namespace."""
         return self._mesh[ATTR_HOST_IPC]
 
     @property
     def host_dbus(self):
-        """Return True if addon run on host DBUS."""
+        """Return True if add-on run on host D-BUS."""
         return self._mesh[ATTR_HOST_DBUS]
 
     @property
     def devices(self):
-        """Return devices of addon."""
+        """Return devices of add-on."""
         return self._mesh.get(ATTR_DEVICES)
 
     @property
     def auto_uart(self):
-        """Return True if we should map all uart device."""
+        """Return True if we should map all UART device."""
         return self._mesh.get(ATTR_AUTO_UART)
 
     @property
     def tmpfs(self):
-        """Return tmpfs of addon."""
+        """Return tmpfs of add-on."""
         return self._mesh.get(ATTR_TMPFS)
 
     @property
     def environment(self):
-        """Return environment of addon."""
+        """Return environment of add-on."""
         return self._mesh.get(ATTR_ENVIRONMENT)
 
     @property
     def privileged(self):
         """Return list of privilege."""
-        return self._mesh.get(ATTR_PRIVILEGED)
+        return self._mesh.get(ATTR_PRIVILEGED, [])
+
+    @property
+    def apparmor(self):
+        """Return True if AppArmor is enabled."""
+        if not self._mesh.get(ATTR_APPARMOR):
+            return SECURITY_DISABLE
+        elif self.sys_host.apparmor.exists(self.slug):
+            return SECURITY_PROFILE
+        return SECURITY_DEFAULT
 
     @property
     def legacy(self):
-        """Return if the add-on don't support hass labels."""
+        """Return if the add-on don't support Home Assistant labels."""
         return self._mesh.get(ATTR_LEGACY)
 
+    @property
+    def access_docker_api(self):
+        """Return if the add-on need read-only Docker API access."""
+        return self._mesh.get(ATTR_DOCKER_API)
+
     @property
     def access_hassio_api(self):
-        """Return True if the add-on access to hassio api."""
+        """Return True if the add-on access to Hass.io REASTful API."""
         return self._mesh[ATTR_HASSIO_API]
 
     @property
     def access_homeassistant_api(self):
-        """Return True if the add-on access to Home-Assistant api proxy."""
+        """Return True if the add-on access to Home Assistant API proxy."""
         return self._mesh[ATTR_HOMEASSISTANT_API]
 
+    @property
+    def hassio_role(self):
+        """Return Hass.io role for API."""
+        return self._mesh[ATTR_HASSIO_ROLE]
+
     @property
     def with_stdin(self):
         """Return True if the add-on access use stdin input."""
@@ -338,9 +398,19 @@ class Addon(CoreSysAttributes):
 
     @property
     def with_gpio(self):
-        """Return True if the add-on access to gpio interface."""
+        """Return True if the add-on access to GPIO interface."""
         return self._mesh[ATTR_GPIO]
 
+    @property
+    def with_full_access(self):
+        """Return True if the add-on want full access to hardware."""
+        return self._mesh[ATTR_FULL_ACCESS]
+
+    @property
+    def with_devicetree(self):
+        """Return True if the add-on read access to devicetree."""
+        return self._mesh[ATTR_DEVICETREE]
+
     @property
     def with_audio(self):
         """Return True if the add-on access to audio."""
@@ -352,15 +422,14 @@ class Addon(CoreSysAttributes):
         if not self.with_audio:
             return None
 
-        setting = self._config.audio_output
         if self.is_installed and \
                 ATTR_AUDIO_OUTPUT in self._data.user[self._id]:
-            setting = self._data.user[self._id][ATTR_AUDIO_OUTPUT]
-        return setting
+            return self._data.user[self._id][ATTR_AUDIO_OUTPUT]
+        return self.sys_host.alsa.default.output
 
     @audio_output.setter
     def audio_output(self, value):
-        """Set/remove custom audio output settings."""
+        """Set/reset audio output settings."""
         if value is None:
             self._data.user[self._id].pop(ATTR_AUDIO_OUTPUT, None)
         else:
@@ -372,14 +441,13 @@ class Addon(CoreSysAttributes):
         if not self.with_audio:
             return None
 
-        setting = self._config.audio_input
         if self.is_installed and ATTR_AUDIO_INPUT in self._data.user[self._id]:
-            setting = self._data.user[self._id][ATTR_AUDIO_INPUT]
-        return setting
+            return self._data.user[self._id][ATTR_AUDIO_INPUT]
+        return self.sys_host.alsa.default.input
 
     @audio_input.setter
     def audio_input(self, value):
-        """Set/remove custom audio input settings."""
+        """Set/reset audio input settings."""
         if value is None:
             self._data.user[self._id].pop(ATTR_AUDIO_INPUT, None)
         else:
@@ -387,12 +455,12 @@ class Addon(CoreSysAttributes):
 
     @property
     def url(self):
-        """Return url of addon."""
+        """Return URL of add-on."""
         return self._mesh.get(ATTR_URL)
 
     @property
     def with_icon(self):
-        """Return True if a icon exists."""
+        """Return True if an icon exists."""
         return self.path_icon.exists()
 
     @property
@@ -410,28 +478,33 @@ class Addon(CoreSysAttributes):
         """Return list of supported arch."""
         return self._mesh[ATTR_ARCH]
 
+    @property
+    def supported_machine(self):
+        """Return list of supported machine."""
+        return self._mesh.get(ATTR_MACHINE) or MACHINE_ALL
+
     @property
     def image(self):
-        """Return image name of addon."""
+        """Return image name of add-on."""
         addon_data = self._mesh
 
-        # Repository with dockerhub images
+        # Repository with Dockerhub images
         if ATTR_IMAGE in addon_data:
-            return addon_data[ATTR_IMAGE].format(arch=self._arch)
+            return addon_data[ATTR_IMAGE].format(arch=self.sys_arch)
 
         # local build
         return "{}/{}-addon-{}".format(
-            addon_data[ATTR_REPOSITORY], self._arch,
+            addon_data[ATTR_REPOSITORY], self.sys_arch,
             addon_data[ATTR_SLUG])
 
     @property
     def need_build(self):
-        """Return True if this  addon need a local build."""
+        """Return True if this  add-on need a local build."""
         return ATTR_IMAGE not in self._mesh
 
     @property
     def map_volumes(self):
-        """Return a dict of {volume: policy} from addon."""
+        """Return a dict of {volume: policy} from add-on."""
         volumes = {}
         for volume in self._mesh[ATTR_MAP]:
             result = RE_VOLUME.match(volume)
@@ -441,45 +514,60 @@ class Addon(CoreSysAttributes):
 
     @property
     def path_data(self):
-        """Return addon data path inside supervisor."""
-        return Path(self._config.path_addons_data, self._id)
+        """Return add-on data path inside Supervisor."""
+        return Path(self.sys_config.path_addons_data, self._id)
 
     @property
     def path_extern_data(self):
-        """Return addon data path external for docker."""
-        return PurePath(self._config.path_extern_addons_data, self._id)
+        """Return add-on data path external for Docker."""
+        return PurePath(self.sys_config.path_extern_addons_data, self._id)
 
     @property
     def path_options(self):
-        """Return path to addons options."""
+        """Return path to add-on options."""
         return Path(self.path_data, "options.json")
 
     @property
     def path_location(self):
-        """Return path to this addon."""
+        """Return path to this add-on."""
         return Path(self._mesh[ATTR_LOCATON])
 
     @property
     def path_icon(self):
-        """Return path to addon icon."""
+        """Return path to add-on icon."""
         return Path(self.path_location, 'icon.png')
 
     @property
     def path_logo(self):
-        """Return path to addon logo."""
+        """Return path to add-on logo."""
         return Path(self.path_location, 'logo.png')
 
     @property
     def path_changelog(self):
-        """Return path to addon changelog."""
+        """Return path to add-on changelog."""
         return Path(self.path_location, 'CHANGELOG.md')
 
+    @property
+    def path_apparmor(self):
+        """Return path to custom AppArmor profile."""
+        return Path(self.path_location, 'apparmor.txt')
+
+    @property
+    def path_asound(self):
+        """Return path to asound config."""
+        return Path(self.sys_config.path_tmp, f"{self.slug}_asound")
+
+    @property
+    def path_extern_asound(self):
+        """Return path to asound config for Docker."""
+        return Path(self.sys_config.path_extern_tmp, f"{self.slug}_asound")
+
     def save_data(self):
-        """Save data of addon."""
-        self._addons.data.save_data()
+        """Save data of add-on."""
+        self.sys_addons.data.save_data()
 
     def write_options(self):
-        """Return True if addon options is written to data."""
+        """Return True if add-on options is written to data."""
         schema = self.schema
         options = self.options
 
@@ -487,26 +575,68 @@ class Addon(CoreSysAttributes):
             schema(options)
             write_json_file(self.path_options, options)
         except vol.Invalid as ex:
-            _LOGGER.error("Addon %s have wrong options: %s", self._id,
+            _LOGGER.error("Add-on %s have wrong options: %s", self._id,
                           humanize_error(options, ex))
         except (OSError, json.JSONDecodeError) as err:
-            _LOGGER.error("Addon %s can't write options: %s", self._id, err)
+            _LOGGER.error("Add-on %s can't write options: %s", self._id, err)
         else:
             return True
 
         return False
 
+    def remove_discovery(self):
+        """Remove all discovery message from add-on."""
+        for message in self.sys_discovery.list_messages:
+            if message.addon != self.slug:
+                continue
+            self.sys_discovery.remove(message)
+
+    def write_asound(self):
+        """Write asound config to file and return True on success."""
+        asound_config = self.sys_host.alsa.asound(
+            alsa_input=self.audio_input, alsa_output=self.audio_output)
+
+        try:
+            with self.path_asound.open('w') as config_file:
+                config_file.write(asound_config)
+        except OSError as err:
+            _LOGGER.error("Add-on %s can't write asound: %s", self._id, err)
+            return False
+
+        return True
+
+    async def _install_apparmor(self):
+        """Install or Update AppArmor profile for Add-on."""
+        exists_local = self.sys_host.apparmor.exists(self.slug)
+        exists_addon = self.path_apparmor.exists()
+
+        # Nothing to do
+        if not exists_local and not exists_addon:
+            return
+
+        # Need removed
+        if exists_local and not exists_addon:
+            await self.sys_host.apparmor.remove_profile(self.slug)
+            return
+
+        # Need install/update
+        with TemporaryDirectory(dir=self.sys_config.path_tmp) as tmp_folder:
+            profile_file = Path(tmp_folder, 'apparmor.txt')
+
+            adjust_profile(self.slug, self.path_apparmor, profile_file)
+            await self.sys_host.apparmor.load_profile(self.slug, profile_file)
+
     @property
     def schema(self):
-        """Create a schema for addon options."""
+        """Create a schema for add-on options."""
         raw_schema = self._mesh[ATTR_SCHEMA]
 
         if isinstance(raw_schema, bool):
             return vol.Schema(dict)
         return vol.Schema(vol.All(dict, validate_options(raw_schema)))
 
-    def test_udpate_schema(self):
-        """Check if the exists config valid after update."""
+    def test_update_schema(self):
+        """Check if the existing configuration is valid after update."""
         if not self.is_installed or self.is_detached:
             return True
 
@@ -536,21 +666,24 @@ class Addon(CoreSysAttributes):
         return True
 
     async def install(self):
-        """Install a addon."""
-        if self._arch not in self.supported_arch:
+        """Install an add-on."""
+        if not self.available:
             _LOGGER.error(
-                "Addon %s not supported on %s", self._id, self._arch)
+                "Add-on %s not supported on %s", self._id, self.sys_arch)
             return False
 
         if self.is_installed:
-            _LOGGER.error("Addon %s is already installed", self._id)
+            _LOGGER.error("Add-on %s is already installed", self._id)
             return False
 
         if not self.path_data.is_dir():
             _LOGGER.info(
-                "Create Home-Assistant addon data folder %s", self.path_data)
+                "Create Home Assistant add-on data folder %s", self.path_data)
             self.path_data.mkdir()
 
+        # Setup/Fix AppArmor profile
+        await self._install_apparmor()
+
         if not await self.instance.install(self.last_version):
             return False
 
@@ -559,20 +692,33 @@ class Addon(CoreSysAttributes):
 
     @check_installed
     async def uninstall(self):
-        """Remove a addon."""
+        """Remove an add-on."""
         if not await self.instance.remove():
             return False
 
         if self.path_data.is_dir():
             _LOGGER.info(
-                "Remove Home-Assistant addon data folder %s", self.path_data)
-            shutil.rmtree(str(self.path_data))
+                "Remove Home Assistant add-on data folder %s", self.path_data)
+            await remove_data(self.path_data)
+
+        # Cleanup audio settings
+        if self.path_asound.exists():
+            with suppress(OSError):
+                self.path_asound.unlink()
+
+        # Cleanup AppArmor profile
+        if self.sys_host.apparmor.exists(self.slug):
+            with suppress(HostAppArmorError):
+                await self.sys_host.apparmor.remove_profile(self.slug)
+
+        # Remove discovery messages
+        self.remove_discovery()
 
         self._set_uninstall()
         return True
 
     async def state(self):
-        """Return running state of addon."""
+        """Return running state of add-on."""
         if not self.is_installed:
             return STATE_NONE
 
@@ -582,15 +728,28 @@ class Addon(CoreSysAttributes):
 
     @check_installed
     async def start(self):
-        """Set options and start addon."""
+        """Set options and start add-on."""
+        if await self.instance.is_running():
+            _LOGGER.warning("%s already running!", self.slug)
+            return
+
+        # Access Token
+        self._data.user[self._id][ATTR_ACCESS_TOKEN] = create_token()
+        self._data.save_data()
+
+        # Options
         if not self.write_options():
             return False
 
+        # Sound
+        if self.with_audio and not self.write_asound():
+            return False
+
         return await self.instance.run()
 
     @check_installed
     def stop(self):
-        """Stop addon.
+        """Stop add-on.
 
         Return a coroutine.
         """
@@ -598,17 +757,20 @@ class Addon(CoreSysAttributes):
 
     @check_installed
     async def update(self):
-        """Update addon."""
+        """Update add-on."""
         last_state = await self.state()
 
         if self.last_version == self.version_installed:
-            _LOGGER.warning("No update available for Addon %s", self._id)
+            _LOGGER.warning("No update available for add-on %s", self._id)
             return False
 
         if not await self.instance.update(self.last_version):
             return False
         self._set_update(self.last_version)
 
+        # Setup/Fix AppArmor profile
+        await self._install_apparmor()
+
         # restore state
         if last_state == STATE_STARTED:
             await self.start()
@@ -616,13 +778,13 @@ class Addon(CoreSysAttributes):
 
     @check_installed
     async def restart(self):
-        """Restart addon."""
+        """Restart add-on."""
         await self.stop()
         return await self.start()
 
     @check_installed
     def logs(self):
-        """Return addons log output.
+        """Return add-ons log output.
 
         Return a coroutine.
         """
@@ -638,11 +800,11 @@ class Addon(CoreSysAttributes):
 
     @check_installed
     async def rebuild(self):
-        """Performe a rebuild of local build addon."""
+        """Perform a rebuild of local build add-on."""
         last_state = await self.state()
 
         if not self.need_build:
-            _LOGGER.error("Can't rebuild a none local build addon!")
+            _LOGGER.error("Can't rebuild a none local build add-on!")
             return False
 
         # remove docker container but not addon config
@@ -671,11 +833,11 @@ class Addon(CoreSysAttributes):
 
     @check_installed
     async def snapshot(self, tar_file):
-        """Snapshot a state of a addon."""
-        with TemporaryDirectory(dir=str(self._config.path_tmp)) as temp:
+        """Snapshot state of an add-on."""
+        with TemporaryDirectory(dir=str(self.sys_config.path_tmp)) as temp:
             # store local image
             if self.need_build and not await \
-                    self.instance.export_image(Path(temp, "image.tar")):
+                    self.instance.export_image(Path(temp, 'image.tar')):
                 return False
 
             data = {
@@ -685,13 +847,22 @@ class Addon(CoreSysAttributes):
                 ATTR_STATE: await self.state(),
             }
 
-            # store local configs/state
+            # Store local configs/state
             try:
-                write_json_file(Path(temp, "addon.json"), data)
+                write_json_file(Path(temp, 'addon.json'), data)
             except (OSError, json.JSONDecodeError) as err:
                 _LOGGER.error("Can't save meta for %s: %s", self._id, err)
                 return False
 
+            # Store AppArmor Profile
+            if self.sys_host.apparmor.exists(self.slug):
+                profile = Path(temp, 'apparmor.txt')
+                try:
+                    self.sys_host.apparmor.backup_profile(self.slug, profile)
+                except HostAppArmorError:
+                    _LOGGER.error("Can't backup AppArmor profile")
+                    return False
+
             # write into tarfile
             def _write_tarfile():
                 """Write tar inside loop."""
@@ -700,8 +871,8 @@ class Addon(CoreSysAttributes):
                     snapshot.add(self.path_data, arcname="data")
 
             try:
-                _LOGGER.info("Build snapshot for addon %s", self._id)
-                await self._loop.run_in_executor(None, _write_tarfile)
+                _LOGGER.info("Build snapshot for add-on %s", self._id)
+                await self.sys_run_in_executor(_write_tarfile)
             except (tarfile.TarError, OSError) as err:
                 _LOGGER.error("Can't write tarfile %s: %s", tar_file, err)
                 return False
@@ -710,8 +881,8 @@ class Addon(CoreSysAttributes):
         return True
 
     async def restore(self, tar_file):
-        """Restore a state of a addon."""
-        with TemporaryDirectory(dir=str(self._config.path_tmp)) as temp:
+        """Restore state of an add-on."""
+        with TemporaryDirectory(dir=str(self.sys_config.path_tmp)) as temp:
             # extract snapshot
             def _extract_tarfile():
                 """Extract tar snapshot."""
@@ -719,18 +890,18 @@ class Addon(CoreSysAttributes):
                     snapshot.extractall(path=Path(temp))
 
             try:
-                await self._loop.run_in_executor(None, _extract_tarfile)
+                await self.sys_run_in_executor(_extract_tarfile)
             except tarfile.TarError as err:
                 _LOGGER.error("Can't read tarfile %s: %s", tar_file, err)
                 return False
 
-            # read snapshot data
+            # Read snapshot data
             try:
-                data = read_json_file(Path(temp, "addon.json"))
+                data = read_json_file(Path(temp, 'addon.json'))
             except (OSError, json.JSONDecodeError) as err:
                 _LOGGER.error("Can't read addon.json: %s", err)
 
-            # validate
+            # Validate
             try:
                 data = SCHEMA_ADDON_SNAPSHOT(data)
             except vol.Invalid as err:
@@ -738,16 +909,16 @@ class Addon(CoreSysAttributes):
                               self._id, humanize_error(data, err))
                 return False
 
-            # restore data / reload addon
+            # Restore data or reload add-on
             _LOGGER.info("Restore config for addon %s", self._id)
             self._restore_data(data[ATTR_USER], data[ATTR_SYSTEM])
 
-            # check version / restore image
+            # Check version / restore image
             version = data[ATTR_VERSION]
             if not await self.instance.exists():
                 _LOGGER.info("Restore image for addon %s", self._id)
 
-                image_file = Path(temp, "image.tar")
+                image_file = Path(temp, 'image.tar')
                 if image_file.is_file():
                     await self.instance.import_image(image_file, version)
                 else:
@@ -756,23 +927,33 @@ class Addon(CoreSysAttributes):
             else:
                 await self.instance.stop()
 
-            # restore data
+            # Restore data
             def _restore_data():
                 """Restore data."""
-                if self.path_data.is_dir():
-                    shutil.rmtree(str(self.path_data), ignore_errors=True)
                 shutil.copytree(str(Path(temp, "data")), str(self.path_data))
 
+            _LOGGER.info("Restore data for addon %s", self._id)
+            if self.path_data.is_dir():
+                await remove_data(self.path_data)
             try:
-                _LOGGER.info("Restore data for addon %s", self._id)
-                await self._loop.run_in_executor(None, _restore_data)
+                await self.sys_run_in_executor(_restore_data)
             except shutil.Error as err:
                 _LOGGER.error("Can't restore origin data: %s", err)
                 return False
 
-            # run addon
+            # Restore AppArmor
+            profile_file = Path(temp, 'apparmor.txt')
+            if profile_file.exists():
+                try:
+                    await self.sys_host.apparmor.load_profile(
+                        self.slug, profile_file)
+                except HostAppArmorError:
+                    _LOGGER.error("Can't restore AppArmor profile")
+                    return False
+
+            # Run add-on
             if data[ATTR_STATE] == STATE_STARTED:
                 return await self.start()
 
-        _LOGGER.info("Finish restore for addon %s", self._id)
+        _LOGGER.info("Finish restore for add-on %s", self._id)
         return True

hassio/addons/build.py

@@ -1,4 +1,4 @@
-"""HassIO addons build environment."""
+"""Hass.io add-on build environment."""
 from pathlib import Path
 
 from .validate import SCHEMA_BUILD_CONFIG, BASE_IMAGE
@@ -8,10 +8,10 @@ from ..utils.json import JsonConfig
 
 
 class AddonBuild(JsonConfig, CoreSysAttributes):
-    """Handle build options for addons."""
+    """Handle build options for add-ons."""
 
     def __init__(self, coresys, slug):
-        """Initialize addon builder."""
+        """Initialize Hass.io add-on builder."""
         self.coresys = coresys
         self._id = slug
 
@@ -24,14 +24,14 @@ class AddonBuild(JsonConfig, CoreSysAttributes):
 
     @property
     def addon(self):
-        """Return addon of build data."""
-        return self._addons.get(self._id)
+        """Return add-on of build data."""
+        return self.sys_addons.get(self._id)
 
     @property
     def base_image(self):
-        """Base images for this addon."""
+        """Base images for this add-on."""
         return self._data[ATTR_BUILD_FROM].get(
-            self._arch, BASE_IMAGE[self._arch])
+            self.sys_arch, BASE_IMAGE[self.sys_arch])
 
     @property
     def squash(self):
@@ -40,11 +40,11 @@ class AddonBuild(JsonConfig, CoreSysAttributes):
 
     @property
     def additional_args(self):
-        """Return additional docker build arguments."""
+        """Return additional Docker build arguments."""
         return self._data[ATTR_ARGS]
 
     def get_docker_args(self, version):
-        """Create a dict with docker build arguments."""
+        """Create a dict with Docker build arguments."""
         args = {
             'path': str(self.addon.path_location),
             'tag': f"{self.addon.image}:{version}",
@@ -53,15 +53,15 @@ class AddonBuild(JsonConfig, CoreSysAttributes):
             'squash': self.squash,
             'labels': {
                 'io.hass.version': version,
-                'io.hass.arch': self._arch,
+                'io.hass.arch': self.sys_arch,
                 'io.hass.type': META_ADDON,
-                'io.hass.name': self.addon.name,
-                'io.hass.description': self.addon.description,
+                'io.hass.name': self._fix_label('name'),
+                'io.hass.description': self._fix_label('description'),
             },
             'buildargs': {
                 'BUILD_FROM': self.base_image,
                 'BUILD_VERSION': version,
-                'BUILD_ARCH': self._arch,
+                'BUILD_ARCH': self.sys_arch,
                 **self.additional_args,
             }
         }
@@ -70,3 +70,8 @@ class AddonBuild(JsonConfig, CoreSysAttributes):
             args['labels']['io.hass.url'] = self.addon.url
 
         return args
+
+    def _fix_label(self, label_name):
+        """Remove characters they are not supported."""
+        label = getattr(self.addon, label_name, "")
+        return label.replace("'", "")

hassio/addons/built-in.json

@@ -1,12 +1,12 @@
 {
     "local": {
-        "name": "Local Add-Ons",
+        "name": "Local add-ons",
         "url": "https://home-assistant.io/hassio",
         "maintainer": "you"
     },
     "core": {
-        "name": "Built-in Add-Ons",
+        "name": "Official add-ons",
         "url": "https://home-assistant.io/addons",
-        "maintainer": "Home Assistant authors"
+        "maintainer": "Home Assistant"
     }
 }

hassio/addons/data.py

@@ -1,5 +1,4 @@
-"""Init file for HassIO addons."""
-import copy
+"""Init file for Hass.io add-on data."""
 import logging
 import json
 from pathlib import Path
@@ -11,7 +10,7 @@ from .utils import extract_hash_from_path
 from .validate import (
     SCHEMA_ADDON_CONFIG, SCHEMA_ADDONS_FILE, SCHEMA_REPOSITORY_CONFIG)
 from ..const import (
-    FILE_HASSIO_ADDONS, ATTR_VERSION, ATTR_SLUG, ATTR_REPOSITORY, ATTR_LOCATON,
+    FILE_HASSIO_ADDONS, ATTR_SLUG, ATTR_REPOSITORY, ATTR_LOCATON,
     REPOSITORY_CORE, REPOSITORY_LOCAL, ATTR_USER, ATTR_SYSTEM)
 from ..coresys import CoreSysAttributes
 from ..utils.json import JsonConfig, read_json_file
@@ -20,7 +19,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class AddonsData(JsonConfig, CoreSysAttributes):
-    """Hold data for addons inside HassIO."""
+    """Hold data for Add-ons inside Hass.io."""
 
     def __init__(self, coresys):
         """Initialize data holder."""
@@ -31,48 +30,45 @@ class AddonsData(JsonConfig, CoreSysAttributes):
 
     @property
     def user(self):
-        """Return local addon user data."""
+        """Return local add-on user data."""
         return self._data[ATTR_USER]
 
     @property
     def system(self):
-        """Return local addon data."""
+        """Return local add-on data."""
         return self._data[ATTR_SYSTEM]
 
     @property
     def cache(self):
-        """Return addon data from cache/repositories."""
+        """Return add-on data from cache/repositories."""
         return self._cache
 
     @property
     def repositories(self):
-        """Return addon data from repositories."""
+        """Return add-on data from repositories."""
         return self._repositories
 
     def reload(self):
-        """Read data from addons repository."""
+        """Read data from add-on repository."""
         self._cache = {}
         self._repositories = {}
 
         # read core repository
         self._read_addons_folder(
-            self._config.path_addons_core, REPOSITORY_CORE)
+            self.sys_config.path_addons_core, REPOSITORY_CORE)
 
         # read local repository
         self._read_addons_folder(
-            self._config.path_addons_local, REPOSITORY_LOCAL)
+            self.sys_config.path_addons_local, REPOSITORY_LOCAL)
 
         # add built-in repositories information
         self._set_builtin_repositories()
 
         # read custom git repositories
-        for repository_element in self._config.path_addons_git.iterdir():
+        for repository_element in self.sys_config.path_addons_git.iterdir():
             if repository_element.is_dir():
                 self._read_git_repository(repository_element)
 
-        # update local data
-        self._merge_config()
-
     def _read_git_repository(self, path):
         """Process a custom repository folder."""
         slug = extract_hash_from_path(path)
@@ -84,7 +80,7 @@ class AddonsData(JsonConfig, CoreSysAttributes):
                 read_json_file(repository_file)
             )
 
-        except (OSError, json.JSONDecodeError):
+        except (OSError, json.JSONDecodeError, UnicodeDecodeError):
             _LOGGER.warning("Can't read repository information from %s",
                             repository_file)
             return
@@ -98,7 +94,7 @@ class AddonsData(JsonConfig, CoreSysAttributes):
         self._read_addons_folder(path, slug)
 
     def _read_addons_folder(self, path, repository):
-        """Read data from addons folder."""
+        """Read data from add-ons folder."""
         for addon in path.glob("**/config.json"):
             try:
                 addon_config = read_json_file(addon)
@@ -138,25 +134,3 @@ class AddonsData(JsonConfig, CoreSysAttributes):
         # local repository
         self._repositories[REPOSITORY_LOCAL] = \
             builtin_data[REPOSITORY_LOCAL]
-
-    def _merge_config(self):
-        """Update local config if they have update.
-
-        It need to be the same version as the local version is for merge.
-        """
-        have_change = False
-
-        for addon in set(self.system):
-            # detached
-            if addon not in self._cache:
-                continue
-
-            cache = self._cache[addon]
-            data = self.system[addon]
-            if data[ATTR_VERSION] == cache[ATTR_VERSION]:
-                if data != cache:
-                    self.system[addon] = copy.deepcopy(cache)
-                    have_change = True
-
-        if have_change:
-            self.save_data()

hassio/addons/git.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO addons git."""
+"""Init file for Hass.io add-on Git."""
 import asyncio
 import logging
 import functools as ft
@@ -8,92 +8,141 @@ import shutil
 import git
 
 from .utils import get_hash_from_repository
-from ..const import URL_HASSIO_ADDONS
+from ..const import URL_HASSIO_ADDONS, ATTR_URL, ATTR_BRANCH
 from ..coresys import CoreSysAttributes
+from ..validate import RE_REPOSITORY
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class GitRepo(CoreSysAttributes):
-    """Manage addons git repo."""
+    """Manage Add-on Git repository."""
 
     def __init__(self, coresys, path, url):
-        """Initialize git base wrapper."""
+        """Initialize Git base wrapper."""
         self.coresys = coresys
         self.repo = None
         self.path = path
-        self.url = url
         self.lock = asyncio.Lock(loop=coresys.loop)
 
+        self._data = RE_REPOSITORY.match(url).groupdict()
+
+    @property
+    def url(self):
+        """Return repository URL."""
+        return self._data[ATTR_URL]
+
+    @property
+    def branch(self):
+        """Return repository branch."""
+        return self._data[ATTR_BRANCH]
+
     async def load(self):
-        """Init git addon repo."""
+        """Init Git add-on repository."""
         if not self.path.is_dir():
             return await self.clone()
 
         async with self.lock:
             try:
-                _LOGGER.info("Load addon %s repository", self.path)
-                self.repo = await self._loop.run_in_executor(
-                    None, git.Repo, str(self.path))
+                _LOGGER.info("Load add-on %s repository", self.path)
+                self.repo = await self.sys_run_in_executor(
+                    git.Repo, str(self.path))
 
             except (git.InvalidGitRepositoryError, git.NoSuchPathError,
                     git.GitCommandError) as err:
                 _LOGGER.error("Can't load %s repo: %s.", self.path, err)
+                self._remove()
                 return False
 
             return True
 
     async def clone(self):
-        """Clone git addon repo."""
+        """Clone git add-on repository."""
         async with self.lock:
+            git_args = {
+                attribute: value
+                for attribute, value in (
+                    ('recursive', True),
+                    ('branch', self.branch),
+                    ('depth', 1),
+                    ('shallow-submodules', True)
+                ) if value is not None
+            }
+
             try:
-                _LOGGER.info("Clone addon %s repository", self.url)
-                self.repo = await self._loop.run_in_executor(
-                    None, ft.partial(
-                        git.Repo.clone_from, self.url, str(self.path),
-                        recursive=True))
+                _LOGGER.info("Clone add-on %s repository", self.url)
+                self.repo = await self.sys_run_in_executor(ft.partial(
+                    git.Repo.clone_from, self.url, str(self.path),
+                    **git_args
+                ))
 
             except (git.InvalidGitRepositoryError, git.NoSuchPathError,
                     git.GitCommandError) as err:
-                _LOGGER.error("Can't clone %s repo: %s.", self.url, err)
+                _LOGGER.error("Can't clone %s repository: %s.", self.url, err)
+                self._remove()
                 return False
 
             return True
 
     async def pull(self):
-        """Pull git addon repo."""
+        """Pull Git add-on repo."""
         if self.lock.locked():
-            _LOGGER.warning("It is already a task in progress.")
+            _LOGGER.warning("It is already a task in progress")
             return False
 
         async with self.lock:
+            _LOGGER.info("Update add-on %s repository", self.url)
+            branch = self.repo.active_branch.name
+
             try:
-                _LOGGER.info("Pull addon %s repository", self.url)
-                await self._loop.run_in_executor(
-                    None, self.repo.remotes.origin.pull)
+                # Download data
+                await self.sys_run_in_executor(ft.partial(
+                    self.repo.remotes.origin.fetch, **{
+                        'update-shallow': True,
+                        'depth': 1,
+                    }))
+
+                # Jump on top of that
+                await self.sys_run_in_executor(ft.partial(
+                    self.repo.git.reset, f"origin/{branch}", hard=True))
+
+                # Cleanup old data
+                await self.sys_run_in_executor(ft.partial(
+                    self.repo.git.clean, "-xdf"))
 
             except (git.InvalidGitRepositoryError, git.NoSuchPathError,
                     git.GitCommandError) as err:
-                _LOGGER.error("Can't pull %s repo: %s.", self.url, err)
+                _LOGGER.error("Can't update %s repo: %s.", self.url, err)
                 return False
 
             return True
 
+    def _remove(self):
+        """Remove a repository."""
+        if not self.path.is_dir():
+            return
+
+        def log_err(funct, path, _):
+            """Log error."""
+            _LOGGER.warning("Can't remove %s", path)
+
+        shutil.rmtree(str(self.path), onerror=log_err)
+
 
 class GitRepoHassIO(GitRepo):
-    """HassIO addons repository."""
+    """Hass.io add-ons repository."""
 
     def __init__(self, coresys):
-        """Initialize git hassio addon repository."""
+        """Initialize Git Hass.io add-on repository."""
         super().__init__(
             coresys, coresys.config.path_addons_core, URL_HASSIO_ADDONS)
 
 
 class GitRepoCustom(GitRepo):
-    """Custom addons repository."""
+    """Custom add-ons repository."""
 
     def __init__(self, coresys, url):
-        """Initialize git hassio addon repository."""
+        """Initialize custom Git Hass.io addo-n repository."""
         path = Path(
             coresys.config.path_addons_git,
             get_hash_from_repository(url))
@@ -101,12 +150,6 @@ class GitRepoCustom(GitRepo):
         super().__init__(coresys, path, url)
 
     def remove(self):
-        """Remove a custom addon."""
-        if self.path.is_dir():
-            _LOGGER.info("Remove custom addon repository %s", self.url)
-
-            def log_err(funct, path, _):
-                """Log error."""
-                _LOGGER.warning("Can't remove %s", path)
-
-            shutil.rmtree(str(self.path), onerror=log_err)
+        """Remove a custom repository."""
+        _LOGGER.info("Remove custom add-on repository %s", self.url)
+        self._remove()

hassio/addons/repository.py

@@ -1,15 +1,16 @@
-"""Represent a HassIO repository."""
+"""Represent a Hass.io repository."""
 from .git import GitRepoHassIO, GitRepoCustom
 from .utils import get_hash_from_repository
 from ..const import (
     REPOSITORY_CORE, REPOSITORY_LOCAL, ATTR_NAME, ATTR_URL, ATTR_MAINTAINER)
 from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
 
 UNKNOWN = 'unknown'
 
 
 class Repository(CoreSysAttributes):
-    """Repository in HassIO."""
+    """Repository in Hass.io."""
 
     def __init__(self, coresys, repository):
         """Initialize repository object."""
@@ -30,7 +31,7 @@ class Repository(CoreSysAttributes):
     @property
     def _mesh(self):
         """Return data struct repository."""
-        return self._addons.data.repositories.get(self._id, {})
+        return self.sys_addons.data.repositories.get(self._id, {})
 
     @property
     def slug(self):
@@ -44,7 +45,7 @@ class Repository(CoreSysAttributes):
 
     @property
     def url(self):
-        """Return url of repository."""
+        """Return URL of repository."""
         return self._mesh.get(ATTR_URL, self.source)
 
     @property
@@ -59,14 +60,14 @@ class Repository(CoreSysAttributes):
         return True
 
     async def update(self):
-        """Update addon repository."""
+        """Update add-on repository."""
         if self.git:
             return await self.git.pull()
         return True
 
     def remove(self):
-        """Remove addon repository."""
+        """Remove add-on repository."""
         if self._id in (REPOSITORY_CORE, REPOSITORY_LOCAL):
-            raise RuntimeError("Can't remove built-in repositories!")
+            raise APIError("Can't remove built-in repositories!")
 
         self.git.remove()

hassio/addons/utils.py

@@ -1,13 +1,65 @@
-"""Util addons functions."""
+"""Util add-ons functions."""
+import asyncio
 import hashlib
 import logging
 import re
 
+from ..const import (
+    SECURITY_DISABLE, SECURITY_PROFILE, PRIVILEGED_NET_ADMIN,
+    PRIVILEGED_SYS_ADMIN, PRIVILEGED_SYS_RAWIO, PRIVILEGED_SYS_PTRACE,
+    PRIVILEGED_DAC_READ_SEARCH, ROLE_ADMIN, ROLE_MANAGER)
+
 RE_SHA1 = re.compile(r"[a-f0-9]{8}")
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def rating_security(addon):
+    """Return 1-5 for security rating.
+
+    1 = not secure
+    5 = high secure
+    """
+    rating = 5
+
+    # AppArmor
+    if addon.apparmor == SECURITY_DISABLE:
+        rating += -1
+    elif addon.apparmor == SECURITY_PROFILE:
+        rating += 1
+
+    # Privileged options
+    if any(privilege in addon.privileged
+           for privilege in (PRIVILEGED_NET_ADMIN, PRIVILEGED_SYS_ADMIN,
+                             PRIVILEGED_SYS_RAWIO, PRIVILEGED_SYS_PTRACE,
+                             PRIVILEGED_DAC_READ_SEARCH)):
+        rating += -1
+
+    # API Hass.io role
+    if addon.hassio_role == ROLE_MANAGER:
+        rating += -1
+    elif addon.hassio_role == ROLE_ADMIN:
+        rating += -2
+
+    # Not secure Networking
+    if addon.host_network:
+        rating += -1
+
+    # Insecure PID namespace
+    if addon.host_pid:
+        rating += -2
+
+    # Full Access
+    if addon.with_full_access:
+        rating += -2
+
+    # Docker Access
+    if addon.access_docker_api:
+        rating = 1
+
+    return max(min(6, rating), 1)
+
+
 def get_hash_from_repository(name):
     """Generate a hash from repository."""
     key = name.lower().encode()
@@ -24,7 +76,7 @@ def extract_hash_from_path(path):
 
 
 def check_installed(method):
-    """Wrap function with check if addon is installed."""
+    """Wrap function with check if add-on is installed."""
     async def wrap_check(addon, *args, **kwargs):
         """Return False if not installed or the function."""
         if not addon.is_installed:
@@ -33,3 +85,20 @@ def check_installed(method):
         return await method(addon, *args, **kwargs)
 
     return wrap_check
+
+
+async def remove_data(folder):
+    """Remove folder and reset privileged."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "rm", "-rf", str(folder),
+            stdout=asyncio.subprocess.DEVNULL
+        )
+
+        _, error_msg = await proc.communicate()
+    except OSError as err:
+        error_msg = str(err)
+
+    if proc.returncode == 0:
+        return
+    _LOGGER.error("Can't remove Add-on Data: %s", error_msg)

hassio/addons/validate.py

@@ -1,4 +1,4 @@
-"""Validate addons options schema."""
+"""Validate add-ons options schema."""
 import logging
 import re
 import uuid
@@ -17,15 +17,22 @@ from ..const import (
     ATTR_AUTO_UPDATE, ATTR_WEBUI, ATTR_AUDIO, ATTR_AUDIO_INPUT, ATTR_HOST_IPC,
     ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API, ATTR_BUILD_FROM, ATTR_SQUASH,
     ATTR_ARGS, ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY,
-    ATTR_HOST_DBUS, ATTR_AUTO_UART, ATTR_SERVICES, ATTR_DISCOVERY)
-from ..validate import NETWORK_PORT, DOCKER_PORTS, ALSA_CHANNEL
+    ATTR_HOST_DBUS, ATTR_AUTO_UART, ATTR_SERVICES, ATTR_DISCOVERY,
+    ATTR_APPARMOR, ATTR_DEVICETREE, ATTR_DOCKER_API, ATTR_PROTECTED,
+    ATTR_FULL_ACCESS, ATTR_ACCESS_TOKEN, ATTR_HOST_PID, ATTR_HASSIO_ROLE,
+    ATTR_MACHINE,
+    PRIVILEGED_NET_ADMIN, PRIVILEGED_SYS_ADMIN, PRIVILEGED_SYS_RAWIO,
+    PRIVILEGED_IPC_LOCK, PRIVILEGED_SYS_TIME, PRIVILEGED_SYS_NICE,
+    PRIVILEGED_SYS_RESOURCE, PRIVILEGED_SYS_PTRACE, PRIVILEGED_DAC_READ_SEARCH,
+    ROLE_DEFAULT, ROLE_HOMEASSISTANT, ROLE_MANAGER, ROLE_ADMIN)
+from ..validate import NETWORK_PORT, DOCKER_PORTS, ALSA_DEVICE, UUID_MATCH
+from ..services.validate import DISCOVERY_SERVICES
 
 _LOGGER = logging.getLogger(__name__)
 
 
 RE_VOLUME = re.compile(r"^(config|ssl|addons|backup|share)(?::(rw|:ro))?$")
-RE_SERVICE = re.compile(r"^(?P<service>mqtt)(?::(?P<rights>rw|:ro))?$")
-RE_DISCOVERY = re.compile(r"^(?P<component>\w*)(?:/(?P<platform>\w*>))?$")
+RE_SERVICE = re.compile(r"^(?P<service>mqtt):(?P<rights>provide|want|need)$")
 
 V_STR = 'str'
 V_INT = 'int'
@@ -51,17 +58,34 @@ ARCH_ALL = [
     ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386
 ]
 
+MACHINE_ALL = [
+    'intel-nuc', 'qemux86', 'qemux86-64', 'qemuarm', 'qemuarm-64',
+    'raspberrypi', 'raspberrypi2', 'raspberrypi3', 'raspberrypi3-64',
+    'odroid-c2', 'odroid-xu',
+]
+
 STARTUP_ALL = [
     STARTUP_ONCE, STARTUP_INITIALIZE, STARTUP_SYSTEM, STARTUP_SERVICES,
     STARTUP_APPLICATION
 ]
 
 PRIVILEGED_ALL = [
-    "NET_ADMIN",
-    "SYS_ADMIN",
-    "SYS_RAWIO",
-    "SYS_TIME",
-    "SYS_NICE"
+    PRIVILEGED_NET_ADMIN,
+    PRIVILEGED_SYS_ADMIN,
+    PRIVILEGED_SYS_RAWIO,
+    PRIVILEGED_IPC_LOCK,
+    PRIVILEGED_SYS_TIME,
+    PRIVILEGED_SYS_NICE,
+    PRIVILEGED_SYS_RESOURCE,
+    PRIVILEGED_SYS_PTRACE,
+    PRIVILEGED_DAC_READ_SEARCH,
+]
+
+ROLE_ALL = [
+    ROLE_DEFAULT,
+    ROLE_HOMEASSISTANT,
+    ROLE_MANAGER,
+    ROLE_ADMIN,
 ]
 
 BASE_IMAGE = {
@@ -89,6 +113,7 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Required(ATTR_DESCRIPTON): vol.Coerce(str),
     vol.Optional(ATTR_URL): vol.Url(),
     vol.Optional(ATTR_ARCH, default=ARCH_ALL): [vol.In(ARCH_ALL)],
+    vol.Optional(ATTR_MACHINE): [vol.In(MACHINE_ALL)],
     vol.Required(ATTR_STARTUP):
         vol.All(_simple_startup, vol.In(STARTUP_ALL)),
     vol.Required(ATTR_BOOT):
@@ -97,6 +122,7 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Optional(ATTR_WEBUI):
         vol.Match(r"^(?:https?|\[PROTO:\w+\]):\/\/\[HOST\]:\[PORT:\d+\].*$"),
     vol.Optional(ATTR_HOST_NETWORK, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HOST_PID, default=False): vol.Boolean(),
     vol.Optional(ATTR_HOST_IPC, default=False): vol.Boolean(),
     vol.Optional(ATTR_HOST_DBUS, default=False): vol.Boolean(),
     vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
@@ -106,14 +132,19 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Optional(ATTR_MAP, default=list): [vol.Match(RE_VOLUME)],
     vol.Optional(ATTR_ENVIRONMENT): {vol.Match(r"\w*"): vol.Coerce(str)},
     vol.Optional(ATTR_PRIVILEGED): [vol.In(PRIVILEGED_ALL)],
+    vol.Optional(ATTR_APPARMOR, default=True): vol.Boolean(),
+    vol.Optional(ATTR_FULL_ACCESS, default=False): vol.Boolean(),
     vol.Optional(ATTR_AUDIO, default=False): vol.Boolean(),
     vol.Optional(ATTR_GPIO, default=False): vol.Boolean(),
+    vol.Optional(ATTR_DEVICETREE, default=False): vol.Boolean(),
     vol.Optional(ATTR_HASSIO_API, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HASSIO_ROLE, default=ROLE_DEFAULT): vol.In(ROLE_ALL),
     vol.Optional(ATTR_HOMEASSISTANT_API, default=False): vol.Boolean(),
     vol.Optional(ATTR_STDIN, default=False): vol.Boolean(),
     vol.Optional(ATTR_LEGACY, default=False): vol.Boolean(),
+    vol.Optional(ATTR_DOCKER_API, default=False): vol.Boolean(),
     vol.Optional(ATTR_SERVICES): [vol.Match(RE_SERVICE)],
-    vol.Optional(ATTR_DISCOVERY): [vol.Match(RE_DISCOVERY)],
+    vol.Optional(ATTR_DISCOVERY): [vol.In(DISCOVERY_SERVICES)],
     vol.Required(ATTR_OPTIONS): dict,
     vol.Required(ATTR_SCHEMA): vol.Any(vol.Schema({
         vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [
@@ -125,7 +156,8 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
             vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [SCHEMA_ELEMENT])
         }))
     }), False),
-    vol.Optional(ATTR_IMAGE): vol.Match(r"^[\w{}]+/[\-\w{}]+$"),
+    vol.Optional(ATTR_IMAGE):
+        vol.Match(r"^([a-zA-Z.:\d{}]+/)*?([\w{}]+)/([\-\w{}]+)$"),
     vol.Optional(ATTR_TIMEOUT, default=10):
         vol.All(vol.Coerce(int), vol.Range(min=10, max=120)),
 }, extra=vol.REMOVE_EXTRA)
@@ -154,15 +186,16 @@ SCHEMA_BUILD_CONFIG = vol.Schema({
 # pylint: disable=no-value-for-parameter
 SCHEMA_ADDON_USER = vol.Schema({
     vol.Required(ATTR_VERSION): vol.Coerce(str),
-    vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex):
-        vol.Match(r"^[0-9a-f]{32}$"),
+    vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex): UUID_MATCH,
+    vol.Optional(ATTR_ACCESS_TOKEN): vol.Match(r"^[0-9a-f]{64}$"),
     vol.Optional(ATTR_OPTIONS, default=dict): dict,
     vol.Optional(ATTR_AUTO_UPDATE, default=False): vol.Boolean(),
     vol.Optional(ATTR_BOOT):
         vol.In([BOOT_AUTO, BOOT_MANUAL]),
     vol.Optional(ATTR_NETWORK): DOCKER_PORTS,
-    vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_CHANNEL,
-    vol.Optional(ATTR_AUDIO_INPUT): ALSA_CHANNEL,
+    vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_DEVICE,
+    vol.Optional(ATTR_AUDIO_INPUT): ALSA_DEVICE,
+    vol.Optional(ATTR_PROTECTED, default=True): vol.Boolean(),
 }, extra=vol.REMOVE_EXTRA)
 
 
@@ -193,7 +226,7 @@ SCHEMA_ADDON_SNAPSHOT = vol.Schema({
 def validate_options(raw_schema):
     """Validate schema."""
     def validate(struct):
-        """Create schema validator for addons options."""
+        """Create schema validator for add-ons options."""
         options = {}
 
         # read options

hassio/api/__init__.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO rest api."""
+"""Init file for Hass.io RESTful API."""
 import logging
 from pathlib import Path
 
@@ -7,243 +7,266 @@ from aiohttp import web
 from .addons import APIAddons
 from .discovery import APIDiscovery
 from .homeassistant import APIHomeAssistant
+from .hardware import APIHardware
 from .host import APIHost
-from .network import APINetwork
+from .hassos import APIHassOS
 from .proxy import APIProxy
 from .supervisor import APISupervisor
 from .snapshots import APISnapshots
 from .services import APIServices
-from .security import security_layer
+from .version import APIVersion
+from .security import SecurityMiddleware
 from ..coresys import CoreSysAttributes
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class RestAPI(CoreSysAttributes):
-    """Handle rest api for hassio."""
+    """Handle RESTful API for Hass.io."""
 
     def __init__(self, coresys):
-        """Initialize docker base wrapper."""
+        """Initialize Docker base wrapper."""
         self.coresys = coresys
+        self.security = SecurityMiddleware(coresys)
         self.webapp = web.Application(
-            middlewares=[security_layer], loop=self._loop)
+            middlewares=[self.security.token_validation], loop=coresys.loop)
 
         # service stuff
-        self._handler = None
-        self.server = None
-
-        # middleware
-        self.webapp['coresys'] = coresys
+        self._runner = web.AppRunner(self.webapp)
+        self._site = None
 
     async def load(self):
         """Register REST API Calls."""
         self._register_supervisor()
         self._register_host()
+        self._register_hassos()
+        self._register_hardware()
         self._register_homeassistant()
         self._register_proxy()
         self._register_panel()
         self._register_addons()
         self._register_snapshots()
-        self._register_network()
         self._register_discovery()
         self._register_services()
+        self._register_version()
 
     def _register_host(self):
-        """Register hostcontrol function."""
+        """Register hostcontrol functions."""
         api_host = APIHost()
         api_host.coresys = self.coresys
 
-        self.webapp.router.add_get('/host/info', api_host.info)
-        self.webapp.router.add_get('/host/hardware', api_host.hardware)
-        self.webapp.router.add_post('/host/reboot', api_host.reboot)
-        self.webapp.router.add_post('/host/shutdown', api_host.shutdown)
-        self.webapp.router.add_post('/host/update', api_host.update)
-        self.webapp.router.add_post('/host/options', api_host.options)
-        self.webapp.router.add_post('/host/reload', api_host.reload)
+        self.webapp.add_routes([
+            web.get('/host/info', api_host.info),
+            web.post('/host/reboot', api_host.reboot),
+            web.post('/host/shutdown', api_host.shutdown),
+            web.post('/host/reload', api_host.reload),
+            web.post('/host/options', api_host.options),
+            web.get('/host/services', api_host.services),
+            web.post('/host/services/{service}/stop', api_host.service_stop),
+            web.post('/host/services/{service}/start', api_host.service_start),
+            web.post(
+                '/host/services/{service}/restart', api_host.service_restart),
+            web.post(
+                '/host/services/{service}/reload', api_host.service_reload),
+        ])
 
-    def _register_network(self):
-        """Register network function."""
-        api_net = APINetwork()
-        api_net.coresys = self.coresys
+    def _register_hassos(self):
+        """Register HassOS functions."""
+        api_hassos = APIHassOS()
+        api_hassos.coresys = self.coresys
 
-        self.webapp.router.add_get('/network/info', api_net.info)
-        self.webapp.router.add_post('/network/options', api_net.options)
+        self.webapp.add_routes([
+            web.get('/hassos/info', api_hassos.info),
+            web.post('/hassos/update', api_hassos.update),
+            web.post('/hassos/update/cli', api_hassos.update_cli),
+            web.post('/hassos/config/sync', api_hassos.config_sync),
+        ])
+
+    def _register_hardware(self):
+        """Register hardware functions."""
+        api_hardware = APIHardware()
+        api_hardware.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/hardware/info', api_hardware.info),
+            web.get('/hardware/audio', api_hardware.audio),
+        ])
+
+    def _register_version(self):
+        """Register version functions."""
+        api_version = APIVersion()
+        api_version.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/version', api_version.info),
+        ])
 
     def _register_supervisor(self):
-        """Register supervisor function."""
+        """Register Supervisor functions."""
         api_supervisor = APISupervisor()
         api_supervisor.coresys = self.coresys
 
-        self.webapp.router.add_get('/supervisor/ping', api_supervisor.ping)
-        self.webapp.router.add_get('/supervisor/info', api_supervisor.info)
-        self.webapp.router.add_get('/supervisor/stats', api_supervisor.stats)
-        self.webapp.router.add_post(
-            '/supervisor/update', api_supervisor.update)
-        self.webapp.router.add_post(
-            '/supervisor/reload', api_supervisor.reload)
-        self.webapp.router.add_post(
-            '/supervisor/options', api_supervisor.options)
-        self.webapp.router.add_get('/supervisor/logs', api_supervisor.logs)
+        self.webapp.add_routes([
+            web.get('/supervisor/ping', api_supervisor.ping),
+            web.get('/supervisor/info', api_supervisor.info),
+            web.get('/supervisor/stats', api_supervisor.stats),
+            web.get('/supervisor/logs', api_supervisor.logs),
+            web.post('/supervisor/update', api_supervisor.update),
+            web.post('/supervisor/reload', api_supervisor.reload),
+            web.post('/supervisor/options', api_supervisor.options),
+        ])
 
     def _register_homeassistant(self):
-        """Register homeassistant function."""
+        """Register Home Assistant functions."""
         api_hass = APIHomeAssistant()
         api_hass.coresys = self.coresys
 
-        self.webapp.router.add_get('/homeassistant/info', api_hass.info)
-        self.webapp.router.add_get('/homeassistant/logs', api_hass.logs)
-        self.webapp.router.add_get('/homeassistant/stats', api_hass.stats)
-        self.webapp.router.add_post('/homeassistant/options', api_hass.options)
-        self.webapp.router.add_post('/homeassistant/update', api_hass.update)
-        self.webapp.router.add_post('/homeassistant/restart', api_hass.restart)
-        self.webapp.router.add_post('/homeassistant/stop', api_hass.stop)
-        self.webapp.router.add_post('/homeassistant/start', api_hass.start)
-        self.webapp.router.add_post('/homeassistant/check', api_hass.check)
+        self.webapp.add_routes([
+            web.get('/homeassistant/info', api_hass.info),
+            web.get('/homeassistant/logs', api_hass.logs),
+            web.get('/homeassistant/stats', api_hass.stats),
+            web.post('/homeassistant/options', api_hass.options),
+            web.post('/homeassistant/update', api_hass.update),
+            web.post('/homeassistant/restart', api_hass.restart),
+            web.post('/homeassistant/stop', api_hass.stop),
+            web.post('/homeassistant/start', api_hass.start),
+            web.post('/homeassistant/check', api_hass.check),
+        ])
 
     def _register_proxy(self):
-        """Register HomeAssistant API Proxy."""
+        """Register Home Assistant API Proxy."""
         api_proxy = APIProxy()
         api_proxy.coresys = self.coresys
 
-        self.webapp.router.add_get(
-            '/homeassistant/api/websocket', api_proxy.websocket)
-        self.webapp.router.add_get(
-            '/homeassistant/websocket', api_proxy.websocket)
-        self.webapp.router.add_get(
-            '/homeassistant/api/stream', api_proxy.stream)
-        self.webapp.router.add_post(
-            '/homeassistant/api/{path:.+}', api_proxy.api)
-        self.webapp.router.add_get(
-            '/homeassistant/api/{path:.+}', api_proxy.api)
-        self.webapp.router.add_get(
-            '/homeassistant/api/', api_proxy.api)
+        self.webapp.add_routes([
+            web.get('/homeassistant/api/websocket', api_proxy.websocket),
+            web.get('/homeassistant/websocket', api_proxy.websocket),
+            web.get('/homeassistant/api/stream', api_proxy.stream),
+            web.post('/homeassistant/api/{path:.+}', api_proxy.api),
+            web.get('/homeassistant/api/{path:.+}', api_proxy.api),
+            web.get('/homeassistant/api/', api_proxy.api),
+        ])
 
     def _register_addons(self):
-        """Register homeassistant function."""
+        """Register Add-on functions."""
         api_addons = APIAddons()
         api_addons.coresys = self.coresys
 
-        self.webapp.router.add_get('/addons', api_addons.list)
-        self.webapp.router.add_post('/addons/reload', api_addons.reload)
-        self.webapp.router.add_get('/addons/{addon}/info', api_addons.info)
-        self.webapp.router.add_post(
-            '/addons/{addon}/install', api_addons.install)
-        self.webapp.router.add_post(
-            '/addons/{addon}/uninstall', api_addons.uninstall)
-        self.webapp.router.add_post('/addons/{addon}/start', api_addons.start)
-        self.webapp.router.add_post('/addons/{addon}/stop', api_addons.stop)
-        self.webapp.router.add_post(
-            '/addons/{addon}/restart', api_addons.restart)
-        self.webapp.router.add_post(
-            '/addons/{addon}/update', api_addons.update)
-        self.webapp.router.add_post(
-            '/addons/{addon}/options', api_addons.options)
-        self.webapp.router.add_post(
-            '/addons/{addon}/rebuild', api_addons.rebuild)
-        self.webapp.router.add_get('/addons/{addon}/logs', api_addons.logs)
-        self.webapp.router.add_get('/addons/{addon}/icon', api_addons.icon)
-        self.webapp.router.add_get('/addons/{addon}/logo', api_addons.logo)
-        self.webapp.router.add_get(
-            '/addons/{addon}/changelog', api_addons.changelog)
-        self.webapp.router.add_post('/addons/{addon}/stdin', api_addons.stdin)
-        self.webapp.router.add_get('/addons/{addon}/stats', api_addons.stats)
+        self.webapp.add_routes([
+            web.get('/addons', api_addons.list),
+            web.post('/addons/reload', api_addons.reload),
+            web.get('/addons/{addon}/info', api_addons.info),
+            web.post('/addons/{addon}/install', api_addons.install),
+            web.post('/addons/{addon}/uninstall', api_addons.uninstall),
+            web.post('/addons/{addon}/start', api_addons.start),
+            web.post('/addons/{addon}/stop', api_addons.stop),
+            web.post('/addons/{addon}/restart', api_addons.restart),
+            web.post('/addons/{addon}/update', api_addons.update),
+            web.post('/addons/{addon}/options', api_addons.options),
+            web.post('/addons/{addon}/rebuild', api_addons.rebuild),
+            web.get('/addons/{addon}/logs', api_addons.logs),
+            web.get('/addons/{addon}/icon', api_addons.icon),
+            web.get('/addons/{addon}/logo', api_addons.logo),
+            web.get('/addons/{addon}/changelog', api_addons.changelog),
+            web.post('/addons/{addon}/stdin', api_addons.stdin),
+            web.post('/addons/{addon}/security', api_addons.security),
+            web.get('/addons/{addon}/stats', api_addons.stats),
+        ])
 
     def _register_snapshots(self):
-        """Register snapshots function."""
+        """Register snapshots functions."""
         api_snapshots = APISnapshots()
         api_snapshots.coresys = self.coresys
 
-        self.webapp.router.add_get('/snapshots', api_snapshots.list)
-        self.webapp.router.add_post('/snapshots/reload', api_snapshots.reload)
-
-        self.webapp.router.add_post(
-            '/snapshots/new/full', api_snapshots.snapshot_full)
-        self.webapp.router.add_post(
-            '/snapshots/new/partial', api_snapshots.snapshot_partial)
-        self.webapp.router.add_post(
-            '/snapshots/new/upload', api_snapshots.upload)
-
-        self.webapp.router.add_get(
-            '/snapshots/{snapshot}/info', api_snapshots.info)
-        self.webapp.router.add_post(
-            '/snapshots/{snapshot}/remove', api_snapshots.remove)
-        self.webapp.router.add_post(
-            '/snapshots/{snapshot}/restore/full', api_snapshots.restore_full)
-        self.webapp.router.add_post(
-            '/snapshots/{snapshot}/restore/partial',
-            api_snapshots.restore_partial)
-        self.webapp.router.add_get(
-            '/snapshots/{snapshot}/download',
-            api_snapshots.download)
+        self.webapp.add_routes([
+            web.get('/snapshots', api_snapshots.list),
+            web.post('/snapshots/reload', api_snapshots.reload),
+            web.post('/snapshots/new/full', api_snapshots.snapshot_full),
+            web.post('/snapshots/new/partial', api_snapshots.snapshot_partial),
+            web.post('/snapshots/new/upload', api_snapshots.upload),
+            web.get('/snapshots/{snapshot}/info', api_snapshots.info),
+            web.post('/snapshots/{snapshot}/remove', api_snapshots.remove),
+            web.post('/snapshots/{snapshot}/restore/full',
+                     api_snapshots.restore_full),
+            web.post('/snapshots/{snapshot}/restore/partial',
+                     api_snapshots.restore_partial),
+            web.get('/snapshots/{snapshot}/download', api_snapshots.download),
+        ])
 
     def _register_services(self):
+        """Register services functions."""
         api_services = APIServices()
         api_services.coresys = self.coresys
 
-        self.webapp.router.add_get('/services', api_services.list)
-
-        self.webapp.router.add_get(
-            '/services/{service}', api_services.get_service)
-        self.webapp.router.add_post(
-            '/services/{service}', api_services.set_service)
-        self.webapp.router.add_delete(
-            '/services/{service}', api_services.del_service)
+        self.webapp.add_routes([
+            web.get('/services', api_services.list),
+            web.get('/services/{service}', api_services.get_service),
+            web.post('/services/{service}', api_services.set_service),
+            web.delete('/services/{service}', api_services.del_service),
+        ])
 
     def _register_discovery(self):
+        """Register discovery functions."""
         api_discovery = APIDiscovery()
         api_discovery.coresys = self.coresys
 
-        self.webapp.router.add_get(
-            '/services/discovery', api_discovery.list)
-        self.webapp.router.add_get(
-            '/services/discovery/{uuid}', api_discovery.get_discovery)
-        self.webapp.router.add_delete(
-            '/services/discovery/{uuid}', api_discovery.del_discovery)
-        self.webapp.router.add_post(
-            '/services/discovery', api_discovery.set_discovery)
+        self.webapp.add_routes([
+            web.get('/discovery', api_discovery.list),
+            web.get('/discovery/{uuid}', api_discovery.get_discovery),
+            web.delete('/discovery/{uuid}',
+                       api_discovery.del_discovery),
+            web.post('/discovery', api_discovery.set_discovery),
+        ])
 
     def _register_panel(self):
-        """Register panel for homeassistant."""
-        def create_panel_response(build_type):
+        """Register panel for Home Assistant."""
+        panel_dir = Path(__file__).parent.joinpath("panel")
+
+        def create_response(panel_file):
             """Create a function to generate a response."""
-            path = Path(__file__).parent.joinpath(
-                f"panel/{build_type}.html")
+            path = panel_dir.joinpath(f"{panel_file!s}.html")
             return lambda request: web.FileResponse(path)
 
         # This route is for backwards compatibility with HA < 0.58
-        self.webapp.router.add_get(
-            '/panel', create_panel_response('hassio-main-es5'))
+        self.webapp.add_routes([
+            web.get('/panel', create_response('hassio-main-es5'))])
 
         # This route is for backwards compatibility with HA 0.58 - 0.61
-        self.webapp.router.add_get(
-            '/panel_es5', create_panel_response('hassio-main-es5'))
-        self.webapp.router.add_get(
-            '/panel_latest', create_panel_response('hassio-main-latest'))
+        self.webapp.add_routes([
+            web.get('/panel_es5', create_response('hassio-main-es5')),
+            web.get('/panel_latest', create_response('hassio-main-latest')),
+        ])
 
-        # This route is for HA > 0.61
-        self.webapp.router.add_get(
-            '/app-es5/index.html', create_panel_response('index'))
-        self.webapp.router.add_get(
-            '/app-es5/hassio-app.html', create_panel_response('hassio-app'))
+        # This route is for backwards compatibility with HA 0.62 - 0.70
+        self.webapp.add_routes([
+            web.get('/app-es5/index.html', create_response('index')),
+            web.get('/app-es5/hassio-app.html', create_response('hassio-app')),
+        ])
+
+        # This route is for HA > 0.70
+        self.webapp.add_routes([web.static('/app', panel_dir)])
 
     async def start(self):
-        """Run rest api webserver."""
-        self._handler = self.webapp.make_handler(loop=self._loop)
+        """Run RESTful API webserver."""
+        await self._runner.setup()
+        self._site = web.TCPSite(
+            self._runner, host="0.0.0.0", port=80, shutdown_timeout=5)
 
         try:
-            self.server = await self._loop.create_server(
-                self._handler, "0.0.0.0", "80")
+            await self._site.start()
         except OSError as err:
             _LOGGER.fatal(
                 "Failed to create HTTP server at 0.0.0.0:80 -> %s", err)
+        else:
+            _LOGGER.info("Start API on %s", self.sys_docker.network.supervisor)
 
     async def stop(self):
-        """Stop rest api webserver."""
-        if self.server:
-            self.server.close()
-            await self.server.wait_closed()
-        await self.webapp.shutdown()
+        """Stop RESTful API webserver."""
+        if not self._site:
+            return
 
-        if self._handler:
-            await self._handler.shutdown(60)
-        await self.webapp.cleanup()
+        # Shutdown running API
+        await self._site.stop()
+        await self._runner.cleanup()
+
+        _LOGGER.info("Stop API on %s", self.sys_docker.network.supervisor)

hassio/api/addons.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO homeassistant rest api."""
+"""Init file for Hass.io Home Assistant RESTful API."""
 import asyncio
 import logging
 
@@ -6,6 +6,7 @@ import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
 from .utils import api_process, api_process_raw, api_validate
+from ..addons.utils import rating_security
 from ..const import (
     ATTR_VERSION, ATTR_LAST_VERSION, ATTR_STATE, ATTR_BOOT, ATTR_OPTIONS,
     ATTR_URL, ATTR_DESCRIPTON, ATTR_DETACHED, ATTR_NAME, ATTR_REPOSITORY,
@@ -17,10 +18,13 @@ from ..const import (
     ATTR_CHANGELOG, ATTR_HOST_IPC, ATTR_HOST_DBUS, ATTR_LONG_DESCRIPTION,
     ATTR_CPU_PERCENT, ATTR_MEMORY_LIMIT, ATTR_MEMORY_USAGE, ATTR_NETWORK_TX,
     ATTR_NETWORK_RX, ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_ICON, ATTR_SERVICES,
-    ATTR_DISCOVERY,
-    CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY, CONTENT_TYPE_TEXT)
+    ATTR_DISCOVERY, ATTR_APPARMOR, ATTR_DEVICETREE, ATTR_DOCKER_API,
+    ATTR_FULL_ACCESS, ATTR_PROTECTED, ATTR_RATING, ATTR_HOST_PID,
+    ATTR_HASSIO_ROLE, ATTR_MACHINE, ATTR_AVAILABLE,
+    CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY, CONTENT_TYPE_TEXT, REQUEST_FROM)
 from ..coresys import CoreSysAttributes
-from ..validate import DOCKER_PORTS
+from ..validate import DOCKER_PORTS, ALSA_DEVICE
+from ..exceptions import APIError
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -33,43 +37,48 @@ SCHEMA_OPTIONS = vol.Schema({
     vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL]),
     vol.Optional(ATTR_NETWORK): vol.Any(None, DOCKER_PORTS),
     vol.Optional(ATTR_AUTO_UPDATE): vol.Boolean(),
+    vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_DEVICE,
+    vol.Optional(ATTR_AUDIO_INPUT): ALSA_DEVICE,
+})
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_SECURITY = vol.Schema({
+    vol.Optional(ATTR_PROTECTED): vol.Boolean(),
 })
 
 
 class APIAddons(CoreSysAttributes):
-    """Handle rest api for addons functions."""
+    """Handle RESTful API for add-on functions."""
 
     def _extract_addon(self, request, check_installed=True):
-        """Return addon and if not exists trow a exception."""
-        addon = self._addons.get(request.match_info.get('addon'))
+        """Return addon, throw an exception it it doesn't exist."""
+        addon_slug = request.match_info.get('addon')
+
+        # Lookup itself
+        if addon_slug == 'self':
+            return request.get(REQUEST_FROM)
+
+        addon = self.sys_addons.get(addon_slug)
         if not addon:
-            raise RuntimeError("Addon not exists")
+            raise APIError("Addon does not exist")
 
         if check_installed and not addon.is_installed:
-            raise RuntimeError("Addon is not installed")
+            raise APIError("Addon is not installed")
 
         return addon
 
-    @staticmethod
-    def _pretty_devices(addon):
-        """Return a simplified device list."""
-        dev_list = addon.devices
-        if not dev_list:
-            return None
-        return [row.split(':')[0] for row in dev_list]
-
     @api_process
     async def list(self, request):
-        """Return all addons / repositories ."""
+        """Return all add-ons or repositories."""
         data_addons = []
-        for addon in self._addons.list_addons:
+        for addon in self.sys_addons.list_addons:
             data_addons.append({
                 ATTR_NAME: addon.name,
                 ATTR_SLUG: addon.slug,
                 ATTR_DESCRIPTON: addon.description,
                 ATTR_VERSION: addon.last_version,
                 ATTR_INSTALLED: addon.version_installed,
-                ATTR_ARCH: addon.supported_arch,
+                ATTR_AVAILABLE: addon.available,
                 ATTR_DETACHED: addon.is_detached,
                 ATTR_REPOSITORY: addon.repository,
                 ATTR_BUILD: addon.need_build,
@@ -79,7 +88,7 @@ class APIAddons(CoreSysAttributes):
             })
 
         data_repositories = []
-        for repository in self._addons.list_repositories:
+        for repository in self.sys_addons.list_repositories:
             data_repositories.append({
                 ATTR_SLUG: repository.slug,
                 ATTR_NAME: repository.name,
@@ -95,17 +104,18 @@ class APIAddons(CoreSysAttributes):
 
     @api_process
     async def reload(self, request):
-        """Reload all addons data."""
-        await asyncio.shield(self._addons.reload(), loop=self._loop)
+        """Reload all add-on data."""
+        await asyncio.shield(self.sys_addons.reload())
         return True
 
     @api_process
     async def info(self, request):
-        """Return addon information."""
+        """Return add-on information."""
         addon = self._extract_addon(request, check_installed=False)
 
         return {
             ATTR_NAME: addon.name,
+            ATTR_SLUG: addon.slug,
             ATTR_DESCRIPTON: addon.description,
             ATTR_LONG_DESCRIPTION: addon.long_description,
             ATTR_VERSION: addon.version_installed,
@@ -113,35 +123,46 @@ class APIAddons(CoreSysAttributes):
             ATTR_REPOSITORY: addon.repository,
             ATTR_LAST_VERSION: addon.last_version,
             ATTR_STATE: await addon.state(),
+            ATTR_PROTECTED: addon.protected,
+            ATTR_RATING: rating_security(addon),
             ATTR_BOOT: addon.boot,
             ATTR_OPTIONS: addon.options,
+            ATTR_ARCH: addon.supported_arch,
+            ATTR_MACHINE: addon.supported_machine,
             ATTR_URL: addon.url,
             ATTR_DETACHED: addon.is_detached,
+            ATTR_AVAILABLE: addon.available,
             ATTR_BUILD: addon.need_build,
             ATTR_NETWORK: addon.ports,
             ATTR_HOST_NETWORK: addon.host_network,
+            ATTR_HOST_PID: addon.host_pid,
             ATTR_HOST_IPC: addon.host_ipc,
             ATTR_HOST_DBUS: addon.host_dbus,
             ATTR_PRIVILEGED: addon.privileged,
-            ATTR_DEVICES: self._pretty_devices(addon),
+            ATTR_FULL_ACCESS: addon.with_full_access,
+            ATTR_APPARMOR: addon.apparmor,
+            ATTR_DEVICES: _pretty_devices(addon),
             ATTR_ICON: addon.with_icon,
             ATTR_LOGO: addon.with_logo,
             ATTR_CHANGELOG: addon.with_changelog,
             ATTR_WEBUI: addon.webui,
             ATTR_STDIN: addon.with_stdin,
             ATTR_HASSIO_API: addon.access_hassio_api,
+            ATTR_HASSIO_ROLE: addon.hassio_role,
             ATTR_HOMEASSISTANT_API: addon.access_homeassistant_api,
             ATTR_GPIO: addon.with_gpio,
+            ATTR_DEVICETREE: addon.with_devicetree,
+            ATTR_DOCKER_API: addon.access_docker_api,
             ATTR_AUDIO: addon.with_audio,
             ATTR_AUDIO_INPUT: addon.audio_input,
             ATTR_AUDIO_OUTPUT: addon.audio_output,
-            ATTR_SERVICES: addon.services,
+            ATTR_SERVICES: _pretty_services(addon),
             ATTR_DISCOVERY: addon.discovery,
         }
 
     @api_process
     async def options(self, request):
-        """Store user options for addon."""
+        """Store user options for add-on."""
         addon = self._extract_addon(request)
 
         addon_schema = SCHEMA_OPTIONS.extend({
@@ -166,6 +187,19 @@ class APIAddons(CoreSysAttributes):
         addon.save_data()
         return True
 
+    @api_process
+    async def security(self, request):
+        """Store security options for add-on."""
+        addon = self._extract_addon(request)
+        body = await api_validate(SCHEMA_SECURITY, request)
+
+        if ATTR_PROTECTED in body:
+            _LOGGER.warning("Protected flag changing for %s!", addon.slug)
+            addon.protected = body[ATTR_PROTECTED]
+
+        addon.save_data()
+        return True
+
     @api_process
     async def stats(self, request):
         """Return resource information."""
@@ -173,7 +207,7 @@ class APIAddons(CoreSysAttributes):
         stats = await addon.stats()
 
         if not stats:
-            raise RuntimeError("No stats available")
+            raise APIError("No stats available")
 
         return {
             ATTR_CPU_PERCENT: stats.cpu_percent,
@@ -187,19 +221,19 @@ class APIAddons(CoreSysAttributes):
 
     @api_process
     def install(self, request):
-        """Install addon."""
+        """Install add-on."""
         addon = self._extract_addon(request, check_installed=False)
-        return asyncio.shield(addon.install(), loop=self._loop)
+        return asyncio.shield(addon.install())
 
     @api_process
     def uninstall(self, request):
-        """Uninstall addon."""
+        """Uninstall add-on."""
         addon = self._extract_addon(request)
-        return asyncio.shield(addon.uninstall(), loop=self._loop)
+        return asyncio.shield(addon.uninstall())
 
     @api_process
     def start(self, request):
-        """Start addon."""
+        """Start add-on."""
         addon = self._extract_addon(request)
 
         # check options
@@ -207,83 +241,99 @@ class APIAddons(CoreSysAttributes):
         try:
             addon.schema(options)
         except vol.Invalid as ex:
-            raise RuntimeError(humanize_error(options, ex)) from None
+            raise APIError(humanize_error(options, ex)) from None
 
-        return asyncio.shield(addon.start(), loop=self._loop)
+        return asyncio.shield(addon.start())
 
     @api_process
     def stop(self, request):
-        """Stop addon."""
+        """Stop add-on."""
         addon = self._extract_addon(request)
-        return asyncio.shield(addon.stop(), loop=self._loop)
+        return asyncio.shield(addon.stop())
 
     @api_process
     def update(self, request):
-        """Update addon."""
+        """Update add-on."""
         addon = self._extract_addon(request)
 
         if addon.last_version == addon.version_installed:
-            raise RuntimeError("No update available!")
+            raise APIError("No update available!")
 
-        return asyncio.shield(addon.update(), loop=self._loop)
+        return asyncio.shield(addon.update())
 
     @api_process
     def restart(self, request):
-        """Restart addon."""
+        """Restart add-on."""
         addon = self._extract_addon(request)
-        return asyncio.shield(addon.restart(), loop=self._loop)
+        return asyncio.shield(addon.restart())
 
     @api_process
     def rebuild(self, request):
-        """Rebuild local build addon."""
+        """Rebuild local build add-on."""
         addon = self._extract_addon(request)
         if not addon.need_build:
-            raise RuntimeError("Only local build addons are supported")
+            raise APIError("Only local build addons are supported")
 
-        return asyncio.shield(addon.rebuild(), loop=self._loop)
+        return asyncio.shield(addon.rebuild())
 
     @api_process_raw(CONTENT_TYPE_BINARY)
     def logs(self, request):
-        """Return logs from addon."""
+        """Return logs from add-on."""
         addon = self._extract_addon(request)
         return addon.logs()
 
     @api_process_raw(CONTENT_TYPE_PNG)
     async def icon(self, request):
-        """Return icon from addon."""
+        """Return icon from add-on."""
         addon = self._extract_addon(request, check_installed=False)
         if not addon.with_icon:
-            raise RuntimeError("No icon found!")
+            raise APIError("No icon found!")
 
         with addon.path_icon.open('rb') as png:
             return png.read()
 
     @api_process_raw(CONTENT_TYPE_PNG)
     async def logo(self, request):
-        """Return logo from addon."""
+        """Return logo from add-on."""
         addon = self._extract_addon(request, check_installed=False)
         if not addon.with_logo:
-            raise RuntimeError("No logo found!")
+            raise APIError("No logo found!")
 
         with addon.path_logo.open('rb') as png:
             return png.read()
 
     @api_process_raw(CONTENT_TYPE_TEXT)
     async def changelog(self, request):
-        """Return changelog from addon."""
+        """Return changelog from add-on."""
         addon = self._extract_addon(request, check_installed=False)
         if not addon.with_changelog:
-            raise RuntimeError("No changelog found!")
+            raise APIError("No changelog found!")
 
         with addon.path_changelog.open('r') as changelog:
             return changelog.read()
 
     @api_process
     async def stdin(self, request):
-        """Write to stdin of addon."""
+        """Write to stdin of add-on."""
         addon = self._extract_addon(request)
         if not addon.with_stdin:
-            raise RuntimeError("STDIN not supported by addon")
+            raise APIError("STDIN not supported by add-on")
 
         data = await request.read()
-        return await asyncio.shield(addon.write_stdin(data), loop=self._loop)
+        return await asyncio.shield(addon.write_stdin(data))
+
+
+def _pretty_devices(addon):
+    """Return a simplified device list."""
+    dev_list = addon.devices
+    if not dev_list:
+        return None
+    return [row.split(':')[0] for row in dev_list]
+
+
+def _pretty_services(addon):
+    """Return a simplified services role list."""
+    services = []
+    for name, access in addon.services_role.items():
+        services.append(f"{name}:{access}")
+    return services

hassio/api/discovery.py

@@ -1,41 +1,47 @@
-"""Init file for HassIO network rest api."""
-
+"""Init file for Hass.io network RESTful API."""
 import voluptuous as vol
 
 from .utils import api_process, api_validate
 from ..const import (
-    ATTR_PROVIDER, ATTR_UUID, ATTR_COMPONENT, ATTR_PLATFORM, ATTR_CONFIG,
-    ATTR_DISCOVERY, REQUEST_FROM)
+    ATTR_ADDON, ATTR_UUID, ATTR_CONFIG, ATTR_DISCOVERY, ATTR_SERVICE,
+    REQUEST_FROM)
 from ..coresys import CoreSysAttributes
+from ..exceptions import APIError, APIForbidden
+from ..validate import SERVICE_ALL
 
 
 SCHEMA_DISCOVERY = vol.Schema({
-    vol.Required(ATTR_COMPONENT): vol.Coerce(str),
-    vol.Optional(ATTR_PLATFORM): vol.Any(None, vol.Coerce(str)),
-    vol.Optional(ATTR_CONFIG): vol.Any(None, dict),
+    vol.Required(ATTR_SERVICE): SERVICE_ALL,
+    vol.Optional(ATTR_CONFIG): vol.Maybe(dict),
 })
 
 
 class APIDiscovery(CoreSysAttributes):
-    """Handle rest api for discovery functions."""
+    """Handle RESTful API for discovery functions."""
 
     def _extract_message(self, request):
         """Extract discovery message from URL."""
-        message = self._services.discovery.get(request.match_info.get('uuid'))
+        message = self.sys_discovery.get(request.match_info.get('uuid'))
         if not message:
-            raise RuntimeError("Discovery message not found")
+            raise APIError("Discovery message not found")
         return message
 
+    def _check_permission_ha(self, request):
+        """Check permission for API call / Home Assistant."""
+        if request[REQUEST_FROM] != self.sys_homeassistant:
+            raise APIForbidden("Only HomeAssistant can use this API!")
+
     @api_process
     async def list(self, request):
         """Show register services."""
+        self._check_permission_ha(request)
+
         discovery = []
-        for message in self._services.discovery.list_messages:
+        for message in self.sys_discovery.list_messages:
             discovery.append({
-                ATTR_PROVIDER: message.provider,
+                ATTR_ADDON: message.addon,
+                ATTR_SERVICE: message.service,
                 ATTR_UUID: message.uuid,
-                ATTR_COMPONENT: message.component,
-                ATTR_PLATFORM: message.platform,
                 ATTR_CONFIG: message.config,
             })
 
@@ -45,8 +51,14 @@ class APIDiscovery(CoreSysAttributes):
     async def set_discovery(self, request):
         """Write data into a discovery pipeline."""
         body = await api_validate(SCHEMA_DISCOVERY, request)
-        message = self._services.discovery.send(
-            provider=request[REQUEST_FROM], **body)
+        addon = request[REQUEST_FROM]
+
+        # Access?
+        if body[ATTR_SERVICE] not in addon.discovery:
+            raise APIForbidden(f"Can't use discovery!")
+
+        # Process discovery message
+        message = self.sys_discovery.send(addon, **body)
 
         return {ATTR_UUID: message.uuid}
 
@@ -55,11 +67,13 @@ class APIDiscovery(CoreSysAttributes):
         """Read data into a discovery message."""
         message = self._extract_message(request)
 
+        # HomeAssistant?
+        self._check_permission_ha(request)
+
         return {
-            ATTR_PROVIDER: message.provider,
+            ATTR_ADDON: message.addon,
+            ATTR_SERVICE: message.service,
             ATTR_UUID: message.uuid,
-            ATTR_COMPONENT: message.component,
-            ATTR_PLATFORM: message.platform,
             ATTR_CONFIG: message.config,
         }
 
@@ -67,6 +81,11 @@ class APIDiscovery(CoreSysAttributes):
     async def del_discovery(self, request):
         """Delete data into a discovery message."""
         message = self._extract_message(request)
+        addon = request[REQUEST_FROM]
 
-        self._services.discovery.remove(message)
+        # Permission
+        if message.addon != addon.slug:
+            raise APIForbidden(f"Can't remove discovery message")
+
+        self.sys_discovery.remove(message)
         return True

hassio/api/hardware.py

@@ -0,0 +1,34 @@
+"""Init file for Hass.io hardware RESTful API."""
+import logging
+
+from .utils import api_process
+from ..const import (
+    ATTR_SERIAL, ATTR_DISK, ATTR_GPIO, ATTR_AUDIO, ATTR_INPUT, ATTR_OUTPUT)
+from ..coresys import CoreSysAttributes
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIHardware(CoreSysAttributes):
+    """Handle RESTful API for hardware functions."""
+
+    @api_process
+    async def info(self, request):
+        """Show hardware info."""
+        return {
+            ATTR_SERIAL: list(self.sys_hardware.serial_devices),
+            ATTR_INPUT: list(self.sys_hardware.input_devices),
+            ATTR_DISK: list(self.sys_hardware.disk_devices),
+            ATTR_GPIO: list(self.sys_hardware.gpio_devices),
+            ATTR_AUDIO: self.sys_hardware.audio_devices,
+        }
+
+    @api_process
+    async def audio(self, request):
+        """Show ALSA audio devices."""
+        return {
+            ATTR_AUDIO: {
+                ATTR_INPUT: self.sys_host.alsa.input_devices,
+                ATTR_OUTPUT: self.sys_host.alsa.output_devices,
+            }
+        }

hassio/api/hassos.py

@@ -0,0 +1,53 @@
+"""Init file for Hass.io HassOS RESTful API."""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from .utils import api_process, api_validate
+from ..const import (
+    ATTR_VERSION, ATTR_BOARD, ATTR_VERSION_LATEST, ATTR_VERSION_CLI,
+    ATTR_VERSION_CLI_LATEST)
+from ..coresys import CoreSysAttributes
+
+_LOGGER = logging.getLogger(__name__)
+
+SCHEMA_VERSION = vol.Schema({
+    vol.Optional(ATTR_VERSION): vol.Coerce(str),
+})
+
+
+class APIHassOS(CoreSysAttributes):
+    """Handle RESTful API for HassOS functions."""
+
+    @api_process
+    async def info(self, request):
+        """Return HassOS information."""
+        return {
+            ATTR_VERSION: self.sys_hassos.version,
+            ATTR_VERSION_CLI: self.sys_hassos.version_cli,
+            ATTR_VERSION_LATEST: self.sys_hassos.version_latest,
+            ATTR_VERSION_CLI_LATEST: self.sys_hassos.version_cli_latest,
+            ATTR_BOARD: self.sys_hassos.board,
+        }
+
+    @api_process
+    async def update(self, request):
+        """Update HassOS."""
+        body = await api_validate(SCHEMA_VERSION, request)
+        version = body.get(ATTR_VERSION, self.sys_hassos.version_latest)
+
+        await asyncio.shield(self.sys_hassos.update(version))
+
+    @api_process
+    async def update_cli(self, request):
+        """Update HassOS CLI."""
+        body = await api_validate(SCHEMA_VERSION, request)
+        version = body.get(ATTR_VERSION, self.sys_hassos.version_cli_latest)
+
+        await asyncio.shield(self.sys_hassos.update_cli(version))
+
+    @api_process
+    def config_sync(self, request):
+        """Trigger config reload on HassOS."""
+        return asyncio.shield(self.sys_hassos.config_sync())

hassio/api/homeassistant.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO homeassistant rest api."""
+"""Init file for Hass.io Home Assistant RESTful API."""
 import asyncio
 import logging
 
@@ -9,9 +9,11 @@ from ..const import (
     ATTR_VERSION, ATTR_LAST_VERSION, ATTR_IMAGE, ATTR_CUSTOM, ATTR_BOOT,
     ATTR_PORT, ATTR_PASSWORD, ATTR_SSL, ATTR_WATCHDOG, ATTR_CPU_PERCENT,
     ATTR_MEMORY_USAGE, ATTR_MEMORY_LIMIT, ATTR_NETWORK_RX, ATTR_NETWORK_TX,
-    ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_WAIT_BOOT, CONTENT_TYPE_BINARY)
+    ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_WAIT_BOOT, ATTR_MACHINE,
+    ATTR_REFRESH_TOKEN, CONTENT_TYPE_BINARY)
 from ..coresys import CoreSysAttributes
 from ..validate import NETWORK_PORT, DOCKER_IMAGE
+from ..exceptions import APIError
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -20,15 +22,16 @@ _LOGGER = logging.getLogger(__name__)
 SCHEMA_OPTIONS = vol.Schema({
     vol.Optional(ATTR_BOOT): vol.Boolean(),
     vol.Inclusive(ATTR_IMAGE, 'custom_hass'):
-        vol.Any(None, vol.Coerce(str)),
+        vol.Maybe(vol.Coerce(str)),
     vol.Inclusive(ATTR_LAST_VERSION, 'custom_hass'):
         vol.Any(None, DOCKER_IMAGE),
     vol.Optional(ATTR_PORT): NETWORK_PORT,
-    vol.Optional(ATTR_PASSWORD): vol.Any(None, vol.Coerce(str)),
+    vol.Optional(ATTR_PASSWORD): vol.Maybe(vol.Coerce(str)),
     vol.Optional(ATTR_SSL): vol.Boolean(),
     vol.Optional(ATTR_WATCHDOG): vol.Boolean(),
     vol.Optional(ATTR_WAIT_BOOT):
         vol.All(vol.Coerce(int), vol.Range(min=60)),
+    vol.Optional(ATTR_REFRESH_TOKEN): vol.Maybe(vol.Coerce(str)),
 })
 
 SCHEMA_VERSION = vol.Schema({
@@ -37,59 +40,62 @@ SCHEMA_VERSION = vol.Schema({
 
 
 class APIHomeAssistant(CoreSysAttributes):
-    """Handle rest api for homeassistant functions."""
+    """Handle RESTful API for Home Assistant functions."""
 
     @api_process
     async def info(self, request):
         """Return host information."""
         return {
-            ATTR_VERSION: self._homeassistant.version,
-            ATTR_LAST_VERSION: self._homeassistant.last_version,
-            ATTR_IMAGE: self._homeassistant.image,
-            ATTR_CUSTOM: self._homeassistant.is_custom_image,
-            ATTR_BOOT: self._homeassistant.boot,
-            ATTR_PORT: self._homeassistant.api_port,
-            ATTR_SSL: self._homeassistant.api_ssl,
-            ATTR_WATCHDOG: self._homeassistant.watchdog,
-            ATTR_WAIT_BOOT: self._homeassistant.wait_boot,
+            ATTR_VERSION: self.sys_homeassistant.version,
+            ATTR_LAST_VERSION: self.sys_homeassistant.last_version,
+            ATTR_MACHINE: self.sys_homeassistant.machine,
+            ATTR_IMAGE: self.sys_homeassistant.image,
+            ATTR_CUSTOM: self.sys_homeassistant.is_custom_image,
+            ATTR_BOOT: self.sys_homeassistant.boot,
+            ATTR_PORT: self.sys_homeassistant.api_port,
+            ATTR_SSL: self.sys_homeassistant.api_ssl,
+            ATTR_WATCHDOG: self.sys_homeassistant.watchdog,
+            ATTR_WAIT_BOOT: self.sys_homeassistant.wait_boot,
         }
 
     @api_process
     async def options(self, request):
-        """Set homeassistant options."""
+        """Set Home Assistant options."""
         body = await api_validate(SCHEMA_OPTIONS, request)
 
         if ATTR_IMAGE in body and ATTR_LAST_VERSION in body:
-            self._homeassistant.image = body[ATTR_IMAGE]
-            self._homeassistant.last_version = body[ATTR_LAST_VERSION]
+            self.sys_homeassistant.image = body[ATTR_IMAGE]
+            self.sys_homeassistant.last_version = body[ATTR_LAST_VERSION]
 
         if ATTR_BOOT in body:
-            self._homeassistant.boot = body[ATTR_BOOT]
+            self.sys_homeassistant.boot = body[ATTR_BOOT]
 
         if ATTR_PORT in body:
-            self._homeassistant.api_port = body[ATTR_PORT]
+            self.sys_homeassistant.api_port = body[ATTR_PORT]
 
         if ATTR_PASSWORD in body:
-            self._homeassistant.api_password = body[ATTR_PASSWORD]
+            self.sys_homeassistant.api_password = body[ATTR_PASSWORD]
 
         if ATTR_SSL in body:
-            self._homeassistant.api_ssl = body[ATTR_SSL]
+            self.sys_homeassistant.api_ssl = body[ATTR_SSL]
 
         if ATTR_WATCHDOG in body:
-            self._homeassistant.watchdog = body[ATTR_WATCHDOG]
+            self.sys_homeassistant.watchdog = body[ATTR_WATCHDOG]
 
         if ATTR_WAIT_BOOT in body:
-            self._homeassistant.wait_boot = body[ATTR_WAIT_BOOT]
+            self.sys_homeassistant.wait_boot = body[ATTR_WAIT_BOOT]
 
-        self._homeassistant.save_data()
-        return True
+        if ATTR_REFRESH_TOKEN in body:
+            self.sys_homeassistant.refresh_token = body[ATTR_REFRESH_TOKEN]
+
+        self.sys_homeassistant.save_data()
 
     @api_process
     async def stats(self, request):
         """Return resource information."""
-        stats = await self._homeassistant.stats()
+        stats = await self.sys_homeassistant.stats()
         if not stats:
-            raise RuntimeError("No stats available")
+            raise APIError("No stats available")
 
         return {
             ATTR_CPU_PERCENT: stats.cpu_percent,
@@ -103,41 +109,35 @@ class APIHomeAssistant(CoreSysAttributes):
 
     @api_process
     async def update(self, request):
-        """Update homeassistant."""
+        """Update Home Assistant."""
         body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self._homeassistant.last_version)
+        version = body.get(ATTR_VERSION, self.sys_homeassistant.last_version)
 
-        if version == self._homeassistant.version:
-            raise RuntimeError("Version {} is already in use".format(version))
-
-        return await asyncio.shield(
-            self._homeassistant.update(version), loop=self._loop)
+        await asyncio.shield(self.sys_homeassistant.update(version))
 
     @api_process
     def stop(self, request):
-        """Stop homeassistant."""
-        return asyncio.shield(self._homeassistant.stop(), loop=self._loop)
+        """Stop Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.stop())
 
     @api_process
     def start(self, request):
-        """Start homeassistant."""
-        return asyncio.shield(self._homeassistant.start(), loop=self._loop)
+        """Start Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.start())
 
     @api_process
     def restart(self, request):
-        """Restart homeassistant."""
-        return asyncio.shield(self._homeassistant.restart(), loop=self._loop)
+        """Restart Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.restart())
 
     @api_process_raw(CONTENT_TYPE_BINARY)
     def logs(self, request):
-        """Return homeassistant docker logs."""
-        return self._homeassistant.logs()
+        """Return Home Assistant Docker logs."""
+        return self.sys_homeassistant.logs()
 
     @api_process
     async def check(self, request):
-        """Check config of homeassistant."""
-        result = await self._homeassistant.check_config()
+        """Check configuration of Home Assistant."""
+        result = await self.sys_homeassistant.check_config()
         if not result.valid:
-            raise RuntimeError(result.log)
-
-        return True
+            raise APIError(result.log)

hassio/api/host.py

@@ -1,92 +1,101 @@
-"""Init file for HassIO host rest api."""
+"""Init file for Hass.io host RESTful API."""
 import asyncio
 import logging
 
 import voluptuous as vol
 
-from .utils import api_process_hostcontrol, api_process, api_validate
+from .utils import api_process, api_validate
 from ..const import (
-    ATTR_VERSION, ATTR_LAST_VERSION, ATTR_TYPE, ATTR_HOSTNAME, ATTR_FEATURES,
-    ATTR_OS, ATTR_SERIAL, ATTR_INPUT, ATTR_DISK, ATTR_AUDIO, ATTR_AUDIO_INPUT,
-    ATTR_AUDIO_OUTPUT, ATTR_GPIO)
+    ATTR_HOSTNAME, ATTR_FEATURES, ATTR_KERNEL, ATTR_OPERATING_SYSTEM,
+    ATTR_CHASSIS, ATTR_DEPLOYMENT, ATTR_STATE, ATTR_NAME, ATTR_DESCRIPTON,
+    ATTR_SERVICES, ATTR_CPE)
 from ..coresys import CoreSysAttributes
-from ..validate import ALSA_CHANNEL
 
 _LOGGER = logging.getLogger(__name__)
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
-})
+SERVICE = 'service'
 
 SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_CHANNEL,
-    vol.Optional(ATTR_AUDIO_INPUT): ALSA_CHANNEL,
+    vol.Optional(ATTR_HOSTNAME): vol.Coerce(str),
 })
 
 
 class APIHost(CoreSysAttributes):
-    """Handle rest api for host functions."""
+    """Handle RESTful API for host functions."""
 
     @api_process
     async def info(self, request):
         """Return host information."""
         return {
-            ATTR_TYPE: self._host_control.type,
-            ATTR_VERSION: self._host_control.version,
-            ATTR_LAST_VERSION: self._host_control.last_version,
-            ATTR_FEATURES: self._host_control.features,
-            ATTR_HOSTNAME: self._host_control.hostname,
-            ATTR_OS: self._host_control.os_info,
+            ATTR_CHASSIS: self.sys_host.info.chassis,
+            ATTR_CPE: self.sys_host.info.cpe,
+            ATTR_FEATURES: self.sys_host.supperted_features,
+            ATTR_HOSTNAME: self.sys_host.info.hostname,
+            ATTR_OPERATING_SYSTEM: self.sys_host.info.operating_system,
+            ATTR_DEPLOYMENT: self.sys_host.info.deployment,
+            ATTR_KERNEL: self.sys_host.info.kernel,
         }
 
     @api_process
     async def options(self, request):
-        """Process host options."""
+        """Edit host settings."""
         body = await api_validate(SCHEMA_OPTIONS, request)
 
-        if ATTR_AUDIO_OUTPUT in body:
-            self._config.audio_output = body[ATTR_AUDIO_OUTPUT]
-        if ATTR_AUDIO_INPUT in body:
-            self._config.audio_input = body[ATTR_AUDIO_INPUT]
-
-        self._config.save_data()
-        return True
-
-    @api_process_hostcontrol
-    def reboot(self, request):
-        """Reboot host."""
-        return self._host_control.reboot()
-
-    @api_process_hostcontrol
-    def shutdown(self, request):
-        """Poweroff host."""
-        return self._host_control.shutdown()
-
-    @api_process_hostcontrol
-    async def reload(self, request):
-        """Reload host data."""
-        await self._host_control.load()
-        return True
-
-    @api_process_hostcontrol
-    async def update(self, request):
-        """Update host OS."""
-        body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self._host_control.last_version)
-
-        if version == self._host_control.version:
-            raise RuntimeError(f"Version {version} is already in use")
-
-        return await asyncio.shield(
-            self._host_control.update(version=version), loop=self._loop)
+        # hostname
+        if ATTR_HOSTNAME in body:
+            await asyncio.shield(
+                self.sys_host.control.set_hostname(body[ATTR_HOSTNAME]))
 
     @api_process
-    async def hardware(self, request):
-        """Return local hardware infos."""
+    def reboot(self, request):
+        """Reboot host."""
+        return asyncio.shield(self.sys_host.control.reboot())
+
+    @api_process
+    def shutdown(self, request):
+        """Poweroff host."""
+        return asyncio.shield(self.sys_host.control.shutdown())
+
+    @api_process
+    def reload(self, request):
+        """Reload host data."""
+        return asyncio.shield(self.sys_host.reload())
+
+    @api_process
+    async def services(self, request):
+        """Return list of available services."""
+        services = []
+        for unit in self.sys_host.services:
+            services.append({
+                ATTR_NAME: unit.name,
+                ATTR_DESCRIPTON: unit.description,
+                ATTR_STATE: unit.state,
+            })
+
         return {
-            ATTR_SERIAL: list(self._hardware.serial_devices),
-            ATTR_INPUT: list(self._hardware.input_devices),
-            ATTR_DISK: list(self._hardware.disk_devices),
-            ATTR_GPIO: list(self._hardware.gpio_devices),
-            ATTR_AUDIO: self._hardware.audio_devices,
+            ATTR_SERVICES: services
         }
+
+    @api_process
+    def service_start(self, request):
+        """Start a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.start(unit))
+
+    @api_process
+    def service_stop(self, request):
+        """Stop a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.stop(unit))
+
+    @api_process
+    def service_reload(self, request):
+        """Reload a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.reload(unit))
+
+    @api_process
+    def service_restart(self, request):
+        """Restart a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.restart(unit))

hassio/api/network.py

@@ -1,38 +0,0 @@
-"""Init file for HassIO network rest api."""
-import logging
-
-import voluptuous as vol
-
-from .utils import api_process, api_process_hostcontrol, api_validate
-from ..const import ATTR_HOSTNAME
-from ..coresys import CoreSysAttributes
-
-_LOGGER = logging.getLogger(__name__)
-
-
-SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_HOSTNAME): vol.Coerce(str),
-})
-
-
-class APINetwork(CoreSysAttributes):
-    """Handle rest api for network functions."""
-
-    @api_process
-    async def info(self, request):
-        """Show network settings."""
-        return {
-            ATTR_HOSTNAME: self._host_control.hostname,
-        }
-
-    @api_process_hostcontrol
-    async def options(self, request):
-        """Edit network settings."""
-        body = await api_validate(SCHEMA_OPTIONS, request)
-
-        # hostname
-        if ATTR_HOSTNAME in body:
-            if self._host_control.hostname != body[ATTR_HOSTNAME]:
-                await self._host_control.set_hostname(body[ATTR_HOSTNAME])
-
-        return True

hassio/api/panel/chunk.72a6da063fe4cb6308e8.js.LICENSE

@@ -0,0 +1,652 @@
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/

hassio/api/panel/chunk.7ee37c2565bcf2d88182.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[4],{102:function(n,r,t){"use strict";t.r(r),t.d(r,"marked",function(){return a}),t.d(r,"filterXSS",function(){return c});var e=t(91),i=t.n(e),o=t(93),u=t.n(o),a=i.a,c=u.a}}]);
+//# sourceMappingURL=chunk.7ee37c2565bcf2d88182.js.map

hassio/api/panel/chunk.7ee37c2565bcf2d88182.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///../src/resources/load_markdown.js"],"names":["__webpack_require__","r","__webpack_exports__","d","marked","filterXSS","marked__WEBPACK_IMPORTED_MODULE_0__","marked__WEBPACK_IMPORTED_MODULE_0___default","n","xss__WEBPACK_IMPORTED_MODULE_1__","xss__WEBPACK_IMPORTED_MODULE_1___default","a"],"mappings":"0FAAAA,EAAAC,EAAAC,GAAAF,EAAAG,EAAAD,EAAA,2BAAAE,IAAAJ,EAAAG,EAAAD,EAAA,8BAAAG,IAAA,IAAAC,EAAAN,EAAA,IAAAO,EAAAP,EAAAQ,EAAAF,GAAAG,EAAAT,EAAA,IAAAU,EAAAV,EAAAQ,EAAAC,GAGaL,EAASG,EAAAI,EACTN,EAAYK,EAAAC","file":"chunk.7ee37c2565bcf2d88182.js","sourcesContent":["import marked_ from 'marked';\nimport filterXSS_ from 'xss';\n\nexport const marked = marked_;\nexport const filterXSS = filterXSS_;\n"],"sourceRoot":""}

hassio/api/panel/chunk.a8fa5591357cce978816.js.LICENSE

@@ -0,0 +1,401 @@
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/

hassio/api/panel/entrypoint.js

@@ -0,0 +1,2 @@
+!function(e){function n(n){for(var t,o,a=n[0],i=n[1],u=0,l=[];u<a.length;u++)o=a[u],r[o]&&l.push(r[o][0]),r[o]=0;for(t in i)Object.prototype.hasOwnProperty.call(i,t)&&(e[t]=i[t]);for(c&&c(n);l.length;)l.shift()()}var t={},r={1:0};function o(n){if(t[n])return t[n].exports;var r=t[n]={i:n,l:!1,exports:{}};return e[n].call(r.exports,r,r.exports,o),r.l=!0,r.exports}o.e=function(e){var n=[],t=r[e];if(0!==t)if(t)n.push(t[2]);else{var a=new Promise(function(n,o){t=r[e]=[n,o]});n.push(t[2]=a);var i,u=document.getElementsByTagName("head")[0],c=document.createElement("script");c.charset="utf-8",c.timeout=120,o.nc&&c.setAttribute("nonce",o.nc),c.src=function(e){return o.p+"chunk."+{0:"a8fa5591357cce978816",2:"457ac71b0904d7243237",3:"57f5b43a82b988080555",4:"7ee37c2565bcf2d88182",5:"72a6da063fe4cb6308e8",6:"ad9001ac29bd3acbb520"}[e]+".js"}(e),i=function(n){c.onerror=c.onload=null,clearTimeout(l);var t=r[e];if(0!==t){if(t){var o=n&&("load"===n.type?"missing":n.type),a=n&&n.target&&n.target.src,i=new Error("Loading chunk "+e+" failed.\n("+o+": "+a+")");i.type=o,i.request=a,t[1](i)}r[e]=void 0}};var l=setTimeout(function(){i({type:"timeout",target:c})},12e4);c.onerror=c.onload=i,u.appendChild(c)}return Promise.all(n)},o.m=e,o.c=t,o.d=function(e,n,t){o.o(e,n)||Object.defineProperty(e,n,{enumerable:!0,get:t})},o.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},o.t=function(e,n){if(1&n&&(e=o(e)),8&n)return e;if(4&n&&"object"==typeof e&&e&&e.__esModule)return e;var t=Object.create(null);if(o.r(t),Object.defineProperty(t,"default",{enumerable:!0,value:e}),2&n&&"string"!=typeof e)for(var r in e)o.d(t,r,function(n){return e[n]}.bind(null,r));return t},o.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return o.d(n,"a",n),n},o.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},o.p="/api/hassio/app/",o.oe=function(e){throw console.error(e),e};var a=window.webpackJsonp=window.webpackJsonp||[],i=a.push.bind(a);a.push=n,a=a.slice();for(var u=0;u<a.length;u++)n(a[u]);var c=i;o(o.s=0)}([function(e,n,t){window.loadES5Adapter().then(function(){Promise.all([t.e(0),t.e(2)]).then(t.bind(null,2)),Promise.all([t.e(0),t.e(5),t.e(3)]).then(t.bind(null,1))})}]);
+//# sourceMappingURL=entrypoint.js.map

hassio/api/panel/index.html

@@ -11,27 +11,28 @@
         padding: 0;
       }
     </style>
+    <script src='/frontend_es5/custom-elements-es5-adapter.js'></script>
   </head>
   <body>
     <hassio-app></hassio-app>
     <script>
-      function addScript(src) {
-        var e = document.createElement('script');
-        e.src = src;
-        document.head.appendChild(e);
-      }
-      if (!window.parent.HASS_DEV) {
-        addScript('/frontend_es5/custom-elements-es5-adapter.js');
-      }
-      var webComponentsSupported = (
-        'customElements' in window &&
-        'import' in document.createElement('link') &&
-        'content' in document.createElement('template'));
-      if (!webComponentsSupported) {
-        addScript('/static/webcomponents-lite.js');
-      }
+    function addScript(src) {
+      var e = document.createElement('script');
+      e.src = src;
+      document.write(e.outerHTML);
+    }
+    var webComponentsSupported = (
+      'customElements' in window &&
+      'import' in document.createElement('link') &&
+      'content' in document.createElement('template'));
+    if (!webComponentsSupported) {
+      addScript('/static/webcomponents-lite.js');
+    }
     </script>
+    <!--
+      Disabled while we make Home Assistant able to serve the right files.
+      <script src="./app.js"></script>
+    -->
     <link rel='import' href='./hassio-app.html'>
-    <link rel='import' href='/static/mdi.html' async>
   </body>
 </html>

hassio/api/proxy.py

@@ -1,69 +1,74 @@
-"""Utils for HomeAssistant Proxy."""
+"""Utils for Home Assistant Proxy."""
 import asyncio
+from contextlib import asynccontextmanager
 import logging
 
 import aiohttp
 from aiohttp import web
-from aiohttp.web_exceptions import HTTPBadGateway, HTTPInternalServerError
-from aiohttp.hdrs import CONTENT_TYPE
+from aiohttp.web_exceptions import (
+    HTTPBadGateway, HTTPInternalServerError, HTTPUnauthorized)
+from aiohttp.hdrs import CONTENT_TYPE, AUTHORIZATION
 import async_timeout
 
 from ..const import HEADER_HA_ACCESS
 from ..coresys import CoreSysAttributes
+from ..exceptions import HomeAssistantAuthError, HomeAssistantAPIError
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class APIProxy(CoreSysAttributes):
-    """API Proxy for Home-Assistant."""
+    """API Proxy for Home Assistant."""
 
     def _check_access(self, request):
         """Check the Hass.io token."""
-        hassio_token = request.headers.get(HEADER_HA_ACCESS)
-        addon = self._addons.from_uuid(hassio_token)
+        if AUTHORIZATION in request.headers:
+            bearer = request.headers[AUTHORIZATION]
+            hassio_token = bearer.split(' ')[-1]
+        else:
+            hassio_token = request.headers.get(HEADER_HA_ACCESS)
 
+        addon = self.sys_addons.from_token(hassio_token)
         if not addon:
-            _LOGGER.warning("Unknown Home-Assistant API access!")
+            _LOGGER.warning("Unknown Home Assistant API access!")
+        elif not addon.access_homeassistant_api:
+            _LOGGER.warning("Not permitted API access: %s", addon.slug)
         else:
             _LOGGER.info("%s access from %s", request.path, addon.slug)
+            return
 
+        raise HTTPUnauthorized()
+
+    @asynccontextmanager
     async def _api_client(self, request, path, timeout=300):
-        """Return a client request with proxy origin for Home-Assistant."""
-        url = f"{self._homeassistant.api_url}/api/{path}"
-
+        """Return a client request with proxy origin for Home Assistant."""
         try:
-            data = None
-            headers = {}
-            method = getattr(self._websession_ssl, request.method.lower())
-            params = request.query or None
-
             # read data
-            with async_timeout.timeout(30, loop=self._loop):
+            with async_timeout.timeout(30):
                 data = await request.read()
 
             if data:
-                headers.update({CONTENT_TYPE: request.content_type})
+                content_type = request.content_type
+            else:
+                content_type = None
 
-            # need api password?
-            if self._homeassistant.api_password:
-                headers = {HEADER_HA_ACCESS: self._homeassistant.api_password}
-
-            # reset headers
-            if not headers:
-                headers = None
-
-            client = await method(
-                url, data=data, headers=headers, timeout=timeout,
-                params=params
-            )
-
-            return client
+            async with self.sys_homeassistant.make_request(
+                    request.method.lower(), f'api/{path}',
+                    content_type=content_type,
+                    data=data,
+                    timeout=timeout,
+            ) as resp:
+                yield resp
+                return
 
+        except HomeAssistantAuthError:
+            _LOGGER.error("Authenticate error on API for request %s", path)
+        except HomeAssistantAPIError:
+            _LOGGER.error("Error on API for request %s", path)
         except aiohttp.ClientError as err:
-            _LOGGER.error("Client error on API %s request %s.", path, err)
-
+            _LOGGER.error("Client error on API %s request %s", path, err)
         except asyncio.TimeoutError:
-            _LOGGER.error("Client timeout error on API request %s.", path)
+            _LOGGER.error("Client timeout error on API request %s", path)
 
         raise HTTPBadGateway()
 
@@ -71,76 +76,96 @@ class APIProxy(CoreSysAttributes):
         """Proxy HomeAssistant EventStream Requests."""
         self._check_access(request)
 
-        _LOGGER.info("Home-Assistant EventStream start")
-        client = await self._api_client(request, 'stream', timeout=None)
+        _LOGGER.info("Home Assistant EventStream start")
+        async with self._api_client(request, 'stream', timeout=None) as client:
+            response = web.StreamResponse()
+            response.content_type = request.headers.get(CONTENT_TYPE)
+            try:
+                await response.prepare(request)
+                while True:
+                    data = await client.content.read(10)
+                    if not data:
+                        break
+                    await response.write(data)
 
-        response = web.StreamResponse()
-        response.content_type = request.headers.get(CONTENT_TYPE)
-        try:
-            await response.prepare(request)
-            while True:
-                data = await client.content.read(10)
-                if not data:
-                    await response.write_eof()
-                    break
-                response.write(data)
+            except aiohttp.ClientError:
+                pass
 
-        except aiohttp.ClientError:
-            await response.write_eof()
+            finally:
+                client.close()
+                _LOGGER.info("Home Assistant EventStream close")
 
-        except asyncio.CancelledError:
-            pass
-
-        finally:
-            client.close()
-            _LOGGER.info("Home-Assistant EventStream close")
-
-        return response
+            return response
 
     async def api(self, request):
-        """Proxy HomeAssistant API Requests."""
+        """Proxy Home Assistant API Requests."""
         self._check_access(request)
 
         # Normal request
         path = request.match_info.get('path', '')
-        client = await self._api_client(request, path)
-
-        data = await client.read()
-        return web.Response(
-            body=data,
-            status=client.status,
-            content_type=client.content_type
-        )
+        async with self._api_client(request, path) as client:
+            data = await client.read()
+            return web.Response(
+                body=data,
+                status=client.status,
+                content_type=client.content_type
+            )
 
     async def _websocket_client(self):
-        """Initialize a websocket api connection."""
-        url = f"{self._homeassistant.api_url}/api/websocket"
+        """Initialize a WebSocket API connection."""
+        url = f"{self.sys_homeassistant.api_url}/api/websocket"
 
         try:
-            client = await self._websession_ssl.ws_connect(
+            client = await self.sys_websession_ssl.ws_connect(
                 url, heartbeat=60, verify_ssl=False)
 
-            # handle authentication
-            for _ in range(2):
-                data = await client.receive_json()
-                if data.get('type') == 'auth_ok':
-                    return client
-                elif data.get('type') == 'auth_required':
-                    await client.send_json({
-                        'type': 'auth',
-                        'api_password': self._homeassistant.api_password,
-                    })
+            # Handle authentication
+            data = await client.receive_json()
 
-            _LOGGER.error("Authentication to Home-Assistant websocket")
+            if data.get('type') == 'auth_ok':
+                return client
 
-        except (aiohttp.ClientError, RuntimeError) as err:
-            _LOGGER.error("Client error on websocket API %s.", err)
+            if data.get('type') != 'auth_required':
+                # Invalid protocol
+                _LOGGER.error(
+                    "Got unexpected response from HA WebSocket: %s", data)
+                raise HTTPBadGateway()
+
+            if self.sys_homeassistant.refresh_token:
+                await self.sys_homeassistant.ensure_access_token()
+                await client.send_json({
+                    'type': 'auth',
+                    'access_token': self.sys_homeassistant.access_token,
+                })
+            else:
+                await client.send_json({
+                    'type': 'auth',
+                    'api_password': self.sys_homeassistant.api_password,
+                })
+
+            data = await client.receive_json()
+
+            if data.get('type') == 'auth_ok':
+                return client
+
+            # Renew the Token is invalid
+            if (data.get('type') == 'invalid_auth' and
+                    self.sys_homeassistant.refresh_token):
+                self.sys_homeassistant.access_token = None
+                return await self._websocket_client()
+
+            raise HomeAssistantAuthError()
+
+        except (RuntimeError, ValueError) as err:
+            _LOGGER.error("Client error on WebSocket API %s.", err)
+        except HomeAssistantAuthError as err:
+            _LOGGER.error("Failed authentication to Home Assistant WebSocket")
 
         raise HTTPBadGateway()
 
     async def websocket(self, request):
-        """Initialize a websocket api connection."""
-        _LOGGER.info("Home-Assistant Websocket API request initialze")
+        """Initialize a WebSocket API connection."""
+        _LOGGER.info("Home Assistant WebSocket API request initialize")
 
         # init server
         server = web.WebSocketResponse(heartbeat=60)
@@ -150,22 +175,28 @@ class APIProxy(CoreSysAttributes):
         try:
             await server.send_json({
                 'type': 'auth_required',
-                'ha_version': self._homeassistant.version,
+                'ha_version': self.sys_homeassistant.version,
             })
 
             # Check API access
             response = await server.receive_json()
-            hassio_token = response.get('api_password')
-            addon = self._addons.from_uuid(hassio_token)
+            hassio_token = (response.get('api_password') or
+                            response.get('access_token'))
+            addon = self.sys_addons.from_token(hassio_token)
 
-            if not addon:
-                _LOGGER.warning("Unauthorized websocket access!")
-            else:
-                _LOGGER.info("Websocket access from %s", addon.slug)
+            if not addon or not addon.access_homeassistant_api:
+                _LOGGER.warning("Unauthorized WebSocket access!")
+                await server.send_json({
+                    'type': 'auth_invalid',
+                    'message': 'Invalid access',
+                })
+                return server
+
+            _LOGGER.info("WebSocket access from %s", addon.slug)
 
             await server.send_json({
                 'type': 'auth_ok',
-                'ha_version': self._homeassistant.version,
+                'ha_version': self.sys_homeassistant.version,
             })
         except (RuntimeError, ValueError) as err:
             _LOGGER.error("Can't initialize handshake: %s", err)
@@ -174,22 +205,22 @@ class APIProxy(CoreSysAttributes):
         # init connection to hass
         client = await self._websocket_client()
 
-        _LOGGER.info("Home-Assistant Websocket API request running")
+        _LOGGER.info("Home Assistant WebSocket API request running")
         try:
             client_read = None
             server_read = None
             while not server.closed and not client.closed:
                 if not client_read:
-                    client_read = asyncio.ensure_future(
-                        client.receive_str(), loop=self._loop)
+                    client_read = self.sys_create_task(
+                        client.receive_str())
                 if not server_read:
-                    server_read = asyncio.ensure_future(
-                        server.receive_str(), loop=self._loop)
+                    server_read = self.sys_create_task(
+                        server.receive_str())
 
                 # wait until data need to be processed
                 await asyncio.wait(
                     [client_read, server_read],
-                    loop=self._loop, return_when=asyncio.FIRST_COMPLETED
+                    return_when=asyncio.FIRST_COMPLETED
                 )
 
                 # server
@@ -208,7 +239,7 @@ class APIProxy(CoreSysAttributes):
             pass
 
         except RuntimeError as err:
-            _LOGGER.info("Home-Assistant Websocket API error: %s", err)
+            _LOGGER.info("Home Assistant WebSocket API error: %s", err)
 
         finally:
             if client_read:
@@ -220,5 +251,5 @@ class APIProxy(CoreSysAttributes):
             await client.close()
             await server.close()
 
-        _LOGGER.info("Home-Assistant Websocket API connection is closed")
+        _LOGGER.info("Home Assistant WebSocket API connection is closed")
         return server

hassio/api/security.py

@@ -3,48 +3,132 @@ import logging
 import re
 
 from aiohttp.web import middleware
-from aiohttp.web_exceptions import HTTPUnauthorized
+from aiohttp.web_exceptions import HTTPUnauthorized, HTTPForbidden
 
-from ..const import HEADER_TOKEN, REQUEST_FROM
+from ..const import (
+    HEADER_TOKEN, REQUEST_FROM, ROLE_ADMIN, ROLE_DEFAULT, ROLE_HOMEASSISTANT,
+    ROLE_MANAGER)
+from ..coresys import CoreSysAttributes
 
 _LOGGER = logging.getLogger(__name__)
 
-NO_SECURITY_CHECK = set((
-    re.compile(r"^/homeassistant/api/.*$"),
-    re.compile(r"^/homeassistant/websocket$"),
-    re.compile(r"^/supervisor/ping$"),
-))
+
+# Block Anytime
+BLACKLIST = re.compile(
+    r"^(?:"
+    r"|/homeassistant/api/hassio/.*"
+    r")$"
+)
+
+# Free to call or have own security concepts
+NO_SECURITY_CHECK = re.compile(
+    r"^(?:"
+    r"|/homeassistant/api/.*"
+    r"|/homeassistant/websocket"
+    r"|/supervisor/ping"
+    r")$"
+)
+
+# Can called by every add-on
+ADDONS_API_BYPASS = re.compile(
+    r"^(?:"
+    r"|/addons/self/(?!security|update)[^/]+"
+    r"|/version"
+    r"|/services.*"
+    r"|/discovery.*"
+    r")$"
+)
+
+# Policy role add-on API access
+ADDONS_ROLE_ACCESS = {
+    ROLE_DEFAULT: re.compile(
+        r"^(?:"
+        r"|/[^/]+/info"
+        r"|/addons"
+        r")$"
+    ),
+    ROLE_HOMEASSISTANT: re.compile(
+        r"^(?:"
+        r"|/homeassistant/.+"
+        r")$"
+    ),
+    ROLE_MANAGER: re.compile(
+        r"^(?:"
+        r"|/homeassistant/.+"
+        r"|/host/.+"
+        r"|/hardware/.+"
+        r"|/hassos/.+"
+        r"|/supervisor/.+"
+        r"|/addons(?:/[^/]+/(?!security).+)?"
+        r"|/snapshots.*"
+        r")$"
+    ),
+    ROLE_ADMIN: re.compile(
+        r".*"
+    ),
+}
 
 
-@middleware
-async def security_layer(request, handler):
-    """Check security access of this layer."""
-    coresys = request.app['coresys']
-    hassio_token = request.headers.get(HEADER_TOKEN)
+class SecurityMiddleware(CoreSysAttributes):
+    """Security middleware functions."""
 
-    # Ignore security check
-    for rule in NO_SECURITY_CHECK:
-        if rule.match(request.path):
+    def __init__(self, coresys):
+        """Initialize security middleware."""
+        self.coresys = coresys
+
+    @middleware
+    async def token_validation(self, request, handler):
+        """Check security access of this layer."""
+        request_from = None
+        hassio_token = request.headers.get(HEADER_TOKEN)
+
+        # Blacklist
+        if BLACKLIST.match(request.path):
+            _LOGGER.warning("%s is blacklisted!", request.path)
+            raise HTTPForbidden()
+
+        # Ignore security check
+        if NO_SECURITY_CHECK.match(request.path):
             _LOGGER.debug("Passthrough %s", request.path)
             return await handler(request)
 
-    # Need to be removed later
-    if not hassio_token:
-        _LOGGER.warning("Invalid token for access %s", request.path)
-        request[REQUEST_FROM] = 'UNKNOWN'
-        return await handler(request)
+        # Not token
+        if not hassio_token:
+            _LOGGER.warning("No API token provided for %s", request.path)
+            raise HTTPUnauthorized()
 
-    # Home-Assistant
-    if hassio_token == coresys.homeassistant.uuid:
-        _LOGGER.debug("%s access from Home-Assistant", request.path)
-        request[REQUEST_FROM] = 'homeassistant'
-        return await handler(request)
+        # Home-Assistant
+        # UUID check need removed with 131
+        if hassio_token in (self.sys_homeassistant.uuid,
+                            self.sys_homeassistant.hassio_token):
+            _LOGGER.debug("%s access from Home Assistant", request.path)
+            request_from = self.sys_homeassistant
 
-    # Add-on
-    addon = coresys.addons.from_uuid(hassio_token)
-    if addon:
-        _LOGGER.info("%s access from %s", request.path, addon.slug)
-        request[REQUEST_FROM] = addon.slug
-        return await handler(request)
+        # Host
+        if hassio_token == self.sys_machine_id:
+            _LOGGER.debug("%s access from Host", request.path)
+            request_from = self.sys_host
 
-    raise HTTPUnauthorized()
+        # Add-on
+        addon = None
+        if hassio_token and not request_from:
+            addon = self.sys_addons.from_token(hassio_token)
+
+        # Check Add-on API access
+        if addon and ADDONS_API_BYPASS.match(request.path):
+            _LOGGER.debug("Passthrough %s from %s", request.path, addon.slug)
+            request_from = addon
+        elif addon and addon.access_hassio_api:
+            # Check Role
+            if ADDONS_ROLE_ACCESS[addon.hassio_role].match(request.path):
+                _LOGGER.info("%s access from %s", request.path, addon.slug)
+                request_from = addon
+            else:
+                _LOGGER.warning("%s no role for %s", request.path, addon.slug)
+
+        if request_from:
+            request[REQUEST_FROM] = request_from
+            return await handler(request)
+
+        _LOGGER.error("Invalid token for access %s", request.path)
+        raise HTTPForbidden()

hassio/api/services.py

@@ -1,19 +1,21 @@
-"""Init file for HassIO network rest api."""
+"""Init file for Hass.io network RESTful API."""
 
 from .utils import api_process, api_validate
 from ..const import (
-    ATTR_AVAILABLE, ATTR_PROVIDER, ATTR_SLUG, ATTR_SERVICES, REQUEST_FROM)
+    ATTR_AVAILABLE, ATTR_PROVIDERS, ATTR_SLUG, ATTR_SERVICES, REQUEST_FROM,
+    PROVIDE_SERVICE)
 from ..coresys import CoreSysAttributes
+from ..exceptions import APIError, APIForbidden
 
 
 class APIServices(CoreSysAttributes):
-    """Handle rest api for services functions."""
+    """Handle RESTful API for services functions."""
 
     def _extract_service(self, request):
-        """Return service and if not exists trow a exception."""
-        service = self._services.get(request.match_info.get('service'))
+        """Return service, throw an exception if it doesn't exist."""
+        service = self.sys_services.get(request.match_info.get('service'))
         if not service:
-            raise RuntimeError("Service not exists")
+            raise APIError("Service does not exist")
 
         return service
 
@@ -21,11 +23,11 @@ class APIServices(CoreSysAttributes):
     async def list(self, request):
         """Show register services."""
         services = []
-        for service in self._services.list_services:
+        for service in self.sys_services.list_services:
             services.append({
                 ATTR_SLUG: service.slug,
                 ATTR_AVAILABLE: service.enabled,
-                ATTR_PROVIDER: service.provider,
+                ATTR_PROVIDERS: service.providers,
             })
 
         return {ATTR_SERVICES: services}
@@ -35,21 +37,39 @@ class APIServices(CoreSysAttributes):
         """Write data into a service."""
         service = self._extract_service(request)
         body = await api_validate(service.schema, request)
+        addon = request[REQUEST_FROM]
 
-        return service.set_service_data(request[REQUEST_FROM], body)
+        _check_access(request, service.slug)
+        service.set_service_data(addon, body)
 
     @api_process
     async def get_service(self, request):
         """Read data into a service."""
         service = self._extract_service(request)
 
-        return {
-            ATTR_AVAILABLE: service.enabled,
-            service.slug: service.get_service_data(),
-        }
+        # Access
+        _check_access(request, service.slug)
+
+        if not service.enabled:
+            raise APIError("Service not enabled")
+        return service.get_service_data()
 
     @api_process
     async def del_service(self, request):
         """Delete data into a service."""
         service = self._extract_service(request)
-        return service.del_service_data(request[REQUEST_FROM])
+        addon = request[REQUEST_FROM]
+
+        # Access
+        _check_access(request, service.slug, True)
+        service.del_service_data(addon)
+
+
+def _check_access(request, service, provide=False):
+    """Raise error if the rights are wrong."""
+    addon = request[REQUEST_FROM]
+    if not addon.services_role.get(service):
+        raise APIForbidden(f"No access to {service} service!")
+
+    if provide and addon.services_role.get(service) != PROVIDE_SERVICE:
+        raise APIForbidden(f"No access to write {service} service!")

hassio/api/snapshots.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO snapshot rest api."""
+"""Init file for Hass.io snapshot RESTful API."""
 import asyncio
 import logging
 from pathlib import Path
@@ -14,6 +14,7 @@ from ..const import (
     ATTR_HOMEASSISTANT, ATTR_VERSION, ATTR_SIZE, ATTR_FOLDERS, ATTR_TYPE,
     ATTR_SNAPSHOTS, ATTR_PASSWORD, ATTR_PROTECTED, CONTENT_TYPE_TAR)
 from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -46,20 +47,20 @@ SCHEMA_SNAPSHOT_PARTIAL = SCHEMA_SNAPSHOT_FULL.extend({
 
 
 class APISnapshots(CoreSysAttributes):
-    """Handle rest api for snapshot functions."""
+    """Handle RESTful API for snapshot functions."""
 
     def _extract_snapshot(self, request):
-        """Return addon and if not exists trow a exception."""
-        snapshot = self._snapshots.get(request.match_info.get('snapshot'))
+        """Return snapshot, throw an exception if it doesn't exist."""
+        snapshot = self.sys_snapshots.get(request.match_info.get('snapshot'))
         if not snapshot:
-            raise RuntimeError("Snapshot not exists")
+            raise APIError("Snapshot does not exist")
         return snapshot
 
     @api_process
     async def list(self, request):
         """Return snapshot list."""
         data_snapshots = []
-        for snapshot in self._snapshots.list_snapshots:
+        for snapshot in self.sys_snapshots.list_snapshots:
             data_snapshots.append({
                 ATTR_SLUG: snapshot.slug,
                 ATTR_NAME: snapshot.name,
@@ -75,7 +76,7 @@ class APISnapshots(CoreSysAttributes):
     @api_process
     async def reload(self, request):
         """Reload snapshot list."""
-        await asyncio.shield(self._snapshots.reload(), loop=self._loop)
+        await asyncio.shield(self.sys_snapshots.reload())
         return True
 
     @api_process
@@ -110,7 +111,7 @@ class APISnapshots(CoreSysAttributes):
         """Full-Snapshot a snapshot."""
         body = await api_validate(SCHEMA_SNAPSHOT_FULL, request)
         snapshot = await asyncio.shield(
-            self._snapshots.do_snapshot_full(**body), loop=self._loop)
+            self.sys_snapshots.do_snapshot_full(**body))
 
         if snapshot:
             return {ATTR_SLUG: snapshot.slug}
@@ -121,7 +122,7 @@ class APISnapshots(CoreSysAttributes):
         """Partial-Snapshot a snapshot."""
         body = await api_validate(SCHEMA_SNAPSHOT_PARTIAL, request)
         snapshot = await asyncio.shield(
-            self._snapshots.do_snapshot_partial(**body), loop=self._loop)
+            self.sys_snapshots.do_snapshot_partial(**body))
 
         if snapshot:
             return {ATTR_SLUG: snapshot.slug}
@@ -134,9 +135,7 @@ class APISnapshots(CoreSysAttributes):
         body = await api_validate(SCHEMA_RESTORE_FULL, request)
 
         return await asyncio.shield(
-            self._snapshots.do_restore_full(snapshot, **body),
-            loop=self._loop
-        )
+            self.sys_snapshots.do_restore_full(snapshot, **body))
 
     @api_process
     async def restore_partial(self, request):
@@ -145,15 +144,13 @@ class APISnapshots(CoreSysAttributes):
         body = await api_validate(SCHEMA_RESTORE_PARTIAL, request)
 
         return await asyncio.shield(
-            self._snapshots.do_restore_partial(snapshot, **body),
-            loop=self._loop
-        )
+            self.sys_snapshots.do_restore_partial(snapshot, **body))
 
     @api_process
     async def remove(self, request):
         """Remove a snapshot."""
         snapshot = self._extract_snapshot(request)
-        return self._snapshots.remove(snapshot)
+        return self.sys_snapshots.remove(snapshot)
 
     async def download(self, request):
         """Download a snapshot file."""
@@ -167,7 +164,7 @@ class APISnapshots(CoreSysAttributes):
     @api_process
     async def upload(self, request):
         """Upload a snapshot file."""
-        with TemporaryDirectory(dir=str(self._config.path_tmp)) as temp_dir:
+        with TemporaryDirectory(dir=str(self.sys_config.path_tmp)) as temp_dir:
             tar_file = Path(temp_dir, f"snapshot.tar")
 
             try:
@@ -183,7 +180,7 @@ class APISnapshots(CoreSysAttributes):
                 return False
 
             snapshot = await asyncio.shield(
-                self._snapshots.import_snapshot(tar_file), loop=self._loop)
+                self.sys_snapshots.import_snapshot(tar_file))
 
             if snapshot:
                 return {ATTR_SLUG: snapshot.slug}

hassio/api/supervisor.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO supervisor rest api."""
+"""Init file for Hass.io Supervisor RESTful API."""
 import asyncio
 import logging
 
@@ -6,20 +6,21 @@ import voluptuous as vol
 
 from .utils import api_process, api_process_raw, api_validate
 from ..const import (
-    ATTR_ADDONS, ATTR_VERSION, ATTR_LAST_VERSION, ATTR_BETA_CHANNEL, ATTR_ARCH,
+    ATTR_ADDONS, ATTR_VERSION, ATTR_LAST_VERSION, ATTR_CHANNEL, ATTR_ARCH,
     HASSIO_VERSION, ATTR_ADDONS_REPOSITORIES, ATTR_LOGO, ATTR_REPOSITORY,
     ATTR_DESCRIPTON, ATTR_NAME, ATTR_SLUG, ATTR_INSTALLED, ATTR_TIMEZONE,
     ATTR_STATE, ATTR_WAIT_BOOT, ATTR_CPU_PERCENT, ATTR_MEMORY_USAGE,
     ATTR_MEMORY_LIMIT, ATTR_NETWORK_RX, ATTR_NETWORK_TX, ATTR_BLK_READ,
     ATTR_BLK_WRITE, CONTENT_TYPE_BINARY, ATTR_ICON)
 from ..coresys import CoreSysAttributes
-from ..validate import validate_timezone, WAIT_BOOT, REPOSITORIES
+from ..validate import WAIT_BOOT, REPOSITORIES, CHANNELS
+from ..exceptions import APIError
+from ..utils.validate import validate_timezone
 
 _LOGGER = logging.getLogger(__name__)
 
 SCHEMA_OPTIONS = vol.Schema({
-    # pylint: disable=no-value-for-parameter
-    vol.Optional(ATTR_BETA_CHANNEL): vol.Boolean(),
+    vol.Optional(ATTR_CHANNEL): CHANNELS,
     vol.Optional(ATTR_ADDONS_REPOSITORIES): REPOSITORIES,
     vol.Optional(ATTR_TIMEZONE): validate_timezone,
     vol.Optional(ATTR_WAIT_BOOT): WAIT_BOOT,
@@ -31,18 +32,18 @@ SCHEMA_VERSION = vol.Schema({
 
 
 class APISupervisor(CoreSysAttributes):
-    """Handle rest api for supervisor functions."""
+    """Handle RESTful API for Supervisor functions."""
 
     @api_process
     async def ping(self, request):
-        """Return ok for signal that the api is ready."""
+        """Return ok for signal that the API is ready."""
         return True
 
     @api_process
     async def info(self, request):
         """Return host information."""
         list_addons = []
-        for addon in self._addons.list_addons:
+        for addon in self.sys_addons.list_addons:
             if addon.is_installed:
                 list_addons.append({
                     ATTR_NAME: addon.name,
@@ -58,43 +59,43 @@ class APISupervisor(CoreSysAttributes):
 
         return {
             ATTR_VERSION: HASSIO_VERSION,
-            ATTR_LAST_VERSION: self._updater.version_hassio,
-            ATTR_BETA_CHANNEL: self._updater.beta_channel,
-            ATTR_ARCH: self._arch,
-            ATTR_WAIT_BOOT: self._config.wait_boot,
-            ATTR_TIMEZONE: self._config.timezone,
+            ATTR_LAST_VERSION: self.sys_updater.version_hassio,
+            ATTR_CHANNEL: self.sys_updater.channel,
+            ATTR_ARCH: self.sys_arch,
+            ATTR_WAIT_BOOT: self.sys_config.wait_boot,
+            ATTR_TIMEZONE: self.sys_config.timezone,
             ATTR_ADDONS: list_addons,
-            ATTR_ADDONS_REPOSITORIES: self._config.addons_repositories,
+            ATTR_ADDONS_REPOSITORIES: self.sys_config.addons_repositories,
         }
 
     @api_process
     async def options(self, request):
-        """Set supervisor options."""
+        """Set Supervisor options."""
         body = await api_validate(SCHEMA_OPTIONS, request)
 
-        if ATTR_BETA_CHANNEL in body:
-            self._updater.beta_channel = body[ATTR_BETA_CHANNEL]
+        if ATTR_CHANNEL in body:
+            self.sys_updater.channel = body[ATTR_CHANNEL]
 
         if ATTR_TIMEZONE in body:
-            self._config.timezone = body[ATTR_TIMEZONE]
+            self.sys_config.timezone = body[ATTR_TIMEZONE]
 
         if ATTR_WAIT_BOOT in body:
-            self._config.wait_boot = body[ATTR_WAIT_BOOT]
+            self.sys_config.wait_boot = body[ATTR_WAIT_BOOT]
 
         if ATTR_ADDONS_REPOSITORIES in body:
             new = set(body[ATTR_ADDONS_REPOSITORIES])
-            await asyncio.shield(self._addons.load_repositories(new))
+            await asyncio.shield(self.sys_addons.load_repositories(new))
 
-        self._updater.save_data()
-        self._config.save_data()
+        self.sys_updater.save_data()
+        self.sys_config.save_data()
         return True
 
     @api_process
     async def stats(self, request):
         """Return resource information."""
-        stats = await self._supervisor.stats()
+        stats = await self.sys_supervisor.stats()
         if not stats:
-            raise RuntimeError("No stats available")
+            raise APIError("No stats available")
 
         return {
             ATTR_CPU_PERCENT: stats.cpu_percent,
@@ -108,32 +109,32 @@ class APISupervisor(CoreSysAttributes):
 
     @api_process
     async def update(self, request):
-        """Update supervisor OS."""
+        """Update Supervisor OS."""
         body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self._updater.version_hassio)
+        version = body.get(ATTR_VERSION, self.sys_updater.version_hassio)
 
-        if version == self._supervisor.version:
-            raise RuntimeError("Version {} is already in use".format(version))
+        if version == self.sys_supervisor.version:
+            raise APIError("Version {} is already in use".format(version))
 
         return await asyncio.shield(
-            self._supervisor.update(version), loop=self._loop)
+            self.sys_supervisor.update(version))
 
     @api_process
     async def reload(self, request):
-        """Reload addons, config ect."""
+        """Reload add-ons, configuration, etc."""
         tasks = [
-            self._updater.reload(),
+            self.sys_updater.reload(),
         ]
         results, _ = await asyncio.shield(
-            asyncio.wait(tasks, loop=self._loop), loop=self._loop)
+            asyncio.wait(tasks))
 
         for result in results:
             if result.exception() is not None:
-                raise RuntimeError("Some reload task fails!")
+                raise APIError("Some reload task fails!")
 
         return True
 
     @api_process_raw(CONTENT_TYPE_BINARY)
     def logs(self, request):
-        """Return supervisor docker logs."""
-        return self._supervisor.logs()
+        """Return supervisor Docker logs."""
+        return self.sys_supervisor.logs()

hassio/api/utils.py

@@ -1,16 +1,15 @@
-"""Init file for HassIO util for rest api."""
+"""Init file for Hass.io util for RESTful API."""
 import json
-import hashlib
 import logging
 
 from aiohttp import web
-from aiohttp.web_exceptions import HTTPServiceUnavailable
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
 from ..const import (
     JSON_RESULT, JSON_DATA, JSON_MESSAGE, RESULT_OK, RESULT_ERROR,
     CONTENT_TYPE_BINARY)
+from ..exceptions import HassioError, APIError, APIForbidden
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,53 +21,31 @@ def json_loads(data):
     try:
         return json.loads(data)
     except json.JSONDecodeError:
-        raise RuntimeError("Invalid json")
+        raise APIError("Invalid json")
 
 
 def api_process(method):
     """Wrap function with true/false calls to rest api."""
     async def wrap_api(api, *args, **kwargs):
-        """Return api information."""
+        """Return API information."""
         try:
             answer = await method(api, *args, **kwargs)
-        except RuntimeError as err:
+        except (APIError, APIForbidden) as err:
             return api_return_error(message=str(err))
+        except HassioError:
+            return api_return_error(message="Unknown Error, see logs")
 
         if isinstance(answer, dict):
             return api_return_ok(data=answer)
         if isinstance(answer, web.Response):
             return answer
-        elif answer:
-            return api_return_ok()
-        return api_return_error()
+        elif isinstance(answer, bool) and not answer:
+            return api_return_error()
+        return api_return_ok()
 
     return wrap_api
 
 
-def api_process_hostcontrol(method):
-    """Wrap HostControl calls to rest api."""
-    async def wrap_hostcontrol(api, *args, **kwargs):
-        """Return host information."""
-        # pylint: disable=protected-access
-        if not api._host_control.active:
-            raise HTTPServiceUnavailable()
-
-        try:
-            answer = await method(api, *args, **kwargs)
-        except RuntimeError as err:
-            return api_return_error(message=str(err))
-
-        if isinstance(answer, dict):
-            return api_return_ok(data=answer)
-        elif answer is None:
-            return api_return_error("Function is not supported")
-        elif answer:
-            return api_return_ok()
-        return api_return_error()
-
-    return wrap_hostcontrol
-
-
 def api_process_raw(content):
     """Wrap content_type into function."""
     def wrap_method(method):
@@ -78,9 +55,12 @@ def api_process_raw(content):
             try:
                 msg_data = await method(api, *args, **kwargs)
                 msg_type = content
-            except RuntimeError as err:
+            except (APIError, APIForbidden) as err:
                 msg_data = str(err).encode()
                 msg_type = CONTENT_TYPE_BINARY
+            except HassioError:
+                msg_data = b''
+                msg_type = CONTENT_TYPE_BINARY
 
             return web.Response(body=msg_data, content_type=msg_type)
 
@@ -89,7 +69,7 @@ def api_process_raw(content):
 
 
 def api_return_error(message=None):
-    """Return a API error message."""
+    """Return an API error message."""
     return web.json_response({
         JSON_RESULT: RESULT_ERROR,
         JSON_MESSAGE: message,
@@ -97,7 +77,7 @@ def api_return_error(message=None):
 
 
 def api_return_ok(data=None):
-    """Return a API ok answer."""
+    """Return an API ok answer."""
     return web.json_response({
         JSON_RESULT: RESULT_OK,
         JSON_DATA: data or {},
@@ -110,12 +90,6 @@ async def api_validate(schema, request):
     try:
         data = schema(data)
     except vol.Invalid as ex:
-        raise RuntimeError(humanize_error(data, ex)) from None
+        raise APIError(humanize_error(data, ex)) from None
 
     return data
-
-
-def hash_password(password):
-    """Hash and salt our passwords."""
-    key = ")*()*SALT_HASSIO2123{}6554547485HSKA!!*JSLAfdasda$".format(password)
-    return hashlib.sha256(key.encode()).hexdigest()

hassio/api/version.py

@@ -0,0 +1,26 @@
+"""Init file for Hass.io version RESTful API."""
+import logging
+
+from .utils import api_process
+from ..const import (
+    ATTR_HOMEASSISTANT, ATTR_SUPERVISOR, ATTR_MACHINE, ATTR_ARCH, ATTR_HASSOS,
+    ATTR_CHANNEL)
+from ..coresys import CoreSysAttributes
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIVersion(CoreSysAttributes):
+    """Handle RESTful API for version functions."""
+
+    @api_process
+    async def info(self, request):
+        """Show version info."""
+        return {
+            ATTR_SUPERVISOR: self.sys_supervisor.version,
+            ATTR_HOMEASSISTANT: self.sys_homeassistant.version,
+            ATTR_HASSOS: self.sys_hassos.version,
+            ATTR_MACHINE: self.sys_machine,
+            ATTR_ARCH: self.sys_arch,
+            ATTR_CHANNEL: self.sys_updater.channel,
+        }

hassio/bootstrap.py

@@ -1,4 +1,4 @@
-"""Bootstrap HassIO."""
+"""Bootstrap Hass.io."""
 import logging
 import os
 import signal
@@ -7,6 +7,7 @@ from pathlib import Path
 
 from colorlog import ColoredFormatter
 
+from .core import HassIO
 from .addons import AddonManager
 from .api import RestAPI
 from .const import SOCKET_DOCKER
@@ -17,76 +18,101 @@ from .snapshots import SnapshotManager
 from .tasks import Tasks
 from .updater import Updater
 from .services import ServiceManager
+from .discovery import Discovery
+from .host import HostManager
+from .dbus import DBusManager
+from .hassos import HassOS
 
 _LOGGER = logging.getLogger(__name__)
 
+ENV_SHARE = 'SUPERVISOR_SHARE'
+ENV_NAME = 'SUPERVISOR_NAME'
+ENV_REPO = 'HOMEASSISTANT_REPOSITORY'
+
+MACHINE_ID = Path('/etc/machine-id')
+
 
 def initialize_coresys(loop):
     """Initialize HassIO coresys/objects."""
     coresys = CoreSys(loop)
 
     # Initialize core objects
+    coresys.core = HassIO(coresys)
     coresys.updater = Updater(coresys)
     coresys.api = RestAPI(coresys)
     coresys.supervisor = Supervisor(coresys)
     coresys.homeassistant = HomeAssistant(coresys)
     coresys.addons = AddonManager(coresys)
     coresys.snapshots = SnapshotManager(coresys)
+    coresys.host = HostManager(coresys)
     coresys.tasks = Tasks(coresys)
     coresys.services = ServiceManager(coresys)
+    coresys.discovery = Discovery(coresys)
+    coresys.dbus = DBusManager(coresys)
+    coresys.hassos = HassOS(coresys)
 
     # bootstrap config
     initialize_system_data(coresys)
 
+    # Set Machine/Host ID
+    if MACHINE_ID.exists():
+        coresys.machine_id = MACHINE_ID.read_text().strip()
+
     return coresys
 
 
 def initialize_system_data(coresys):
-    """Setup default config and create folders."""
+    """Set up the default configuration and create folders."""
     config = coresys.config
 
-    # homeassistant config folder
-    if not config.path_config.is_dir():
+    # Home Assistant configuration folder
+    if not config.path_homeassistant.is_dir():
         _LOGGER.info(
-            "Create Home-Assistant config folder %s", config.path_config)
-        config.path_config.mkdir()
+            "Create Home Assistant configuration folder %s",
+            config.path_homeassistant)
+        config.path_homeassistant.mkdir()
 
     # hassio ssl folder
     if not config.path_ssl.is_dir():
-        _LOGGER.info("Create hassio ssl folder %s", config.path_ssl)
+        _LOGGER.info("Create Hass.io SSL/TLS folder %s", config.path_ssl)
         config.path_ssl.mkdir()
 
     # hassio addon data folder
     if not config.path_addons_data.is_dir():
         _LOGGER.info(
-            "Create hassio addon data folder %s", config.path_addons_data)
+            "Create Hass.io Add-on data folder %s", config.path_addons_data)
         config.path_addons_data.mkdir(parents=True)
 
     if not config.path_addons_local.is_dir():
-        _LOGGER.info("Create hassio addon local repository folder %s",
+        _LOGGER.info("Create Hass.io Add-on local repository folder %s",
                      config.path_addons_local)
         config.path_addons_local.mkdir(parents=True)
 
     if not config.path_addons_git.is_dir():
-        _LOGGER.info("Create hassio addon git repositories folder %s",
+        _LOGGER.info("Create Hass.io Add-on git repositories folder %s",
                      config.path_addons_git)
         config.path_addons_git.mkdir(parents=True)
 
     # hassio tmp folder
     if not config.path_tmp.is_dir():
-        _LOGGER.info("Create hassio temp folder %s", config.path_tmp)
+        _LOGGER.info("Create Hass.io temp folder %s", config.path_tmp)
         config.path_tmp.mkdir(parents=True)
 
     # hassio backup folder
     if not config.path_backup.is_dir():
-        _LOGGER.info("Create hassio backup folder %s", config.path_backup)
+        _LOGGER.info("Create Hass.io backup folder %s", config.path_backup)
         config.path_backup.mkdir()
 
     # share folder
     if not config.path_share.is_dir():
-        _LOGGER.info("Create hassio share folder %s", config.path_share)
+        _LOGGER.info("Create Hass.io share folder %s", config.path_share)
         config.path_share.mkdir()
 
+    # apparmor folder
+    if not config.path_apparmor.is_dir():
+        _LOGGER.info("Create Hass.io Apparmor folder %s", config.path_apparmor)
+        config.path_apparmor.mkdir()
+
     return config
 
 
@@ -100,7 +126,7 @@ def migrate_system_env(coresys):
         try:
             old_build.rmdir()
         except OSError:
-            _LOGGER.warning("Can't cleanup old addons build dir.")
+            _LOGGER.warning("Can't cleanup old Add-on build directory")
 
 
 def initialize_logging():
@@ -131,8 +157,7 @@ def initialize_logging():
 def check_environment():
     """Check if all environment are exists."""
     # check environment variables
-    for key in ('SUPERVISOR_SHARE', 'SUPERVISOR_NAME',
-                'HOMEASSISTANT_REPOSITORY'):
+    for key in (ENV_SHARE, ENV_NAME, ENV_REPO):
         try:
             os.environ[key]
         except KeyError:
@@ -141,19 +166,24 @@ def check_environment():
 
     # check docker socket
     if not SOCKET_DOCKER.is_socket():
-        _LOGGER.fatal("Can't find docker socket!")
+        _LOGGER.fatal("Can't find Docker socket!")
         return False
 
     # check socat exec
     if not shutil.which('socat'):
-        _LOGGER.fatal("Can0t find socat program!")
+        _LOGGER.fatal("Can't find socat!")
+        return False
+
+    # check socat exec
+    if not shutil.which('gdbus'):
+        _LOGGER.fatal("Can't find gdbus!")
         return False
 
     return True
 
 
 def reg_signal(loop):
-    """Register SIGTERM, SIGKILL to stop system."""
+    """Register SIGTERM and SIGKILL to stop system."""
     try:
         loop.add_signal_handler(
             signal.SIGTERM, lambda: loop.call_soon(loop.stop))

hassio/config.py

@@ -1,19 +1,22 @@
-"""Bootstrap HassIO."""
+"""Bootstrap Hass.io."""
 from datetime import datetime
 import logging
 import os
+import re
 from pathlib import Path, PurePath
 
+import pytz
+
 from .const import (
     FILE_HASSIO_CONFIG, HASSIO_DATA, ATTR_TIMEZONE, ATTR_ADDONS_CUSTOM_LIST,
-    ATTR_AUDIO_INPUT, ATTR_AUDIO_OUTPUT, ATTR_LAST_BOOT, ATTR_WAIT_BOOT)
+    ATTR_LAST_BOOT, ATTR_WAIT_BOOT)
 from .utils.dt import parse_datetime
 from .utils.json import JsonConfig
 from .validate import SCHEMA_HASSIO_CONFIG
 
 _LOGGER = logging.getLogger(__name__)
 
-HOMEASSISTANT_CONFIG = PurePath("homeassistant")
+HOMEASSISTANT_CONFIG = PurePath('homeassistant')
 
 HASSIO_SSL = PurePath("ssl")
 
@@ -25,9 +28,12 @@ ADDONS_DATA = PurePath("addons/data")
 BACKUP_DATA = PurePath("backup")
 SHARE_DATA = PurePath("share")
 TMP_DATA = PurePath("tmp")
+APPARMOR_DATA = PurePath("apparmor")
 
 DEFAULT_BOOT_TIME = datetime.utcfromtimestamp(0).isoformat()
 
+RE_TIMEZONE = re.compile(r"time_zone: (?P<timezone>[\w/\-+]+)")
+
 
 class CoreConfig(JsonConfig):
     """Hold all core config data."""
@@ -39,7 +45,21 @@ class CoreConfig(JsonConfig):
     @property
     def timezone(self):
         """Return system timezone."""
-        return self._data[ATTR_TIMEZONE]
+        config_file = Path(self.path_homeassistant, 'configuration.yaml')
+        try:
+            assert config_file.exists()
+            configuration = config_file.read_text()
+
+            data = RE_TIMEZONE.search(configuration)
+            assert data
+
+            timezone = data.group('timezone')
+            pytz.timezone(timezone)
+        except (pytz.exceptions.UnknownTimeZoneError, OSError, AssertionError):
+            _LOGGER.debug("Can't parse Home Assistant timezone")
+            return self._data[ATTR_TIMEZONE]
+
+        return timezone
 
     @timezone.setter
     def timezone(self, value):
@@ -73,27 +93,27 @@ class CoreConfig(JsonConfig):
 
     @property
     def path_hassio(self):
-        """Return hassio data path."""
+        """Return Hass.io data path."""
         return HASSIO_DATA
 
     @property
     def path_extern_hassio(self):
-        """Return hassio data path extern for docker."""
+        """Return Hass.io data path external for Docker."""
         return PurePath(os.environ['SUPERVISOR_SHARE'])
 
     @property
-    def path_extern_config(self):
-        """Return config path extern for docker."""
+    def path_extern_homeassistant(self):
+        """Return config path external for Docker."""
         return str(PurePath(self.path_extern_hassio, HOMEASSISTANT_CONFIG))
 
     @property
-    def path_config(self):
+    def path_homeassistant(self):
         """Return config path inside supervisor."""
         return Path(HASSIO_DATA, HOMEASSISTANT_CONFIG)
 
     @property
     def path_extern_ssl(self):
-        """Return SSL path extern for docker."""
+        """Return SSL path external for Docker."""
         return str(PurePath(self.path_extern_hassio, HASSIO_SSL))
 
     @property
@@ -103,39 +123,44 @@ class CoreConfig(JsonConfig):
 
     @property
     def path_addons_core(self):
-        """Return git path for core addons."""
+        """Return git path for core Add-ons."""
         return Path(HASSIO_DATA, ADDONS_CORE)
 
     @property
     def path_addons_git(self):
-        """Return path for git addons."""
+        """Return path for Git Add-on."""
         return Path(HASSIO_DATA, ADDONS_GIT)
 
     @property
     def path_addons_local(self):
-        """Return path for customs addons."""
+        """Return path for custom Add-ons."""
         return Path(HASSIO_DATA, ADDONS_LOCAL)
 
     @property
     def path_extern_addons_local(self):
-        """Return path for customs addons."""
+        """Return path for custom Add-ons."""
         return PurePath(self.path_extern_hassio, ADDONS_LOCAL)
 
     @property
     def path_addons_data(self):
-        """Return root addon data folder."""
+        """Return root Add-on data folder."""
         return Path(HASSIO_DATA, ADDONS_DATA)
 
     @property
     def path_extern_addons_data(self):
-        """Return root addon data folder extern for docker."""
+        """Return root add-on data folder external for Docker."""
         return PurePath(self.path_extern_hassio, ADDONS_DATA)
 
     @property
     def path_tmp(self):
-        """Return hass.io temp folder."""
+        """Return Hass.io temp folder."""
         return Path(HASSIO_DATA, TMP_DATA)
 
+    @property
+    def path_extern_tmp(self):
+        """Return Hass.io temp folder for Docker."""
+        return PurePath(self.path_extern_hassio, TMP_DATA)
+
     @property
     def path_backup(self):
         """Return root backup data folder."""
@@ -143,7 +168,7 @@ class CoreConfig(JsonConfig):
 
     @property
     def path_extern_backup(self):
-        """Return root backup data folder extern for docker."""
+        """Return root backup data folder external for Docker."""
         return PurePath(self.path_extern_hassio, BACKUP_DATA)
 
     @property
@@ -151,14 +176,19 @@ class CoreConfig(JsonConfig):
         """Return root share data folder."""
         return Path(HASSIO_DATA, SHARE_DATA)
 
+    @property
+    def path_apparmor(self):
+        """Return root Apparmor profile folder."""
+        return Path(HASSIO_DATA, APPARMOR_DATA)
+
     @property
     def path_extern_share(self):
-        """Return root share data folder extern for docker."""
+        """Return root share data folder external for Docker."""
         return PurePath(self.path_extern_hassio, SHARE_DATA)
 
     @property
     def addons_repositories(self):
-        """Return list of addons custom repositories."""
+        """Return list of custom Add-on repositories."""
         return self._data[ATTR_ADDONS_CUSTOM_LIST]
 
     def add_addon_repository(self, repo):
@@ -174,23 +204,3 @@ class CoreConfig(JsonConfig):
             return
 
         self._data[ATTR_ADDONS_CUSTOM_LIST].remove(repo)
-
-    @property
-    def audio_output(self):
-        """Return ALSA audio output card,dev."""
-        return self._data.get(ATTR_AUDIO_OUTPUT)
-
-    @audio_output.setter
-    def audio_output(self, value):
-        """Set ALSA audio output card,dev."""
-        self._data[ATTR_AUDIO_OUTPUT] = value
-
-    @property
-    def audio_input(self):
-        """Return ALSA audio input card,dev."""
-        return self._data.get(ATTR_AUDIO_INPUT)
-
-    @audio_input.setter
-    def audio_input(self, value):
-        """Set ALSA audio input card,dev."""
-        self._data[ATTR_AUDIO_INPUT] = value

hassio/const.py

@@ -1,13 +1,18 @@
-"""Const file for HassIO."""
+"""Constants file for Hass.io."""
 from pathlib import Path
 from ipaddress import ip_network
 
-HASSIO_VERSION = '0.93'
+HASSIO_VERSION = '134'
 
-URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
-                      'hassio/{}/version.json')
+URL_HASSIO_ADDONS = "https://github.com/home-assistant/hassio-addons"
+URL_HASSIO_VERSION = \
+    "https://s3.amazonaws.com/hassio-version/{channel}.json"
+URL_HASSIO_APPARMOR = \
+    "https://s3.amazonaws.com/hassio-version/apparmor.txt"
 
-URL_HASSIO_ADDONS = 'https://github.com/home-assistant/hassio-addons'
+URL_HASSOS_OTA = (
+    "https://github.com/home-assistant/hassos/releases/download/"
+    "{version}/hassos_{board}-{version}.raucb")
 
 HASSIO_DATA = Path("/data")
 
@@ -16,9 +21,9 @@ FILE_HASSIO_CONFIG = Path(HASSIO_DATA, "config.json")
 FILE_HASSIO_HOMEASSISTANT = Path(HASSIO_DATA, "homeassistant.json")
 FILE_HASSIO_UPDATER = Path(HASSIO_DATA, "updater.json")
 FILE_HASSIO_SERVICES = Path(HASSIO_DATA, "services.json")
+FILE_HASSIO_DISCOVERY = Path(HASSIO_DATA, "discovery.json")
 
 SOCKET_DOCKER = Path("/var/run/docker.sock")
-SOCKET_HC = Path("/var/run/hassio-hc.sock")
 
 DOCKER_NETWORK = 'hassio'
 DOCKER_NETWORK_MASK = ip_network('172.30.32.0/23')
@@ -27,6 +32,7 @@ DOCKER_NETWORK_RANGE = ip_network('172.30.33.0/24')
 LABEL_VERSION = 'io.hass.version'
 LABEL_ARCH = 'io.hass.arch'
 LABEL_TYPE = 'io.hass.type'
+LABEL_MACHINE = 'io.hass.machine'
 
 META_ADDON = 'addon'
 META_SUPERVISOR = 'supervisor'
@@ -45,14 +51,16 @@ CONTENT_TYPE_JSON = 'application/json'
 CONTENT_TYPE_TEXT = 'text/plain'
 CONTENT_TYPE_TAR = 'application/tar'
 HEADER_HA_ACCESS = 'x-ha-access'
-HEADER_TOKEN = 'X-HASSIO-KEY'
+HEADER_TOKEN = 'x-hassio-key'
 
 ENV_TOKEN = 'HASSIO_TOKEN'
 ENV_TIME = 'TZ'
 
 REQUEST_FROM = 'HASSIO_FROM'
 
+ATTR_MACHINE = 'machine'
 ATTR_WAIT_BOOT = 'wait_boot'
+ATTR_DEPLOYMENT = 'deployment'
 ATTR_WATCHDOG = 'watchdog'
 ATTR_CHANGELOG = 'changelog'
 ATTR_DATE = 'date'
@@ -61,16 +69,19 @@ ATTR_LONG_DESCRIPTION = 'long_description'
 ATTR_HOSTNAME = 'hostname'
 ATTR_TIMEZONE = 'timezone'
 ATTR_ARGS = 'args'
-ATTR_OS = 'os'
+ATTR_OPERATING_SYSTEM = 'operating_system'
+ATTR_CHASSIS = 'chassis'
 ATTR_TYPE = 'type'
 ATTR_SOURCE = 'source'
 ATTR_FEATURES = 'features'
 ATTR_ADDONS = 'addons'
+ATTR_PROVIDERS = 'providers'
 ATTR_VERSION = 'version'
+ATTR_VERSION_LATEST = 'version_latest'
 ATTR_AUTO_UART = 'auto_uart'
 ATTR_LAST_BOOT = 'last_boot'
 ATTR_LAST_VERSION = 'last_version'
-ATTR_BETA_CHANNEL = 'beta_channel'
+ATTR_CHANNEL = 'channel'
 ATTR_NAME = 'name'
 ATTR_SLUG = 'slug'
 ATTR_DESCRIPTON = 'description'
@@ -98,13 +109,12 @@ ATTR_MAINTAINER = 'maintainer'
 ATTR_PASSWORD = 'password'
 ATTR_TOTP = 'totp'
 ATTR_INITIALIZE = 'initialize'
-ATTR_SESSION = 'session'
-ATTR_SESSIONS = 'sessions'
 ATTR_LOCATON = 'location'
 ATTR_BUILD = 'build'
 ATTR_DEVICES = 'devices'
 ATTR_ENVIRONMENT = 'environment'
 ATTR_HOST_NETWORK = 'host_network'
+ATTR_HOST_PID = 'host_pid'
 ATTR_HOST_IPC = 'host_ipc'
 ATTR_HOST_DBUS = 'host_dbus'
 ATTR_NETWORK = 'network'
@@ -144,22 +154,41 @@ ATTR_MEMORY_LIMIT = 'memory_limit'
 ATTR_MEMORY_USAGE = 'memory_usage'
 ATTR_BLK_READ = 'blk_read'
 ATTR_BLK_WRITE = 'blk_write'
-ATTR_PROVIDER = 'provider'
+ATTR_ADDON = 'addon'
 ATTR_AVAILABLE = 'available'
 ATTR_HOST = 'host'
 ATTR_USERNAME = 'username'
 ATTR_PROTOCOL = 'protocol'
 ATTR_DISCOVERY = 'discovery'
-ATTR_PLATFORM = 'platform'
-ATTR_COMPONENT = 'component'
 ATTR_CONFIG = 'config'
-ATTR_DISCOVERY_ID = 'discovery_id'
 ATTR_SERVICES = 'services'
+ATTR_SERVICE = 'service'
 ATTR_DISCOVERY = 'discovery'
 ATTR_PROTECTED = 'protected'
 ATTR_CRYPTO = 'crypto'
+ATTR_BRANCH = 'branch'
+ATTR_KERNEL = 'kernel'
+ATTR_APPARMOR = 'apparmor'
+ATTR_DEVICETREE = 'devicetree'
+ATTR_CPE = 'cpe'
+ATTR_BOARD = 'board'
+ATTR_HASSOS = 'hassos'
+ATTR_HASSOS_CLI = 'hassos_cli'
+ATTR_VERSION_CLI = 'version_cli'
+ATTR_VERSION_CLI_LATEST = 'version_cli_latest'
+ATTR_REFRESH_TOKEN = 'refresh_token'
+ATTR_ACCESS_TOKEN = 'access_token'
+ATTR_DOCKER_API = 'docker_api'
+ATTR_FULL_ACCESS = 'full_access'
+ATTR_PROTECTED = 'protected'
+ATTR_RATING = 'rating'
+ATTR_HASSIO_ROLE = 'hassio_role'
+ATTR_SUPERVISOR = 'supervisor'
 
 SERVICE_MQTT = 'mqtt'
+PROVIDE_SERVICE = 'provide'
+NEED_SERVICE = 'need'
+WANT_SERVICE = 'want'
 
 STARTUP_INITIALIZE = 'initialize'
 STARTUP_SYSTEM = 'system'
@@ -185,6 +214,10 @@ ARCH_AARCH64 = 'aarch64'
 ARCH_AMD64 = 'amd64'
 ARCH_I386 = 'i386'
 
+CHANNEL_STABLE = 'stable'
+CHANNEL_BETA = 'beta'
+CHANNEL_DEV = 'dev'
+
 REPOSITORY_CORE = 'core'
 REPOSITORY_LOCAL = 'local'
 
@@ -197,3 +230,28 @@ SNAPSHOT_FULL = 'full'
 SNAPSHOT_PARTIAL = 'partial'
 
 CRYPTO_AES128 = 'aes128'
+
+SECURITY_PROFILE = 'profile'
+SECURITY_DEFAULT = 'default'
+SECURITY_DISABLE = 'disable'
+
+PRIVILEGED_NET_ADMIN = 'NET_ADMIN'
+PRIVILEGED_SYS_ADMIN = 'SYS_ADMIN'
+PRIVILEGED_SYS_RAWIO = 'SYS_RAWIO'
+PRIVILEGED_IPC_LOCK = 'IPC_LOCK'
+PRIVILEGED_SYS_TIME = 'SYS_TIME'
+PRIVILEGED_SYS_NICE = 'SYS_NICE'
+PRIVILEGED_SYS_RESOURCE = 'SYS_RESOURCE'
+PRIVILEGED_SYS_PTRACE = 'SYS_PTRACE'
+PRIVILEGED_DAC_READ_SEARCH = 'DAC_READ_SEARCH'
+
+FEATURES_SHUTDOWN = 'shutdown'
+FEATURES_REBOOT = 'reboot'
+FEATURES_HASSOS = 'hassos'
+FEATURES_HOSTNAME = 'hostname'
+FEATURES_SERVICES = 'services'
+
+ROLE_DEFAULT = 'default'
+ROLE_HOMEASSISTANT = 'homeassistant'
+ROLE_MANAGER = 'manager'
+ROLE_ADMIN = 'admin'

hassio/core.py

@@ -1,117 +1,143 @@
-"""Main file for HassIO."""
+"""Main file for Hass.io."""
+from contextlib import suppress
 import asyncio
 import logging
 
+import async_timeout
+
 from .coresys import CoreSysAttributes
 from .const import (
     STARTUP_SYSTEM, STARTUP_SERVICES, STARTUP_APPLICATION, STARTUP_INITIALIZE)
-from .utils.dt import fetch_timezone
+from .exceptions import HassioError, HomeAssistantError
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class HassIO(CoreSysAttributes):
-    """Main object of hassio."""
+    """Main object of Hass.io."""
 
     def __init__(self, coresys):
-        """Initialize hassio object."""
+        """Initialize Hass.io object."""
         self.coresys = coresys
 
     async def setup(self):
         """Setup HassIO orchestration."""
-        # update timezone
-        if self._config.timezone == 'UTC':
-            self._config.timezone = await fetch_timezone(self._websession)
+        # Load Supervisor
+        await self.sys_supervisor.load()
 
-        # supervisor
-        await self._supervisor.load()
+        # Load DBus
+        await self.sys_dbus.load()
 
-        # hostcontrol
-        await self._host_control.load()
+        # Load Host
+        await self.sys_host.load()
 
-        # Load homeassistant
-        await self._homeassistant.load()
+        # Load HassOS
+        await self.sys_hassos.load()
 
-        # Load addons
-        await self._addons.load()
+        # Load Home Assistant
+        await self.sys_homeassistant.load()
+
+        # Load Add-ons
+        await self.sys_addons.load()
 
         # rest api views
-        await self._api.load()
+        await self.sys_api.load()
 
         # load last available data
-        await self._updater.load()
+        await self.sys_updater.load()
 
         # load last available data
-        await self._snapshots.load()
+        await self.sys_snapshots.load()
 
         # load services
-        await self._services.load()
+        await self.sys_services.load()
+
+        # Load discovery
+        await self.sys_discovery.load()
 
         # start dns forwarding
-        self._loop.create_task(self._dns.start())
-
-        # start addon mark as initialize
-        await self._addons.auto_boot(STARTUP_INITIALIZE)
+        self.sys_create_task(self.sys_dns.start())
 
     async def start(self):
-        """Start HassIO orchestration."""
+        """Start Hass.io orchestration."""
         # on release channel, try update itself
-        # on beta channel, only read new versions
-        if not self._updater.beta_channel and self._supervisor.need_update:
-            if await self._supervisor.update():
+        # on dev mode, only read new versions
+        if not self.sys_dev and self.sys_supervisor.need_update:
+            if await self.sys_supervisor.update():
                 return
         else:
-            _LOGGER.info("Ignore Hass.io auto updates on beta mode")
+            _LOGGER.info("Ignore Hass.io auto updates on dev channel")
 
         # start api
-        await self._api.start()
-        _LOGGER.info("Start API on %s", self._docker.network.supervisor)
+        await self.sys_api.start()
+
+        # start addon mark as initialize
+        await self.sys_addons.boot(STARTUP_INITIALIZE)
 
         try:
             # HomeAssistant is already running / supervisor have only reboot
-            if self._hardware.last_boot == self._config.last_boot:
+            if self.sys_hardware.last_boot == self.sys_config.last_boot:
                 _LOGGER.info("Hass.io reboot detected")
                 return
 
             # reset register services / discovery
-            self._services.reset()
+            self.sys_services.reset()
 
             # start addon mark as system
-            await self._addons.auto_boot(STARTUP_SYSTEM)
+            await self.sys_addons.boot(STARTUP_SYSTEM)
 
             # start addon mark as services
-            await self._addons.auto_boot(STARTUP_SERVICES)
+            await self.sys_addons.boot(STARTUP_SERVICES)
 
             # run HomeAssistant
-            if self._homeassistant.boot:
-                await self._homeassistant.start()
+            if self.sys_homeassistant.boot:
+                with suppress(HomeAssistantError):
+                    await self.sys_homeassistant.start()
 
             # start addon mark as application
-            await self._addons.auto_boot(STARTUP_APPLICATION)
+            await self.sys_addons.boot(STARTUP_APPLICATION)
 
             # store new last boot
-            self._config.last_boot = self._hardware.last_boot
-            self._config.save_data()
+            self.sys_config.last_boot = self.sys_hardware.last_boot
+            self.sys_config.save_data()
 
         finally:
             # Add core tasks into scheduler
-            await self._tasks.load()
+            await self.sys_tasks.load()
 
             # If landingpage / run upgrade in background
-            if self._homeassistant.version == 'landingpage':
-                self._loop.create_task(self._homeassistant.install())
+            if self.sys_homeassistant.version == 'landingpage':
+                self.sys_create_task(self.sys_homeassistant.install())
 
             _LOGGER.info("Hass.io is up and running")
 
     async def stop(self):
         """Stop a running orchestration."""
         # don't process scheduler anymore
-        self._scheduler.suspend = True
-
-        # process stop tasks
-        self._websession.close()
-        self._websession_ssl.close()
+        self.sys_scheduler.suspend = True
 
         # process async stop tasks
-        await asyncio.wait(
-            [self._api.stop(), self._dns.stop()], loop=self._loop)
+        try:
+            with async_timeout.timeout(10):
+                await asyncio.wait([
+                    self.sys_api.stop(),
+                    self.sys_dns.stop(),
+                    self.sys_websession.close(),
+                    self.sys_websession_ssl.close()
+                ])
+        except asyncio.TimeoutError:
+            _LOGGER.warning("Force Shutdown!")
+
+        _LOGGER.info("Hass.io is down")
+
+    async def shutdown(self):
+        """Shutdown all running containers in correct order."""
+        await self.sys_addons.shutdown(STARTUP_APPLICATION)
+
+        # Close Home Assistant
+        with suppress(HassioError):
+            await self.sys_homeassistant.stop()
+
+        await self.sys_addons.shutdown(STARTUP_SERVICES)
+        await self.sys_addons.shutdown(STARTUP_SYSTEM)
+        await self.sys_addons.shutdown(STARTUP_INITIALIZE)

hassio/coresys.py

@@ -1,22 +1,22 @@
 """Handle core shared data."""
-
 import aiohttp
 
+from .const import CHANNEL_DEV
 from .config import CoreConfig
 from .docker import DockerAPI
 from .misc.dns import DNSForward
 from .misc.hardware import Hardware
-from .misc.host_control import HostControl
 from .misc.scheduler import Scheduler
 
 
-class CoreSys(object):
+class CoreSys:
     """Class that handle all shared data."""
 
     def __init__(self, loop):
         """Initialize coresys."""
         # Static attributes
         self.exit_code = 0
+        self.machine_id = None
 
         # External objects
         self._loop = loop
@@ -30,9 +30,9 @@ class CoreSys(object):
         self._docker = DockerAPI()
         self._scheduler = Scheduler(loop=loop)
         self._dns = DNSForward(loop=loop)
-        self._host_control = HostControl(loop=loop)
 
         # Internal objects pointers
+        self._core = None
         self._homeassistant = None
         self._supervisor = None
         self._addons = None
@@ -40,15 +40,36 @@ class CoreSys(object):
         self._updater = None
         self._snapshots = None
         self._tasks = None
+        self._host = None
+        self._dbus = None
+        self._hassos = None
         self._services = None
+        self._discovery = None
 
     @property
     def arch(self):
-        """Return running arch of hass.io system."""
+        """Return running arch of the Hass.io system."""
         if self._supervisor:
             return self._supervisor.arch
         return None
 
+    @property
+    def machine(self):
+        """Return running machine type of the Hass.io system."""
+        if self._homeassistant:
+            return self._homeassistant.machine
+        return None
+
+    @property
+    def dev(self):
+        """Return True if we run dev mode."""
+        return self._updater.channel == CHANNEL_DEV
+
+    @property
+    def timezone(self):
+        """Return timezone."""
+        return self._config.timezone
+
     @property
     def loop(self):
         """Return loop object."""
@@ -90,20 +111,27 @@ class CoreSys(object):
         return self._dns
 
     @property
-    def host_control(self):
-        """Return HostControl object."""
-        return self._host_control
+    def core(self):
+        """Return HassIO object."""
+        return self._core
+
+    @core.setter
+    def core(self, value):
+        """Set a Hass.io object."""
+        if self._core:
+            raise RuntimeError("Hass.io already set!")
+        self._core = value
 
     @property
     def homeassistant(self):
-        """Return HomeAssistant object."""
+        """Return Home Assistant object."""
         return self._homeassistant
 
     @homeassistant.setter
     def homeassistant(self, value):
         """Set a HomeAssistant object."""
         if self._homeassistant:
-            raise RuntimeError("HomeAssistant already set!")
+            raise RuntimeError("Home Assistant already set!")
         self._homeassistant = value
 
     @property
@@ -125,7 +153,7 @@ class CoreSys(object):
 
     @api.setter
     def api(self, value):
-        """Set a API object."""
+        """Set an API object."""
         if self._api:
             raise RuntimeError("API already set!")
         self._api = value
@@ -190,14 +218,70 @@ class CoreSys(object):
             raise RuntimeError("Services already set!")
         self._services = value
 
+    @property
+    def discovery(self):
+        """Return ServiceManager object."""
+        return self._discovery
 
-class CoreSysAttributes(object):
+    @discovery.setter
+    def discovery(self, value):
+        """Set a Discovery object."""
+        if self._discovery:
+            raise RuntimeError("Discovery already set!")
+        self._discovery = value
+
+    @property
+    def dbus(self):
+        """Return DBusManager object."""
+        return self._dbus
+
+    @dbus.setter
+    def dbus(self, value):
+        """Set a DBusManager object."""
+        if self._dbus:
+            raise RuntimeError("DBusManager already set!")
+        self._dbus = value
+
+    @property
+    def host(self):
+        """Return HostManager object."""
+        return self._host
+
+    @host.setter
+    def host(self, value):
+        """Set a HostManager object."""
+        if self._host:
+            raise RuntimeError("HostManager already set!")
+        self._host = value
+
+    @property
+    def hassos(self):
+        """Return HassOS object."""
+        return self._hassos
+
+    @hassos.setter
+    def hassos(self, value):
+        """Set a HassOS object."""
+        if self._hassos:
+            raise RuntimeError("HassOS already set!")
+        self._hassos = value
+
+    def run_in_executor(self, funct, *args):
+        """Wrapper for executor pool."""
+        return self._loop.run_in_executor(None, funct, *args)
+
+    def create_task(self, coroutine):
+        """Wrapper for async task."""
+        return self._loop.create_task(coroutine)
+
+
+class CoreSysAttributes:
     """Inheret basic CoreSysAttributes."""
 
     coresys = None
 
     def __getattr__(self, name):
         """Mapping to coresys."""
-        if hasattr(self.coresys, name[1:]):
-            return getattr(self.coresys, name[1:])
-        raise AttributeError(f"Can't find {name} on {self.__class__}")
+        if name.startswith("sys_") and hasattr(self.coresys, name[4:]):
+            return getattr(self.coresys, name[4:])
+        raise AttributeError(f"Can't resolve {name} on {self}")

hassio/dbus/__init__.py

@@ -0,0 +1,39 @@
+"""D-Bus interface objects."""
+
+from .systemd import Systemd
+from .hostname import Hostname
+from .rauc import Rauc
+from ..coresys import CoreSysAttributes
+
+
+class DBusManager(CoreSysAttributes):
+    """A DBus Interface handler."""
+
+    def __init__(self, coresys):
+        """Initialize D-Bus interface."""
+        self.coresys = coresys
+
+        self._systemd = Systemd()
+        self._hostname = Hostname()
+        self._rauc = Rauc()
+
+    @property
+    def systemd(self):
+        """Return the systemd interface."""
+        return self._systemd
+
+    @property
+    def hostname(self):
+        """Return the hostname interface."""
+        return self._hostname
+
+    @property
+    def rauc(self):
+        """Return the rauc interface."""
+        return self._rauc
+
+    async def load(self):
+        """Connect interfaces to D-Bus."""
+        await self.systemd.connect()
+        await self.hostname.connect()
+        await self.rauc.connect()

hassio/dbus/hostname.py

@@ -0,0 +1,39 @@
+"""D-Bus interface for hostname."""
+import logging
+
+from .interface import DBusInterface
+from .utils import dbus_connected
+from ..exceptions import DBusError
+from ..utils.gdbus import DBus
+
+_LOGGER = logging.getLogger(__name__)
+
+DBUS_NAME = 'org.freedesktop.hostname1'
+DBUS_OBJECT = '/org/freedesktop/hostname1'
+
+
+class Hostname(DBusInterface):
+    """Handle D-Bus interface for hostname/system."""
+
+    async def connect(self):
+        """Connect to system's D-Bus."""
+        try:
+            self.dbus = await DBus.connect(DBUS_NAME, DBUS_OBJECT)
+        except DBusError:
+            _LOGGER.warning("Can't connect to hostname")
+
+    @dbus_connected
+    def set_static_hostname(self, hostname):
+        """Change local hostname.
+
+        Return a coroutine.
+        """
+        return self.dbus.SetStaticHostname(hostname, False)
+
+    @dbus_connected
+    def get_properties(self):
+        """Return local host informations.
+
+        Return a coroutine.
+        """
+        return self.dbus.get_properties(DBUS_NAME)

hassio/dbus/interface.py

@@ -0,0 +1,18 @@
+"""Interface class for D-Bus wrappers."""
+
+
+class DBusInterface:
+    """Handle D-Bus interface for hostname/system."""
+
+    def __init__(self):
+        """Initialize systemd."""
+        self.dbus = None
+
+    @property
+    def is_connected(self):
+        """Return True, if they is connected to D-Bus."""
+        return self.dbus is not None
+
+    async def connect(self):
+        """Connect to D-Bus."""
+        raise NotImplementedError()

hassio/dbus/rauc.py

@@ -0,0 +1,55 @@
+"""D-Bus interface for rauc."""
+import logging
+
+from .interface import DBusInterface
+from .utils import dbus_connected
+from ..exceptions import DBusError
+from ..utils.gdbus import DBus
+
+_LOGGER = logging.getLogger(__name__)
+
+DBUS_NAME = 'de.pengutronix.rauc'
+DBUS_OBJECT = '/'
+
+
+class Rauc(DBusInterface):
+    """Handle D-Bus interface for rauc."""
+
+    async def connect(self):
+        """Connect to D-Bus."""
+        try:
+            self.dbus = await DBus.connect(DBUS_NAME, DBUS_OBJECT)
+        except DBusError:
+            _LOGGER.warning("Can't connect to rauc")
+
+    @dbus_connected
+    def install(self, raucb_file):
+        """Install rauc bundle file.
+
+        Return a coroutine.
+        """
+        return self.dbus.Installer.Install(raucb_file)
+
+    @dbus_connected
+    def get_slot_status(self):
+        """Get slot status.
+
+        Return a coroutine.
+        """
+        return self.dbus.Installer.GetSlotStatus()
+
+    @dbus_connected
+    def get_properties(self):
+        """Return rauc informations.
+
+        Return a coroutine.
+        """
+        return self.dbus.get_properties(f"{DBUS_NAME}.Installer")
+
+    @dbus_connected
+    def signal_completed(self):
+        """Return a signal wrapper for completed signal.
+
+        Return a coroutine.
+        """
+        return self.dbus.wait_signal(f"{DBUS_NAME}.Installer.Completed")

hassio/dbus/systemd.py

@@ -0,0 +1,79 @@
+"""Interface to Systemd over D-Bus."""
+import logging
+
+from .interface import DBusInterface
+from .utils import dbus_connected
+from ..exceptions import DBusError
+from ..utils.gdbus import DBus
+
+_LOGGER = logging.getLogger(__name__)
+
+DBUS_NAME = 'org.freedesktop.systemd1'
+DBUS_OBJECT = '/org/freedesktop/systemd1'
+
+
+class Systemd(DBusInterface):
+    """Systemd function handler."""
+
+    async def connect(self):
+        """Connect to D-Bus."""
+        try:
+            self.dbus = await DBus.connect(DBUS_NAME, DBUS_OBJECT)
+        except DBusError:
+            _LOGGER.warning("Can't connect to systemd")
+
+    @dbus_connected
+    def reboot(self):
+        """Reboot host computer.
+
+        Return a coroutine.
+        """
+        return self.dbus.Manager.Reboot()
+
+    @dbus_connected
+    def power_off(self):
+        """Power off host computer.
+
+        Return a coroutine.
+        """
+        return self.dbus.Manager.PowerOff()
+
+    @dbus_connected
+    def start_unit(self, unit, mode):
+        """Start a systemd service unit.
+
+        Return a coroutine.
+        """
+        return self.dbus.Manager.StartUnit(unit, mode)
+
+    @dbus_connected
+    def stop_unit(self, unit, mode):
+        """Stop a systemd service unit.
+
+        Return a coroutine.
+        """
+        return self.dbus.Manager.StopUnit(unit, mode)
+
+    @dbus_connected
+    def reload_unit(self, unit, mode):
+        """Reload a systemd service unit.
+
+        Return a coroutine.
+        """
+        return self.dbus.Manager.ReloadOrRestartUnit(unit, mode)
+
+    @dbus_connected
+    def restart_unit(self, unit, mode):
+        """Restart a systemd service unit.
+
+        Return a coroutine.
+        """
+        return self.dbus.Manager.RestartUnit(unit, mode)
+
+    @dbus_connected
+    def list_units(self):
+        """Return a list of available systemd services.
+
+        Return a coroutine.
+        """
+        return self.dbus.Manager.ListUnits()

hassio/dbus/utils.py

@@ -0,0 +1,14 @@
+"""Utils for D-Bus."""
+
+from ..exceptions import DBusNotConnectedError
+
+
+def dbus_connected(method):
+    """Wrapper for check if D-Bus is connected."""
+    def wrap_dbus(api, *args, **kwargs):
+        """Check if D-Bus is connected before call a method."""
+        if api.dbus is None:
+            raise DBusNotConnectedError()
+        return method(api, *args, **kwargs)
+
+    return wrap_dbus

hassio/discovery.py

@@ -0,0 +1,121 @@
+"""Handle discover message for Home Assistant."""
+import logging
+from contextlib import suppress
+from uuid import uuid4
+
+import attr
+import voluptuous as vol
+from voluptuous.humanize import humanize_error
+
+from .const import FILE_HASSIO_DISCOVERY, ATTR_CONFIG, ATTR_DISCOVERY
+from .coresys import CoreSysAttributes
+from .exceptions import DiscoveryError, HomeAssistantAPIError
+from .validate import SCHEMA_DISCOVERY_CONFIG
+from .utils.json import JsonConfig
+from .services.validate import DISCOVERY_SERVICES
+
+_LOGGER = logging.getLogger(__name__)
+
+CMD_NEW = 'post'
+CMD_DEL = 'delete'
+
+
+class Discovery(CoreSysAttributes, JsonConfig):
+    """Home Assistant Discovery handler."""
+
+    def __init__(self, coresys):
+        """Initialize discovery handler."""
+        super().__init__(FILE_HASSIO_DISCOVERY, SCHEMA_DISCOVERY_CONFIG)
+        self.coresys = coresys
+        self.message_obj = {}
+
+    async def load(self):
+        """Load exists discovery message into storage."""
+        messages = {}
+        for message in self._data[ATTR_DISCOVERY]:
+            discovery = Message(**message)
+            messages[discovery.uuid] = discovery
+
+        self.message_obj = messages
+
+    def save(self):
+        """Write discovery message into data file."""
+        messages = []
+        for message in self.list_messages:
+            messages.append(attr.asdict(message))
+
+        self._data[ATTR_DISCOVERY].clear()
+        self._data[ATTR_DISCOVERY].extend(messages)
+        self.save_data()
+
+    def get(self, uuid):
+        """Return discovery message."""
+        return self.message_obj.get(uuid)
+
+    @property
+    def list_messages(self):
+        """Return list of available discovery messages."""
+        return list(self.message_obj.values())
+
+    def send(self, addon, service, config):
+        """Send a discovery message to Home Assistant."""
+        try:
+            DISCOVERY_SERVICES[service](config)
+        except vol.Invalid as err:
+            _LOGGER.error(
+                "Invalid discovery %s config", humanize_error(config, err))
+            raise DiscoveryError() from None
+
+        # Create message
+        message = Message(addon.slug, service, config)
+
+        # Already exists?
+        for old_message in self.list_messages:
+            if old_message != message:
+                continue
+            _LOGGER.warning("Duplicate discovery message from %s", addon.slug)
+            return old_message
+
+        _LOGGER.info("Send discovery to Home Assistant %s from %s",
+                     service, addon.slug)
+        self.message_obj[message.uuid] = message
+        self.save()
+
+        self.sys_create_task(self._push_discovery(message, CMD_NEW))
+        return message
+
+    def remove(self, message):
+        """Remove a discovery message from Home Assistant."""
+        self.message_obj.pop(message.uuid, None)
+        self.save()
+
+        _LOGGER.info("Delete discovery to Home Assistant %s from %s",
+                     message.service, message.addon)
+        self.sys_create_task(self._push_discovery(message, CMD_DEL))
+
+    async def _push_discovery(self, message, command):
+        """Send a discovery request."""
+        if not await self.sys_homeassistant.check_api_state():
+            _LOGGER.info("Discovery %s mesage ignore", message.uuid)
+            return
+
+        data = attr.asdict(message)
+        data.pop(ATTR_CONFIG)
+
+        with suppress(HomeAssistantAPIError):
+            async with self.sys_homeassistant.make_request(
+                    command, f"api/hassio_push/discovery/{message.uuid}",
+                    json=data, timeout=10):
+                _LOGGER.info("Discovery %s message send", message.uuid)
+                return
+
+        _LOGGER.warning("Discovery %s message fail", message.uuid)
+
+
+@attr.s
+class Message:
+    """Represent a single Discovery message."""
+    uuid = attr.ib(factory=lambda: uuid4().hex, cmp=False, init=False)
+    addon = attr.ib()
+    service = attr.ib()
+    config = attr.ib(cmp=False)

hassio/docker/__init__.py

@@ -1,8 +1,8 @@
-"""Init file for HassIO docker object."""
+"""Init file for Hass.io Docker object."""
 from contextlib import suppress
-from collections import namedtuple
 import logging
 
+import attr
 import docker
 
 from .network import DockerNetwork
@@ -10,39 +10,44 @@ from ..const import SOCKET_DOCKER
 
 _LOGGER = logging.getLogger(__name__)
 
-CommandReturn = namedtuple('CommandReturn', ['exit_code', 'output'])
+
+@attr.s(frozen=True)
+class CommandReturn:
+    """Return object from command run."""
+    exit_code = attr.ib()
+    output = attr.ib()
 
 
-class DockerAPI(object):
-    """Docker hassio wrapper.
+class DockerAPI:
+    """Docker Hass.io wrapper.
 
     This class is not AsyncIO safe!
     """
 
     def __init__(self):
-        """Initialize docker base wrapper."""
+        """Initialize Docker base wrapper."""
         self.docker = docker.DockerClient(
             base_url="unix:/{}".format(str(SOCKET_DOCKER)),
-            version='auto', timeout=300)
+            version='auto', timeout=900)
         self.network = DockerNetwork(self.docker)
 
     @property
     def images(self):
-        """Return api images."""
+        """Return API images."""
         return self.docker.images
 
     @property
     def containers(self):
-        """Return api containers."""
+        """Return API containers."""
         return self.docker.containers
 
     @property
     def api(self):
-        """Return api containers."""
+        """Return API containers."""
         return self.docker.api
 
     def run(self, image, **kwargs):
-        """"Create a docker and run it.
+        """"Create a Docker container and run it.
 
         Need run inside executor.
         """
@@ -50,7 +55,7 @@ class DockerAPI(object):
         network_mode = kwargs.get('network_mode')
         hostname = kwargs.get('hostname')
 
-        # setup network
+        # Setup network
         kwargs['dns_search'] = ["."]
         if network_mode:
             kwargs['dns'] = [str(self.network.supervisor)]
@@ -58,7 +63,7 @@ class DockerAPI(object):
         else:
             kwargs['network'] = None
 
-        # create container
+        # Create container
         try:
             container = self.docker.containers.create(image, **kwargs)
         except docker.errors.DockerException as err:
@@ -107,8 +112,9 @@ class DockerAPI(object):
             _LOGGER.error("Can't execute command: %s", err)
             return CommandReturn(None, b"")
 
-        # cleanup container
-        with suppress(docker.errors.DockerException):
-            container.remove(force=True)
+        finally:
+            # cleanup container
+            with suppress(docker.errors.DockerException):
+                container.remove(force=True)
 
         return CommandReturn(result.get('StatusCode'), output)

hassio/docker/addon.py

@@ -1,16 +1,17 @@
-"""Init file for HassIO addon docker object."""
+"""Init file for Hass.io add-on Docker object."""
 import logging
 import os
+from pathlib import Path
 
 import docker
 import requests
 
 from .interface import DockerInterface
-from .utils import docker_process
 from ..addons.build import AddonBuild
 from ..const import (
     MAP_CONFIG, MAP_SSL, MAP_ADDONS, MAP_BACKUP, MAP_SHARE, ENV_TOKEN,
-    ENV_TIME)
+    ENV_TIME, SECURITY_PROFILE, SECURITY_DISABLE)
+from ..utils import process_lock
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -18,45 +19,45 @@ AUDIO_DEVICE = "/dev/snd:/dev/snd:rwm"
 
 
 class DockerAddon(DockerInterface):
-    """Docker hassio wrapper for HomeAssistant."""
+    """Docker Hass.io wrapper for Home Assistant."""
 
     def __init__(self, coresys, slug):
-        """Initialize docker homeassistant wrapper."""
+        """Initialize Docker Home Assistant wrapper."""
         super().__init__(coresys)
         self._id = slug
 
     @property
     def addon(self):
-        """Return addon of docker image."""
-        return self._addons.get(self._id)
+        """Return add-on of Docker image."""
+        return self.sys_addons.get(self._id)
 
     @property
     def image(self):
-        """Return name of docker image."""
+        """Return name of Docker image."""
         return self.addon.image
 
     @property
     def timeout(self):
-        """Return timeout for docker actions."""
+        """Return timeout for Docker actions."""
         return self.addon.timeout
 
     @property
     def version(self):
-        """Return version of docker image."""
+        """Return version of Docker image."""
         if not self.addon.legacy:
             return super().version
         return self.addon.version_installed
 
     @property
     def arch(self):
-        """Return arch of docker image."""
+        """Return arch of Docker image."""
         if not self.addon.legacy:
             return super().arch
-        return self._arch
+        return self.sys_arch
 
     @property
     def name(self):
-        """Return name of docker container."""
+        """Return name of Docker container."""
         return "addon_{}".format(self.addon.slug)
 
     @property
@@ -66,14 +67,19 @@ class DockerAddon(DockerInterface):
             return 'host'
         return None
 
+    @property
+    def full_access(self):
+        """Return True if full access is enabled."""
+        return not self.addon.protected and self.addon.with_full_access
+
     @property
     def hostname(self):
-        """Return slug/id of addon."""
+        """Return slug/id of add-on."""
         return self.addon.slug.replace('_', '-')
 
     @property
     def environment(self):
-        """Return environment for docker add-on."""
+        """Return environment for Docker add-on."""
         addon_env = self.addon.environment or {}
 
         # Need audio settings
@@ -85,8 +91,8 @@ class DockerAddon(DockerInterface):
 
         return {
             **addon_env,
-            ENV_TIME: self._config.timezone,
-            ENV_TOKEN: self.addon.uuid,
+            ENV_TIME: self.sys_timezone,
+            ENV_TOKEN: self.addon.hassio_token,
         }
 
     @property
@@ -100,7 +106,7 @@ class DockerAddon(DockerInterface):
 
         # Auto mapping UART devices
         if self.addon.auto_uart:
-            for device in self._hardware.serial_devices:
+            for device in self.sys_hardware.serial_devices:
                 devices.append(f"{device}:{device}:rwm")
 
         # Return None if no devices is present
@@ -108,7 +114,7 @@ class DockerAddon(DockerInterface):
 
     @property
     def ports(self):
-        """Filter None from addon ports."""
+        """Filter None from add-on ports."""
         if not self.addon.ports:
             return None
 
@@ -120,19 +126,25 @@ class DockerAddon(DockerInterface):
 
     @property
     def security_opt(self):
-        """Controlling security opt."""
-        privileged = self.addon.privileged or []
+        """Controlling security options."""
+        security = []
 
-        # Disable AppArmor sinse it make troubles wit SYS_ADMIN
-        if 'SYS_ADMIN' in privileged:
-            return [
-                "apparmor:unconfined",
-            ]
-        return None
+        # AppArmor
+        apparmor = self.sys_host.apparmor.available
+        if not apparmor or self.addon.apparmor == SECURITY_DISABLE:
+            security.append("apparmor:unconfined")
+        elif self.addon.apparmor == SECURITY_PROFILE:
+            security.append(f"apparmor={self.addon.slug}")
+
+        # Disable Seccomp / We don't support it official and it
+        # make troubles on some kind of host systems.
+        security.append("seccomp=unconfined")
+
+        return security
 
     @property
     def tmpfs(self):
-        """Return tmpfs for docker add-on."""
+        """Return tmpfs for Docker add-on."""
         options = self.addon.tmpfs
         if options:
             return {"/tmpfs": f"{options}"}
@@ -142,17 +154,24 @@ class DockerAddon(DockerInterface):
     def network_mapping(self):
         """Return hosts mapping."""
         return {
-            'homeassistant': self._docker.network.gateway,
-            'hassio': self._docker.network.supervisor,
+            'homeassistant': self.sys_docker.network.gateway,
+            'hassio': self.sys_docker.network.supervisor,
         }
 
     @property
     def network_mode(self):
-        """Return network mode for addon."""
+        """Return network mode for add-on."""
         if self.addon.host_network:
             return 'host'
         return None
 
+    @property
+    def pid_mode(self):
+        """Return PID mode for add-on."""
+        if not self.addon.protected and self.addon.host_pid:
+            return 'host'
+        return None
+
     @property
     def volumes(self):
         """Generate volumes for mappings."""
@@ -166,74 +185,106 @@ class DockerAddon(DockerInterface):
         # setup config mappings
         if MAP_CONFIG in addon_mapping:
             volumes.update({
-                str(self._config.path_extern_config): {
+                str(self.sys_config.path_extern_homeassistant): {
                     'bind': "/config", 'mode': addon_mapping[MAP_CONFIG]
                 }})
 
         if MAP_SSL in addon_mapping:
             volumes.update({
-                str(self._config.path_extern_ssl): {
+                str(self.sys_config.path_extern_ssl): {
                     'bind': "/ssl", 'mode': addon_mapping[MAP_SSL]
                 }})
 
         if MAP_ADDONS in addon_mapping:
             volumes.update({
-                str(self._config.path_extern_addons_local): {
+                str(self.sys_config.path_extern_addons_local): {
                     'bind': "/addons", 'mode': addon_mapping[MAP_ADDONS]
                 }})
 
         if MAP_BACKUP in addon_mapping:
             volumes.update({
-                str(self._config.path_extern_backup): {
+                str(self.sys_config.path_extern_backup): {
                     'bind': "/backup", 'mode': addon_mapping[MAP_BACKUP]
                 }})
 
         if MAP_SHARE in addon_mapping:
             volumes.update({
-                str(self._config.path_extern_share): {
+                str(self.sys_config.path_extern_share): {
                     'bind': "/share", 'mode': addon_mapping[MAP_SHARE]
                 }})
 
-        # init other hardware mappings
+        # Init other hardware mappings
+
+        # GPIO support
         if self.addon.with_gpio:
+            for gpio_path in ("/sys/class/gpio", "/sys/devices/platform/soc"):
+                if not Path(gpio_path).exists():
+                    continue
+                volumes.update({
+                    gpio_path: {
+                        'bind': gpio_path, 'mode': 'rw'
+                    },
+                })
+
+        # DeviceTree support
+        if self.addon.with_devicetree:
             volumes.update({
-                "/sys/class/gpio": {
-                    'bind': "/sys/class/gpio", 'mode': 'rw'
-                },
-                "/sys/devices/platform/soc": {
-                    'bind': "/sys/devices/platform/soc", 'mode': 'rw'
+                "/sys/firmware/devicetree/base": {
+                    'bind': "/device-tree", 'mode': 'ro'
                 },
             })
 
-        # host dbus system
+        # Docker API support
+        if not self.addon.protected and self.addon.access_docker_api:
+            volumes.update({
+                "/var/run/docker.sock": {
+                    'bind': "/var/run/docker.sock", 'mode': 'ro'
+                },
+            })
+
+        # Host D-Bus system
         if self.addon.host_dbus:
             volumes.update({
                 "/var/run/dbus": {
                     'bind': "/var/run/dbus", 'mode': 'rw'
                 }})
 
+        # ALSA configuration
+        if self.addon.with_audio:
+            volumes.update({
+                str(self.addon.path_extern_asound): {
+                    'bind': "/etc/asound.conf", 'mode': 'ro'
+                }})
+
         return volumes
 
     def _run(self):
-        """Run docker image.
+        """Run Docker image.
 
         Need run inside executor.
         """
         if self._is_running():
             return True
 
+        # Security check
+        if not self.addon.protected:
+            _LOGGER.warning(
+                "%s run with disabled protected mode!", self.addon.name)
+
         # cleanup
         self._stop()
 
-        ret = self._docker.run(
+        ret = self.sys_docker.run(
             self.image,
             name=self.name,
             hostname=self.hostname,
             detach=True,
             init=True,
+            privileged=self.full_access,
             ipc_mode=self.ipc,
             stdin_open=self.addon.with_stdin,
             network_mode=self.network_mode,
+            pid_mode=self.pid_mode,
             ports=self.ports,
             extra_hosts=self.network_mapping,
             devices=self.devices,
@@ -245,13 +296,13 @@ class DockerAddon(DockerInterface):
         )
 
         if ret:
-            _LOGGER.info("Start docker addon %s with version %s",
+            _LOGGER.info("Start Docker add-on %s with version %s",
                          self.image, self.version)
 
         return ret
 
     def _install(self, tag):
-        """Pull docker image or build it.
+        """Pull Docker image or build it.
 
         Need run inside executor.
         """
@@ -261,7 +312,7 @@ class DockerAddon(DockerInterface):
         return super()._install(tag)
 
     def _build(self, tag):
-        """Build a docker container.
+        """Build a Docker container.
 
         Need run inside executor.
         """
@@ -269,7 +320,7 @@ class DockerAddon(DockerInterface):
 
         _LOGGER.info("Start build %s:%s", self.image, tag)
         try:
-            image, log = self._docker.images.build(
+            image, log = self.sys_docker.images.build(
                 **build_env.get_docker_args(tag))
 
             _LOGGER.debug("Build %s:%s done: %s", self.image, tag, log)
@@ -278,17 +329,17 @@ class DockerAddon(DockerInterface):
             # Update meta data
             self._meta = image.attrs
 
-        except (docker.errors.DockerException) as err:
+        except docker.errors.DockerException as err:
             _LOGGER.error("Can't build %s:%s: %s", self.image, tag, err)
             return False
 
         _LOGGER.info("Build %s:%s done", self.image, tag)
         return True
 
-    @docker_process
+    @process_lock
     def export_image(self, path):
         """Export current images into a tar file."""
-        return self._loop.run_in_executor(None, self._export_image, path)
+        return self.sys_run_in_executor(self._export_image, path)
 
     def _export_image(self, tar_file):
         """Export current images into a tar file.
@@ -296,7 +347,7 @@ class DockerAddon(DockerInterface):
         Need run inside executor.
         """
         try:
-            image = self._docker.api.get_image(self.image)
+            image = self.sys_docker.api.get_image(self.image)
         except docker.errors.DockerException as err:
             _LOGGER.error("Can't fetch image %s: %s", self.image, err)
             return False
@@ -313,10 +364,10 @@ class DockerAddon(DockerInterface):
         _LOGGER.info("Export image %s done", self.image)
         return True
 
-    @docker_process
+    @process_lock
     def import_image(self, path, tag):
         """Import a tar file as image."""
-        return self._loop.run_in_executor(None, self._import_image, path, tag)
+        return self.sys_run_in_executor(self._import_image, path, tag)
 
     def _import_image(self, tar_file, tag):
         """Import a tar file as image.
@@ -325,9 +376,9 @@ class DockerAddon(DockerInterface):
         """
         try:
             with tar_file.open("rb") as read_tar:
-                self._docker.api.load_image(read_tar, quiet=True)
+                self.sys_docker.api.load_image(read_tar, quiet=True)
 
-            image = self._docker.images.get(self.image)
+            image = self.sys_docker.images.get(self.image)
             image.tag(self.image, tag=tag)
         except (docker.errors.DockerException, OSError) as err:
             _LOGGER.error("Can't import image %s: %s", self.image, err)
@@ -338,10 +389,10 @@ class DockerAddon(DockerInterface):
         self._cleanup()
         return True
 
-    @docker_process
+    @process_lock
     def write_stdin(self, data):
         """Write to add-on stdin."""
-        return self._loop.run_in_executor(None, self._write_stdin, data)
+        return self.sys_run_in_executor(self._write_stdin, data)
 
     def _write_stdin(self, data):
         """Write to add-on stdin.
@@ -352,15 +403,15 @@ class DockerAddon(DockerInterface):
             return False
 
         try:
-            # load needed docker objects
-            container = self._docker.containers.get(self.name)
+            # Load needed docker objects
+            container = self.sys_docker.containers.get(self.name)
             socket = container.attach_socket(params={'stdin': 1, 'stream': 1})
         except docker.errors.DockerException as err:
             _LOGGER.error("Can't attach to %s stdin: %s", self.name, err)
             return False
 
         try:
-            # write to stdin
+            # Write to stdin
             data += b"\n"
             os.write(socket.fileno(), data)
             socket.close()

hassio/docker/hassos_cli.py

@@ -0,0 +1,37 @@
+"""HassOS Cli docker object."""
+import logging
+
+import docker
+
+from .interface import DockerInterface
+from ..coresys import CoreSysAttributes
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class DockerHassOSCli(DockerInterface, CoreSysAttributes):
+    """Docker Hass.io wrapper for HassOS Cli."""
+
+    @property
+    def image(self):
+        """Return name of HassOS CLI image."""
+        return f"homeassistant/{self.sys_arch}-hassio-cli"
+
+    def _stop(self):
+        """Don't need stop."""
+        return True
+
+    def _attach(self):
+        """Attach to running Docker container.
+        Need run inside executor.
+        """
+        try:
+            image = self.sys_docker.images.get(self.image)
+
+        except docker.errors.DockerException:
+            _LOGGER.warning("Can't find a HassOS CLI %s", self.image)
+
+        else:
+            self._meta = image.attrs
+            _LOGGER.info("Found HassOS CLI %s with version %s",
+                         self.image, self.version)

hassio/docker/homeassistant.py

@@ -1,10 +1,10 @@
-"""Init file for HassIO docker object."""
+"""Init file for Hass.io Docker object."""
 import logging
 
 import docker
 
 from .interface import DockerInterface
-from ..const import ENV_TOKEN, ENV_TIME
+from ..const import ENV_TOKEN, ENV_TIME, LABEL_MACHINE
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -12,28 +12,35 @@ HASS_DOCKER_NAME = 'homeassistant'
 
 
 class DockerHomeAssistant(DockerInterface):
-    """Docker hassio wrapper for HomeAssistant."""
+    """Docker Hass.io wrapper for Home Assistant."""
+
+    @property
+    def machine(self):
+        """Return machine of Home Assistant Docker image."""
+        if self._meta and LABEL_MACHINE in self._meta['Config']['Labels']:
+            return self._meta['Config']['Labels'][LABEL_MACHINE]
+        return None
 
     @property
     def image(self):
-        """Return name of docker image."""
-        return self._homeassistant.image
+        """Return name of Docker image."""
+        return self.sys_homeassistant.image
 
     @property
     def name(self):
-        """Return name of docker container."""
+        """Return name of Docker container."""
         return HASS_DOCKER_NAME
 
     @property
     def devices(self):
-        """Create list of special device to map into docker."""
+        """Create list of special device to map into Docker."""
         devices = []
-        for device in self._hardware.serial_devices:
+        for device in self.sys_hardware.serial_devices:
             devices.append(f"{device}:{device}:rwm")
         return devices or None
 
     def _run(self):
-        """Run docker image.
+        """Run Docker image.
 
         Need run inside executor.
         """
@@ -43,7 +50,7 @@ class DockerHomeAssistant(DockerInterface):
         # cleanup
         self._stop()
 
-        ret = self._docker.run(
+        ret = self.sys_docker.run(
             self.image,
             name=self.name,
             hostname=self.name,
@@ -53,16 +60,16 @@ class DockerHomeAssistant(DockerInterface):
             devices=self.devices,
             network_mode='host',
             environment={
-                'HASSIO': self._docker.network.supervisor,
-                ENV_TIME: self._config.timezone,
-                ENV_TOKEN: self._homeassistant.uuid,
+                'HASSIO': self.sys_docker.network.supervisor,
+                ENV_TIME: self.sys_timezone,
+                ENV_TOKEN: self.sys_homeassistant.hassio_token,
             },
             volumes={
-                str(self._config.path_extern_config):
+                str(self.sys_config.path_extern_homeassistant):
                     {'bind': '/config', 'mode': 'rw'},
-                str(self._config.path_extern_ssl):
+                str(self.sys_config.path_extern_ssl):
                     {'bind': '/ssl', 'mode': 'ro'},
-                str(self._config.path_extern_share):
+                str(self.sys_config.path_extern_share):
                     {'bind': '/share', 'mode': 'rw'},
             }
         )
@@ -78,26 +85,31 @@ class DockerHomeAssistant(DockerInterface):
 
         Need run inside executor.
         """
-        return self._docker.run_command(
+        return self.sys_docker.run_command(
             self.image,
             command,
+            privileged=True,
+            init=True,
+            devices=self.devices,
             detach=True,
             stdout=True,
             stderr=True,
             environment={
-                ENV_TIME: self._config.timezone,
+                ENV_TIME: self.sys_timezone,
             },
             volumes={
-                str(self._config.path_extern_config):
-                    {'bind': '/config', 'mode': 'ro'},
-                str(self._config.path_extern_ssl):
+                str(self.sys_config.path_extern_homeassistant):
+                    {'bind': '/config', 'mode': 'rw'},
+                str(self.sys_config.path_extern_ssl):
                     {'bind': '/ssl', 'mode': 'ro'},
+                str(self.sys_config.path_extern_share):
+                    {'bind': '/share', 'mode': 'ro'},
             }
         )
 
     def is_initialize(self):
-        """Return True if docker container exists."""
-        return self._loop.run_in_executor(None, self._is_initialize)
+        """Return True if Docker container exists."""
+        return self.sys_run_in_executor(self._is_initialize)
 
     def _is_initialize(self):
         """Return True if docker container exists.
@@ -105,7 +117,7 @@ class DockerHomeAssistant(DockerInterface):
         Need run inside executor.
         """
         try:
-            self._docker.containers.get(self.name)
+            self.sys_docker.containers.get(self.name)
         except docker.errors.DockerException:
             return False
 

hassio/docker/interface.py

@@ -1,76 +1,82 @@
-"""Interface class for HassIO docker object."""
+"""Interface class for Hass.io Docker object."""
 import asyncio
 from contextlib import suppress
 import logging
 
 import docker
 
-from .utils import docker_process
 from .stats import DockerStats
 from ..const import LABEL_VERSION, LABEL_ARCH
 from ..coresys import CoreSysAttributes
+from ..utils import process_lock
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class DockerInterface(CoreSysAttributes):
-    """Docker hassio interface."""
+    """Docker Hass.io interface."""
 
     def __init__(self, coresys):
-        """Initialize docker base wrapper."""
+        """Initialize Docker base wrapper."""
         self.coresys = coresys
         self._meta = None
-        self.lock = asyncio.Lock(loop=self._loop)
+        self.lock = asyncio.Lock(loop=coresys.loop)
 
     @property
     def timeout(self):
-        """Return timeout for docker actions."""
+        """Return timeout for Docker actions."""
         return 30
 
     @property
     def name(self):
-        """Return name of docker container."""
+        """Return name of Docker container."""
         return None
 
+    @property
+    def meta_config(self):
+        """Return meta data of configuration for container/image."""
+        if not self._meta:
+            return {}
+        return self._meta.get('Config', {})
+
+    @property
+    def meta_labels(self):
+        """Return meta data of labels for container/image."""
+        return self.meta_config.get('Labels') or {}
+
     @property
     def image(self):
-        """Return name of docker image."""
-        if not self._meta:
-            return None
-        return self._meta['Config']['Image']
+        """Return name of Docker image."""
+        return self.meta_config.get('Image')
 
     @property
     def version(self):
-        """Return version of docker image."""
-        if self._meta and LABEL_VERSION in self._meta['Config']['Labels']:
-            return self._meta['Config']['Labels'][LABEL_VERSION]
-        return None
+        """Return version of Docker image."""
+        return self.meta_labels.get(LABEL_VERSION)
 
     @property
     def arch(self):
-        """Return arch of docker image."""
-        if self._meta and LABEL_ARCH in self._meta['Config']['Labels']:
-            return self._meta['Config']['Labels'][LABEL_ARCH]
-        return None
+        """Return arch of Docker image."""
+        return self.meta_labels.get(LABEL_ARCH)
 
     @property
     def in_progress(self):
         """Return True if a task is in progress."""
         return self.lock.locked()
 
-    @docker_process
+    @process_lock
     def install(self, tag):
         """Pull docker image."""
-        return self._loop.run_in_executor(None, self._install, tag)
+        return self.sys_run_in_executor(self._install, tag)
 
     def _install(self, tag):
-        """Pull docker image.
+        """Pull Docker image.
 
         Need run inside executor.
         """
         try:
             _LOGGER.info("Pull image %s tag %s.", self.image, tag)
-            image = self._docker.images.pull(f"{self.image}:{tag}")
+            image = self.sys_docker.images.pull(f"{self.image}:{tag}")
 
             image.tag(self.image, tag='latest')
             self._meta = image.attrs
@@ -82,16 +88,16 @@ class DockerInterface(CoreSysAttributes):
         return True
 
     def exists(self):
-        """Return True if docker image exists in local repo."""
-        return self._loop.run_in_executor(None, self._exists)
+        """Return True if Docker image exists in local repository."""
+        return self.sys_run_in_executor(self._exists)
 
     def _exists(self):
-        """Return True if docker image exists in local repo.
+        """Return True if Docker image exists in local repository.
 
         Need run inside executor.
         """
         try:
-            image = self._docker.images.get(self.image)
+            image = self.sys_docker.images.get(self.image)
             assert f"{self.image}:{self.version}" in image.tags
         except (docker.errors.DockerException, AssertionError):
             return False
@@ -99,20 +105,20 @@ class DockerInterface(CoreSysAttributes):
         return True
 
     def is_running(self):
-        """Return True if docker is Running.
+        """Return True if Docker is running.
 
         Return a Future.
         """
-        return self._loop.run_in_executor(None, self._is_running)
+        return self.sys_run_in_executor(self._is_running)
 
     def _is_running(self):
-        """Return True if docker is Running.
+        """Return True if Docker is running.
 
         Need run inside executor.
         """
         try:
-            container = self._docker.containers.get(self.name)
-            image = self._docker.images.get(self.image)
+            container = self.sys_docker.containers.get(self.name)
+            image = self.sys_docker.images.get(self.image)
         except docker.errors.DockerException:
             return False
 
@@ -120,16 +126,16 @@ class DockerInterface(CoreSysAttributes):
         if container.status != 'running':
             return False
 
-        # we run on a old image, stop and start it
+        # we run on an old image, stop and start it
         if container.image.id != image.id:
             return False
 
         return True
 
-    @docker_process
+    @process_lock
     def attach(self):
-        """Attach to running docker container."""
-        return self._loop.run_in_executor(None, self._attach)
+        """Attach to running Docker container."""
+        return self.sys_run_in_executor(self._attach)
 
     def _attach(self):
         """Attach to running docker container.
@@ -138,9 +144,9 @@ class DockerInterface(CoreSysAttributes):
         """
         try:
             if self.image:
-                self._meta = self._docker.images.get(self.image).attrs
+                self._meta = self.sys_docker.images.get(self.image).attrs
             else:
-                self._meta = self._docker.containers.get(self.name).attrs
+                self._meta = self.sys_docker.containers.get(self.name).attrs
         except docker.errors.DockerException:
             return False
 
@@ -149,22 +155,22 @@ class DockerInterface(CoreSysAttributes):
 
         return True
 
-    @docker_process
+    @process_lock
     def run(self):
-        """Run docker image."""
-        return self._loop.run_in_executor(None, self._run)
+        """Run Docker image."""
+        return self.sys_run_in_executor(self._run)
 
     def _run(self):
-        """Run docker image.
+        """Run Docker image.
 
         Need run inside executor.
         """
         raise NotImplementedError()
 
-    @docker_process
+    @process_lock
     def stop(self):
-        """Stop/remove docker container."""
-        return self._loop.run_in_executor(None, self._stop)
+        """Stop/remove Docker container."""
+        return self.sys_run_in_executor(self._stop)
 
     def _stop(self):
         """Stop/remove and remove docker container.
@@ -172,44 +178,44 @@ class DockerInterface(CoreSysAttributes):
         Need run inside executor.
         """
         try:
-            container = self._docker.containers.get(self.name)
+            container = self.sys_docker.containers.get(self.name)
         except docker.errors.DockerException:
             return False
 
         if container.status == 'running':
-            _LOGGER.info("Stop %s docker application", self.image)
+            _LOGGER.info("Stop %s Docker application", self.image)
             with suppress(docker.errors.DockerException):
                 container.stop(timeout=self.timeout)
 
         with suppress(docker.errors.DockerException):
-            _LOGGER.info("Clean %s docker application", self.image)
+            _LOGGER.info("Clean %s Docker application", self.image)
             container.remove(force=True)
 
         return True
 
-    @docker_process
+    @process_lock
     def remove(self):
-        """Remove docker images."""
-        return self._loop.run_in_executor(None, self._remove)
+        """Remove Docker images."""
+        return self.sys_run_in_executor(self._remove)
 
     def _remove(self):
         """remove docker images.
 
         Need run inside executor.
         """
-        # cleanup container
+        # Cleanup container
         self._stop()
 
         _LOGGER.info(
-            "Remove docker %s with latest and %s", self.image, self.version)
+            "Remove Docker %s with latest and %s", self.image, self.version)
 
         try:
             with suppress(docker.errors.ImageNotFound):
-                self._docker.images.remove(
+                self.sys_docker.images.remove(
                     image=f"{self.image}:latest", force=True)
 
             with suppress(docker.errors.ImageNotFound):
-                self._docker.images.remove(
+                self.sys_docker.images.remove(
                     image=f"{self.image}:{self.version}", force=True)
 
         except docker.errors.DockerException as err:
@@ -219,10 +225,10 @@ class DockerInterface(CoreSysAttributes):
         self._meta = None
         return True
 
-    @docker_process
+    @process_lock
     def update(self, tag):
-        """Update a docker image."""
-        return self._loop.run_in_executor(None, self._update, tag)
+        """Update a Docker image."""
+        return self.sys_run_in_executor(self._update, tag)
 
     def _update(self, tag):
         """Update a docker image.
@@ -230,69 +236,44 @@ class DockerInterface(CoreSysAttributes):
         Need run inside executor.
         """
         _LOGGER.info(
-            "Update docker %s with %s:%s", self.version, self.image, tag)
+            "Update Docker %s with %s:%s", self.version, self.image, tag)
 
-        # update docker image
+        # Update docker image
         if not self._install(tag):
             return False
 
-        # stop container & cleanup
+        # Stop container & cleanup
         self._stop()
         self._cleanup()
 
         return True
 
     def logs(self):
-        """Return docker logs of container.
+        """Return Docker logs of container.
 
         Return a Future.
         """
-        return self._loop.run_in_executor(None, self._logs)
+        return self.sys_run_in_executor(self._logs)
 
     def _logs(self):
-        """Return docker logs of container.
+        """Return Docker logs of container.
 
         Need run inside executor.
         """
         try:
-            container = self._docker.containers.get(self.name)
+            container = self.sys_docker.containers.get(self.name)
         except docker.errors.DockerException:
             return b""
 
         try:
             return container.logs(tail=100, stdout=True, stderr=True)
         except docker.errors.DockerException as err:
-            _LOGGER.warning("Can't grap logs from %s: %s", self.image, err)
+            _LOGGER.warning("Can't grep logs from %s: %s", self.image, err)
 
-    @docker_process
-    def restart(self):
-        """Restart docker container."""
-        return self._loop.run_in_executor(None, self._restart)
-
-    def _restart(self):
-        """Restart docker container.
-
-        Need run inside executor.
-        """
-        try:
-            container = self._docker.containers.get(self.name)
-        except docker.errors.DockerException:
-            return False
-
-        _LOGGER.info("Restart %s", self.image)
-
-        try:
-            container.restart(timeout=self.timeout)
-        except docker.errors.DockerException as err:
-            _LOGGER.warning("Can't restart %s: %s", self.image, err)
-            return False
-
-        return True
-
-    @docker_process
+    @process_lock
     def cleanup(self):
         """Check if old version exists and cleanup."""
-        return self._loop.run_in_executor(None, self._cleanup)
+        return self.sys_run_in_executor(self._cleanup)
 
     def _cleanup(self):
         """Check if old version exists and cleanup.
@@ -300,25 +281,25 @@ class DockerInterface(CoreSysAttributes):
         Need run inside executor.
         """
         try:
-            latest = self._docker.images.get(self.image)
+            latest = self.sys_docker.images.get(self.image)
         except docker.errors.DockerException:
             _LOGGER.warning("Can't find %s for cleanup", self.image)
             return False
 
-        for image in self._docker.images.list(name=self.image):
+        for image in self.sys_docker.images.list(name=self.image):
             if latest.id == image.id:
                 continue
 
             with suppress(docker.errors.DockerException):
-                _LOGGER.info("Cleanup docker images: %s", image.tags)
-                self._docker.images.remove(image.id, force=True)
+                _LOGGER.info("Cleanup Docker images: %s", image.tags)
+                self.sys_docker.images.remove(image.id, force=True)
 
         return True
 
-    @docker_process
+    @process_lock
     def execute_command(self, command):
         """Create a temporary container and run command."""
-        return self._loop.run_in_executor(None, self._execute_command, command)
+        return self.sys_run_in_executor(self._execute_command, command)
 
     def _execute_command(self, command):
         """Create a temporary container and run command.
@@ -329,7 +310,7 @@ class DockerInterface(CoreSysAttributes):
 
     def stats(self):
         """Read and return stats from container."""
-        return self._loop.run_in_executor(None, self._stats)
+        return self.sys_run_in_executor(self._stats)
 
     def _stats(self):
         """Create a temporary container and run command.
@@ -337,7 +318,7 @@ class DockerInterface(CoreSysAttributes):
         Need run inside executor.
         """
         try:
-            container = self._docker.containers.get(self.name)
+            container = self.sys_docker.containers.get(self.name)
         except docker.errors.DockerException:
             return None
 

hassio/docker/network.py

@@ -1,4 +1,4 @@
-"""Internal network manager for HassIO."""
+"""Internal network manager for Hass.io."""
 import logging
 
 import docker
@@ -8,14 +8,14 @@ from ..const import DOCKER_NETWORK_MASK, DOCKER_NETWORK, DOCKER_NETWORK_RANGE
 _LOGGER = logging.getLogger(__name__)
 
 
-class DockerNetwork(object):
-    """Internal HassIO Network.
+class DockerNetwork:
+    """Internal Hass.io Network.
 
     This class is not AsyncIO safe!
     """
 
     def __init__(self, dock):
-        """Initialize internal hassio network."""
+        """Initialize internal Hass.io network."""
         self.docker = dock
         self.network = self._get_network()
 
@@ -44,7 +44,7 @@ class DockerNetwork(object):
         try:
             return self.docker.networks.get(DOCKER_NETWORK)
         except docker.errors.NotFound:
-            _LOGGER.info("Can't find HassIO network, create new network")
+            _LOGGER.info("Can't find Hass.io network, create new network")
 
         ipam_pool = docker.types.IPAMPool(
             subnet=str(DOCKER_NETWORK_MASK),
@@ -61,7 +61,7 @@ class DockerNetwork(object):
             })
 
     def attach_container(self, container, alias=None, ipv4=None):
-        """Attach container to hassio network.
+        """Attach container to Hass.io network.
 
         Need run inside executor.
         """
@@ -77,7 +77,7 @@ class DockerNetwork(object):
         return True
 
     def detach_default_bridge(self, container):
-        """Detach default docker bridge.
+        """Detach default Docker bridge.
 
         Need run inside executor.
         """

hassio/docker/stats.py

@@ -1,12 +1,12 @@
-"""Calc & represent docker stats data."""
+"""Calc and represent docker stats data."""
 from contextlib import suppress
 
 
-class DockerStats(object):
+class DockerStats:
     """Hold stats data from container inside."""
 
     def __init__(self, stats):
-        """Initialize docker stats."""
+        """Initialize Docker stats."""
         self._cpu = 0.0
         self._network_rx = 0
         self._network_tx = 0

hassio/docker/supervisor.py

@@ -1,4 +1,4 @@
-"""Init file for HassIO docker object."""
+"""Init file for Hass.io Docker object."""
 import logging
 import os
 
@@ -11,11 +11,11 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class DockerSupervisor(DockerInterface, CoreSysAttributes):
-    """Docker hassio wrapper for HomeAssistant."""
+    """Docker Hass.io wrapper for Supervisor."""
 
     @property
     def name(self):
-        """Return name of docker container."""
+        """Return name of Docker container."""
         return os.environ['SUPERVISOR_NAME']
 
     def _attach(self):
@@ -24,18 +24,19 @@ class DockerSupervisor(DockerInterface, CoreSysAttributes):
         Need run inside executor.
         """
         try:
-            container = self._docker.containers.get(self.name)
+            container = self.sys_docker.containers.get(self.name)
         except docker.errors.DockerException:
             return False
 
         self._meta = container.attrs
-        _LOGGER.info("Attach to supervisor %s with version %s",
+        _LOGGER.info("Attach to Supervisor %s with version %s",
                      self.image, self.version)
 
-        # if already attach
-        if container in self._docker.network.containers:
+        # If already attach
+        if container in self.sys_docker.network.containers:
             return True
 
-        # attach to network
-        return self._docker.network.attach_container(
-            container, alias=['hassio'], ipv4=self._docker.network.supervisor)
+        # Attach to network
+        return self.sys_docker.network.attach_container(
+            container, alias=['hassio'],
+            ipv4=self.sys_docker.network.supervisor)

hassio/docker/utils.py

@@ -1,20 +0,0 @@
-"""HassIO docker utilitys."""
-import logging
-
-_LOGGER = logging.getLogger(__name__)
-
-
-# pylint: disable=protected-access
-def docker_process(method):
-    """Wrap function with only run once."""
-    async def wrap_api(api, *args, **kwargs):
-        """Return api wrapper."""
-        if api.lock.locked():
-            _LOGGER.error(
-                "Can't excute %s while a task is in progress", method.__name__)
-            return False
-
-        async with api.lock:
-            return await method(api, *args, **kwargs)
-
-    return wrap_api

hassio/exceptions.py

@@ -0,0 +1,141 @@
+"""Core Exceptions."""
+
+
+class HassioError(Exception):
+    """Root exception."""
+    pass
+
+
+class HassioNotSupportedError(HassioError):
+    """Function is not supported."""
+    pass
+
+
+# HomeAssistant
+
+class HomeAssistantError(HassioError):
+    """Home Assistant exception."""
+    pass
+
+
+class HomeAssistantUpdateError(HomeAssistantError):
+    """Error on update of a Home Assistant."""
+    pass
+
+
+class HomeAssistantAPIError(HomeAssistantError):
+    """Home Assistant API exception."""
+    pass
+
+
+class HomeAssistantAuthError(HomeAssistantAPIError):
+    """Home Assistant Auth API exception."""
+    pass
+
+
+# HassOS
+
+class HassOSError(HassioError):
+    """HassOS exception."""
+    pass
+
+
+class HassOSUpdateError(HassOSError):
+    """Error on update of a HassOS."""
+    pass
+
+
+class HassOSNotSupportedError(HassioNotSupportedError):
+    """Function not supported by HassOS."""
+    pass
+
+
+# Updater
+
+class HassioUpdaterError(HassioError):
+    """Error on Updater."""
+    pass
+
+
+# Host
+
+class HostError(HassioError):
+    """Internal Host error."""
+    pass
+
+
+class HostNotSupportedError(HassioNotSupportedError):
+    """Host function is not supprted."""
+    pass
+
+
+class HostServiceError(HostError):
+    """Host service functions fails."""
+    pass
+
+
+class HostAppArmorError(HostError):
+    """Host apparmor functions fails."""
+    pass
+
+
+# API
+
+class APIError(HassioError, RuntimeError):
+    """API errors."""
+    pass
+
+
+class APIForbidden(APIError):
+    """API forbidden error."""
+    pass
+
+
+# Service / Discovery
+
+class DiscoveryError(HassioError):
+    """Discovery Errors."""
+    pass
+
+
+class ServicesError(HassioError):
+    """Services Errors."""
+    pass
+
+
+# utils/gdbus
+
+class DBusError(HassioError):
+    """DBus generic error."""
+    pass
+
+
+class DBusNotConnectedError(HostNotSupportedError):
+    """DBus is not connected and call a method."""
+
+
+class DBusFatalError(DBusError):
+    """DBus call going wrong."""
+    pass
+
+
+class DBusParseError(DBusError):
+    """DBus parse error."""
+    pass
+
+
+# util/apparmor
+
+class AppArmorError(HostAppArmorError):
+    """General AppArmor error."""
+    pass
+
+
+class AppArmorFileError(AppArmorError):
+    """AppArmor profile file error."""
+    pass
+
+
+class AppArmorInvalidError(AppArmorError):
+    """AppArmor profile validate error."""
+    pass

hassio/hassos.py

@@ -0,0 +1,186 @@
+"""HassOS support on supervisor."""
+import asyncio
+import logging
+from pathlib import Path
+
+import aiohttp
+from cpe import CPE
+
+from .coresys import CoreSysAttributes
+from .const import URL_HASSOS_OTA
+from .docker.hassos_cli import DockerHassOSCli
+from .exceptions import HassOSNotSupportedError, HassOSUpdateError, DBusError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class HassOS(CoreSysAttributes):
+    """HassOS interface inside HassIO."""
+
+    def __init__(self, coresys):
+        """Initialize HassOS handler."""
+        self.coresys = coresys
+        self.instance = DockerHassOSCli(coresys)
+        self._available = False
+        self._version = None
+        self._board = None
+
+    @property
+    def available(self):
+        """Return True, if HassOS on host."""
+        return self._available
+
+    @property
+    def version(self):
+        """Return version of HassOS."""
+        return self._version
+
+    @property
+    def version_cli(self):
+        """Return version of HassOS cli."""
+        return self.instance.version
+
+    @property
+    def version_latest(self):
+        """Return version of HassOS."""
+        return self.sys_updater.version_hassos
+
+    @property
+    def version_cli_latest(self):
+        """Return version of HassOS."""
+        return self.sys_updater.version_hassos_cli
+
+    @property
+    def need_update(self):
+        """Return true if a HassOS update is available."""
+        return self.version != self.version_latest
+
+    @property
+    def need_cli_update(self):
+        """Return true if a HassOS cli update is available."""
+        return self.version_cli != self.version_cli_latest
+
+    @property
+    def board(self):
+        """Return board name."""
+        return self._board
+
+    def _check_host(self):
+        """Check if HassOS is availabe."""
+        if not self.available:
+            _LOGGER.error("No HassOS available")
+            raise HassOSNotSupportedError()
+
+    async def _download_raucb(self, version):
+        """Download rauc bundle (OTA) from github."""
+        url = URL_HASSOS_OTA.format(version=version, board=self.board)
+        raucb = Path(self.sys_config.path_tmp, f"hassos-{version}.raucb")
+
+        try:
+            _LOGGER.info("Fetch OTA update from %s", url)
+            async with self.sys_websession.get(url) as request:
+                if request.status != 200:
+                    raise HassOSUpdateError()
+
+                # Download RAUCB file
+                with raucb.open('wb') as ota_file:
+                    while True:
+                        chunk = await request.content.read(1048576)
+                        if not chunk:
+                            break
+                        ota_file.write(chunk)
+
+            _LOGGER.info("OTA update is downloaded on %s", raucb)
+            return raucb
+
+        except (aiohttp.ClientError, asyncio.TimeoutError) as err:
+            _LOGGER.warning("Can't fetch versions from %s: %s", url, err)
+
+        except OSError as err:
+            _LOGGER.error("Can't write OTA file: %s", err)
+
+        raise HassOSUpdateError()
+
+    async def load(self):
+        """Load HassOS data."""
+        try:
+            # Check needed host functions
+            assert self.sys_dbus.rauc.is_connected
+            assert self.sys_dbus.systemd.is_connected
+            assert self.sys_dbus.hostname.is_connected
+
+            assert self.sys_host.info.cpe is not None
+            cpe = CPE(self.sys_host.info.cpe)
+            assert cpe.get_product()[0] == 'hassos'
+        except (AssertionError, NotImplementedError):
+            _LOGGER.debug("Found no HassOS")
+            return
+
+        # Store meta data
+        self._available = True
+        self._version = cpe.get_version()[0]
+        self._board = cpe.get_target_hardware()[0]
+
+        _LOGGER.info("Detect HassOS %s on host system", self.version)
+        await self.instance.attach()
+
+    def config_sync(self):
+        """Trigger a host config reload from usb.
+
+        Return a coroutine.
+        """
+        self._check_host()
+
+        _LOGGER.info("Syncing configuration from USB with HassOS.")
+        return self.sys_host.services.restart('hassos-config.service')
+
+    async def update(self, version=None):
+        """Update HassOS system."""
+        version = version or self.version_latest
+
+        # Check installed version
+        self._check_host()
+        if version == self.version:
+            _LOGGER.warning("Version %s is already installed", version)
+            raise HassOSUpdateError()
+
+        # Fetch files from internet
+        int_ota = await self._download_raucb(version)
+        ext_ota = Path(self.sys_config.path_extern_tmp, int_ota.name)
+
+        try:
+            await self.sys_dbus.rauc.install(ext_ota)
+            completed = await self.sys_dbus.rauc.signal_completed()
+
+        except DBusError:
+            _LOGGER.error("Rauc communication error")
+            raise HassOSUpdateError() from None
+
+        finally:
+            int_ota.unlink()
+
+        # Update success
+        if 0 in completed:
+            _LOGGER.info("Install HassOS %s success", version)
+            self.sys_create_task(self.sys_host.control.reboot())
+            return
+
+        # Update fails
+        rauc_status = await self.sys_dbus.get_properties()
+        _LOGGER.error(
+            "HassOS update fails with: %s", rauc_status.get('LastError'))
+        raise HassOSUpdateError()
+
+    async def update_cli(self, version=None):
+        """Update local HassOS cli."""
+        version = version or self.version_cli_latest
+
+        if version == self.version_cli:
+            _LOGGER.warning("Version %s is already installed for CLI", version)
+            raise HassOSUpdateError()
+
+        if await self.instance.update(version):
+            return
+
+        _LOGGER.error("HassOS CLI update fails")
+        raise HassOSUpdateError()

hassio/homeassistant.py

@@ -1,22 +1,29 @@
-"""HomeAssistant control object."""
+"""Home Assistant control object."""
 import asyncio
-from collections import namedtuple
+from contextlib import asynccontextmanager, suppress
+from datetime import datetime, timedelta
 import logging
 import os
 import re
+from pathlib import Path
 import socket
 import time
 
 import aiohttp
-from aiohttp.hdrs import CONTENT_TYPE
+from aiohttp import hdrs
+import attr
 
 from .const import (
     FILE_HASSIO_HOMEASSISTANT, ATTR_IMAGE, ATTR_LAST_VERSION, ATTR_UUID,
     ATTR_BOOT, ATTR_PASSWORD, ATTR_PORT, ATTR_SSL, ATTR_WATCHDOG,
-    ATTR_WAIT_BOOT, HEADER_HA_ACCESS, CONTENT_TYPE_JSON)
+    ATTR_WAIT_BOOT, ATTR_REFRESH_TOKEN, ATTR_ACCESS_TOKEN,
+    HEADER_HA_ACCESS)
 from .coresys import CoreSysAttributes
 from .docker.homeassistant import DockerHomeAssistant
-from .utils import convert_to_ascii
+from .exceptions import (
+    HomeAssistantUpdateError, HomeAssistantError, HomeAssistantAPIError,
+    HomeAssistantAuthError)
+from .utils import convert_to_ascii, process_lock, create_token
 from .utils.json import JsonConfig
 from .validate import SCHEMA_HASS_CONFIG
 
@@ -24,103 +31,123 @@ _LOGGER = logging.getLogger(__name__)
 
 RE_YAML_ERROR = re.compile(r"homeassistant\.util\.yaml")
 
-ConfigResult = namedtuple('ConfigResult', ['valid', 'log'])
+
+@attr.s(frozen=True)
+class ConfigResult:
+    """Return object from config check."""
+    valid = attr.ib()
+    log = attr.ib()
 
 
 class HomeAssistant(JsonConfig, CoreSysAttributes):
-    """Hass core object for handle it."""
+    """Home Assistant core object for handle it."""
 
     def __init__(self, coresys):
-        """Initialize hass object."""
+        """Initialize Home Assistant object."""
         super().__init__(FILE_HASSIO_HOMEASSISTANT, SCHEMA_HASS_CONFIG)
         self.coresys = coresys
         self.instance = DockerHomeAssistant(coresys)
+        self.lock = asyncio.Lock(loop=coresys.loop)
+        self._error_state = False
+        # We don't persist access tokens. Instead we fetch new ones when needed
+        self.access_token = None
+        self._access_token_expires = None
 
     async def load(self):
-        """Prepare HomeAssistant object."""
+        """Prepare Home Assistant object."""
         if await self.instance.attach():
             return
 
-        _LOGGER.info("No HomeAssistant docker %s found.", self.image)
+        _LOGGER.info("No Home Assistant Docker image %s found.", self.image)
         await self.install_landingpage()
 
+    @property
+    def machine(self):
+        """Return the system machines."""
+        return self.instance.machine
+
+    @property
+    def error_state(self):
+        """Return True if system is in error."""
+        return self._error_state
+
     @property
     def api_ip(self):
-        """Return IP of HomeAssistant instance."""
-        return self._docker.network.gateway
+        """Return IP of Home Assistant instance."""
+        return self.sys_docker.network.gateway
 
     @property
     def api_port(self):
-        """Return network port to home-assistant instance."""
+        """Return network port to Home Assistant instance."""
         return self._data[ATTR_PORT]
 
     @api_port.setter
     def api_port(self, value):
-        """Set network port for home-assistant instance."""
+        """Set network port for Home Assistant instance."""
         self._data[ATTR_PORT] = value
 
     @property
     def api_password(self):
-        """Return password for home-assistant instance."""
+        """Return password for Home Assistant instance."""
         return self._data.get(ATTR_PASSWORD)
 
     @api_password.setter
     def api_password(self, value):
-        """Set password for home-assistant instance."""
+        """Set password for Home Assistant instance."""
         self._data[ATTR_PASSWORD] = value
 
     @property
     def api_ssl(self):
-        """Return if we need ssl to home-assistant instance."""
+        """Return if we need ssl to Home Assistant instance."""
         return self._data[ATTR_SSL]
 
     @api_ssl.setter
     def api_ssl(self, value):
-        """Set SSL for home-assistant instance."""
+        """Set SSL for Home Assistant instance."""
         self._data[ATTR_SSL] = value
 
     @property
     def api_url(self):
-        """Return API url to Home-Assistant."""
+        """Return API url to Home Assistant."""
         return "{}://{}:{}".format(
             'https' if self.api_ssl else 'http', self.api_ip, self.api_port
         )
 
     @property
     def watchdog(self):
-        """Return True if the watchdog should protect Home-Assistant."""
+        """Return True if the watchdog should protect Home Assistant."""
         return self._data[ATTR_WATCHDOG]
 
     @watchdog.setter
     def watchdog(self, value):
-        """Return True if the watchdog should protect Home-Assistant."""
+        """Return True if the watchdog should protect Home Assistant."""
         self._data[ATTR_WATCHDOG] = value
 
     @property
     def wait_boot(self):
-        """Return time to wait for Home-Assistant startup."""
+        """Return time to wait for Home Assistant startup."""
         return self._data[ATTR_WAIT_BOOT]
 
     @wait_boot.setter
     def wait_boot(self, value):
-        """Set time to wait for Home-Assistant startup."""
+        """Set time to wait for Home Assistant startup."""
         self._data[ATTR_WAIT_BOOT] = value
 
     @property
     def version(self):
-        """Return version of running homeassistant."""
+        """Return version of running Home Assistant."""
         return self.instance.version
 
     @property
     def last_version(self):
-        """Return last available version of homeassistant."""
+        """Return last available version of Home Assistant."""
         if self.is_custom_image:
             return self._data.get(ATTR_LAST_VERSION)
-        return self._updater.version_homeassistant
+        return self.sys_updater.version_homeassistant
 
     @last_version.setter
     def last_version(self, value):
-        """Set last available version of homeassistant."""
+        """Set last available version of Home Assistant."""
         if value:
             self._data[ATTR_LAST_VERSION] = value
         else:
@@ -128,14 +155,14 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
 
     @property
     def image(self):
-        """Return image name of hass containter."""
+        """Return image name of the Home Assistant container."""
         if self._data.get(ATTR_IMAGE):
             return self._data[ATTR_IMAGE]
         return os.environ['HOMEASSISTANT_REPOSITORY']
 
     @image.setter
     def image(self, value):
-        """Set image name of hass containter."""
+        """Set image name of Home Assistant container."""
         if value:
             self._data[ATTR_IMAGE] = value
         else:
@@ -149,87 +176,149 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
 
     @property
     def boot(self):
-        """Return True if home-assistant boot is enabled."""
+        """Return True if Home Assistant boot is enabled."""
         return self._data[ATTR_BOOT]
 
     @boot.setter
     def boot(self, value):
-        """Set home-assistant boot options."""
+        """Set Home Assistant boot options."""
         self._data[ATTR_BOOT] = value
 
     @property
     def uuid(self):
-        """Return a UUID of this HomeAssistant."""
+        """Return a UUID of this Home Assistant instance."""
         return self._data[ATTR_UUID]
 
+    @property
+    def hassio_token(self):
+        """Return a access token for the Hass.io API."""
+        return self._data.get(ATTR_ACCESS_TOKEN)
+
+    @property
+    def refresh_token(self):
+        """Return the refresh token to authenticate with Home Assistant."""
+        return self._data.get(ATTR_REFRESH_TOKEN)
+
+    @refresh_token.setter
+    def refresh_token(self, value):
+        """Set Home Assistant refresh_token."""
+        self._data[ATTR_REFRESH_TOKEN] = value
+
+    @process_lock
     async def install_landingpage(self):
-        """Install a landingpage."""
+        """Install a landing page."""
         _LOGGER.info("Setup HomeAssistant landingpage")
         while True:
             if await self.instance.install('landingpage'):
                 break
             _LOGGER.warning("Fails install landingpage, retry after 60sec")
-            await asyncio.sleep(60, loop=self._loop)
+            await asyncio.sleep(60)
 
         # Run landingpage after installation
-        await self.start()
+        _LOGGER.info("Start landing page")
+        try:
+            await self._start()
+        except HomeAssistantError:
+            _LOGGER.warning("Can't start landing page")
 
+    @process_lock
     async def install(self):
-        """Install a landingpage."""
-        _LOGGER.info("Setup HomeAssistant")
+        """Install a landing page."""
+        _LOGGER.info("Setup Home Assistant")
         while True:
             # read homeassistant tag and install it
             if not self.last_version:
-                await self._updater.reload()
+                await self.sys_updater.reload()
 
             tag = self.last_version
             if tag and await self.instance.install(tag):
                 break
-            _LOGGER.warning("Error on install HomeAssistant. Retry in 60sec")
-            await asyncio.sleep(60, loop=self._loop)
+            _LOGGER.warning("Error on install Home Assistant. Retry in 60sec")
+            await asyncio.sleep(60)
 
         # finishing
-        _LOGGER.info("HomeAssistant docker now installed")
-        if self.boot:
-            await self.start()
-        await self.instance.cleanup()
+        _LOGGER.info("Home Assistant docker now installed")
+        try:
+            if not self.boot:
+                return
+            _LOGGER.info("Start Home Assistant")
+            await self._start()
+        except HomeAssistantError:
+            _LOGGER.error("Can't start Home Assistant!")
+        finally:
+            await self.instance.cleanup()
 
+    @process_lock
     async def update(self, version=None):
         """Update HomeAssistant version."""
         version = version or self.last_version
+        rollback = self.version if not self.error_state else None
         running = await self.instance.is_running()
         exists = await self.instance.exists()
 
         if exists and version == self.instance.version:
-            _LOGGER.info("Version %s is already installed", version)
-            return False
+            _LOGGER.warning("Version %s is already installed", version)
+            return HomeAssistantUpdateError()
 
-        try:
-            return await self.instance.update(version)
-        finally:
-            if running:
-                await self.start()
+        # process a update
+        async def _update(to_version):
+            """Run Home Assistant update."""
+            try:
+                _LOGGER.info("Update Home Assistant to version %s", to_version)
+                if not await self.instance.update(to_version):
+                    raise HomeAssistantUpdateError()
+            finally:
+                if running:
+                    await self._start()
+                _LOGGER.info("Successful run Home Assistant %s", to_version)
+
+        # Update Home Assistant
+        with suppress(HomeAssistantError):
+            await _update(version)
+            return
+
+        # Update going wrong, revert it
+        if self.error_state and rollback:
+            _LOGGER.fatal("HomeAssistant update fails -> rollback!")
+            await _update(rollback)
+        else:
+            raise HomeAssistantUpdateError()
+
+    async def _start(self):
+        """Start Home Assistant Docker & wait."""
+        if await self.instance.is_running():
+            _LOGGER.warning("Home Assistant is already running!")
+            return
+
+        # Create new API token
+        self._data[ATTR_ACCESS_TOKEN] = create_token()
+        self.save_data()
 
-    async def start(self):
-        """Run HomeAssistant docker."""
         if not await self.instance.run():
-            return False
+            raise HomeAssistantError()
+        await self._block_till_run()
 
-        return await self._block_till_run()
+    @process_lock
+    def start(self):
+        """Run Home Assistant docker.
 
+        Return a coroutine.
+        """
+        return self._start()
+
+    @process_lock
     def stop(self):
-        """Stop HomeAssistant docker.
+        """Stop Home Assistant Docker.
 
         Return a coroutine.
         """
         return self.instance.stop()
 
+    @process_lock
     async def restart(self):
-        """Restart HomeAssistant docker."""
-        if not await self.instance.restart():
-            return False
-
-        return await self._block_till_run()
+        """Restart Home Assistant Docker."""
+        await self.instance.stop()
+        await self._start()
 
     def logs(self):
         """Get HomeAssistant docker logs.
@@ -239,21 +328,21 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
         return self.instance.logs()
 
     def stats(self):
-        """Return stats of HomeAssistant.
+        """Return stats of Home Assistant.
 
         Return a coroutine.
         """
         return self.instance.stats()
 
     def is_running(self):
-        """Return True if docker container is running.
+        """Return True if Docker container is running.
 
         Return a coroutine.
         """
         return self.instance.is_running()
 
     def is_initialize(self):
-        """Return True if a docker container is exists.
+        """Return True if a Docker container is exists.
 
         Return a coroutine.
         """
@@ -262,73 +351,108 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
     @property
     def in_progress(self):
         """Return True if a task is in progress."""
-        return self.instance.in_progress
+        return self.instance.in_progress or self.lock.locked()
 
     async def check_config(self):
-        """Run homeassistant config check."""
+        """Run Home Assistant config check."""
         result = await self.instance.execute_command(
             "python3 -m homeassistant -c /config --script check_config"
         )
 
         # if not valid
         if result.exit_code is None:
-            return ConfigResult(False, "")
+            _LOGGER.error("Fatal error on config check!")
+            raise HomeAssistantError()
 
         # parse output
         log = convert_to_ascii(result.output)
         if result.exit_code != 0 or RE_YAML_ERROR.search(log):
+            _LOGGER.error("Invalid Home Assistant config found!")
             return ConfigResult(False, log)
+
+        _LOGGER.info("Home Assistant config is valid")
         return ConfigResult(True, log)
 
+    async def ensure_access_token(self):
+        """Ensures there is an access token."""
+        if (self.access_token is not None and
+                self._access_token_expires > datetime.utcnow()):
+            return
+
+        with suppress(asyncio.TimeoutError, aiohttp.ClientError):
+            async with self.sys_websession_ssl.post(
+                    f"{self.api_url}/auth/token",
+                    timeout=30,
+                    data={
+                        "grant_type": "refresh_token",
+                        "refresh_token": self.refresh_token
+                    }
+            ) as resp:
+                if resp.status != 200:
+                    _LOGGER.error("Can't update Home Assistant access token!")
+                    raise HomeAssistantAuthError()
+
+                _LOGGER.info("Updated Home Assistant API token")
+                tokens = await resp.json()
+                self.access_token = tokens['access_token']
+                self._access_token_expires = \
+                    datetime.utcnow() + timedelta(seconds=tokens['expires_in'])
+
+    @asynccontextmanager
+    async def make_request(self, method, path, json=None, content_type=None,
+                           data=None, timeout=30):
+        """Async context manager to make a request with right auth."""
+        url = f"{self.api_url}/{path}"
+        headers = {}
+
+        # Passthrough content type
+        if content_type is not None:
+            headers[hdrs.CONTENT_TYPE] = content_type
+
+        # Set old API Password
+        if self.api_password:
+            headers[HEADER_HA_ACCESS] = self.api_password
+
+        for _ in (1, 2):
+            # Prepare Access token
+            if self.refresh_token:
+                await self.ensure_access_token()
+                headers[hdrs.AUTHORIZATION] = f'Bearer {self.access_token}'
+
+            try:
+                async with getattr(self.sys_websession_ssl, method)(
+                        url, data=data, timeout=timeout, json=json,
+                        headers=headers
+                ) as resp:
+                    # Access token expired
+                    if resp.status == 401 and self.refresh_token:
+                        self.access_token = None
+                        continue
+                    yield resp
+                    return
+            except (asyncio.TimeoutError, aiohttp.ClientError) as err:
+                _LOGGER.error("Error on call %s: %s", url, err)
+                break
+
+        raise HomeAssistantAPIError()
+
     async def check_api_state(self):
-        """Check if Home-Assistant up and running."""
-        url = f"{self.api_url}/api/"
-        header = {CONTENT_TYPE: CONTENT_TYPE_JSON}
+        """Return True if Home Assistant up and running."""
+        with suppress(HomeAssistantAPIError):
+            async with self.make_request('get', 'api/') as resp:
+                if resp.status in (200, 201):
+                    return True
+                err = resp.status
 
-        if self.api_password:
-            header.update({HEADER_HA_ACCESS: self.api_password})
-
-        try:
-            # pylint: disable=bad-continuation
-            async with self._websession_ssl.get(
-                    url, headers=header, timeout=30) as request:
-                status = request.status
-
-        except (asyncio.TimeoutError, aiohttp.ClientError):
-            return False
-
-        if status not in (200, 201):
-            _LOGGER.warning("Home-Assistant API config missmatch")
-        return True
-
-    async def send_event(self, event_type, event_data=None):
-        """Send event to Home-Assistant."""
-        url = f"{self.api_url}/api/events/{event_type}"
-        header = {CONTENT_TYPE: CONTENT_TYPE_JSON}
-
-        if self.api_password:
-            header.update({HEADER_HA_ACCESS: self.api_password})
-
-        try:
-            # pylint: disable=bad-continuation
-            async with self._websession_ssl.post(
-                    url, headers=header, timeout=30,
-                    json=event_data) as request:
-                status = request.status
-
-        except (asyncio.TimeoutError, aiohttp.ClientError) as err:
-            _LOGGER.warning(
-                "Home-Assistant event %s fails: %s", event_type, err)
-            return False
-
-        if status not in (200, 201):
-            _LOGGER.warning("Home-Assistant event %s fails", event_type)
-            return False
-        return True
+        _LOGGER.warning("Home Assistant API config mismatch: %d", err)
+        return False
 
     async def _block_till_run(self):
         """Block until Home-Assistant is booting up or startup timeout."""
         start_time = time.monotonic()
+        migration_progress = False
+        migration_file = Path(
+            self.sys_config.path_homeassistant, '.migration_progress')
 
         def check_port():
             """Check if port is mapped."""
@@ -337,17 +461,47 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
                 result = sock.connect_ex((str(self.api_ip), self.api_port))
                 sock.close()
 
+                # Check if the port is available
                 if result == 0:
                     return True
-                return False
             except OSError:
                 pass
+            return False
 
-        while time.monotonic() - start_time < self.wait_boot:
-            if await self._loop.run_in_executor(None, check_port):
-                _LOGGER.info("Detect a running Home-Assistant instance")
-                return True
-            await asyncio.sleep(10, loop=self._loop)
+        while True:
+            await asyncio.sleep(10)
 
-        _LOGGER.warning("Don't wait anymore of Home-Assistant startup!")
-        return False
+            # 1
+            # Check if Container is is_running
+            if not await self.instance.is_running():
+                _LOGGER.error("Home Assistant has crashed!")
+                break
+
+            # 2
+            # Check if API response
+            if await self.sys_run_in_executor(check_port):
+                _LOGGER.info("Detect a running Home Assistant instance")
+                self._error_state = False
+                return
+
+            # 3
+            # Running DB Migration
+            if migration_file.exists():
+                if not migration_progress:
+                    migration_progress = True
+                    _LOGGER.info("Home Assistant record migration in progress")
+                continue
+            elif migration_progress:
+                migration_progress = False  # Reset start time
+                start_time = time.monotonic()
+                _LOGGER.info("Home Assistant record migration done")
+
+            # 4
+            # Timeout
+            if time.monotonic() - start_time > self.wait_boot:
+                _LOGGER.warning(
+                    "Don't wait anymore of Home Assistant startup!")
+                break
+
+        self._error_state = True
+        raise HomeAssistantError()

hassio/host/__init__.py

@@ -0,0 +1,93 @@
+"""Host function like audio, D-Bus or systemd."""
+from contextlib import suppress
+import logging
+
+from .alsa import AlsaAudio
+from .apparmor import AppArmorControl
+from .control import SystemControl
+from .info import InfoCenter
+from .services import ServiceManager
+from ..const import (
+    FEATURES_REBOOT, FEATURES_SHUTDOWN, FEATURES_HOSTNAME, FEATURES_SERVICES,
+    FEATURES_HASSOS)
+from ..coresys import CoreSysAttributes
+from ..exceptions import HassioError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class HostManager(CoreSysAttributes):
+    """Manage supported function from host."""
+
+    def __init__(self, coresys):
+        """Initialize Host manager."""
+        self.coresys = coresys
+        self._alsa = AlsaAudio(coresys)
+        self._apparmor = AppArmorControl(coresys)
+        self._control = SystemControl(coresys)
+        self._info = InfoCenter(coresys)
+        self._services = ServiceManager(coresys)
+
+    @property
+    def alsa(self):
+        """Return host ALSA handler."""
+        return self._alsa
+
+    @property
+    def apparmor(self):
+        """Return host AppArmor handler."""
+        return self._apparmor
+
+    @property
+    def control(self):
+        """Return host control handler."""
+        return self._control
+
+    @property
+    def info(self):
+        """Return host info handler."""
+        return self._info
+
+    @property
+    def services(self):
+        """Return host services handler."""
+        return self._services
+
+    @property
+    def supperted_features(self):
+        """Return a list of supported host features."""
+        features = []
+
+        if self.sys_dbus.systemd.is_connected:
+            features.extend([
+                FEATURES_REBOOT,
+                FEATURES_SHUTDOWN,
+                FEATURES_SERVICES,
+            ])
+
+        if self.sys_dbus.hostname.is_connected:
+            features.append(FEATURES_HOSTNAME)
+
+        if self.sys_hassos.available:
+            features.append(FEATURES_HASSOS)
+
+        return features
+
+    async def reload(self):
+        """Reload host functions."""
+        if self.sys_dbus.hostname.is_connected:
+            await self.info.update()
+
+        if self.sys_dbus.systemd.is_connected:
+            await self.services.update()
+
+    async def load(self):
+        """Load host information."""
+        with suppress(HassioError):
+            await self.reload()
+
+        # Load profile data
+        try:
+            await self.apparmor.load()
+        except HassioError as err:
+            _LOGGER.waring("Load host AppArmor on start fails: %s", err)

hassio/host/alsa.py

@@ -0,0 +1,137 @@
+"""Host Audio support."""
+import logging
+import json
+from pathlib import Path
+from string import Template
+
+import attr
+
+from ..const import ATTR_INPUT, ATTR_OUTPUT, ATTR_DEVICES, ATTR_NAME
+from ..coresys import CoreSysAttributes
+
+_LOGGER = logging.getLogger(__name__)
+
+# pylint: disable=invalid-name
+DefaultConfig = attr.make_class('DefaultConfig', ['input', 'output'])
+
+
+class AlsaAudio(CoreSysAttributes):
+    """Handle Audio ALSA host data."""
+
+    def __init__(self, coresys):
+        """Initialize ALSA audio system."""
+        self.coresys = coresys
+        self._data = {
+            ATTR_INPUT: {},
+            ATTR_OUTPUT: {},
+        }
+        self._cache = 0
+        self._default = None
+
+    @property
+    def input_devices(self):
+        """Return list of ALSA input devices."""
+        self._update_device()
+        return self._data[ATTR_INPUT]
+
+    @property
+    def output_devices(self):
+        """Return list of ALSA output devices."""
+        self._update_device()
+        return self._data[ATTR_OUTPUT]
+
+    def _update_device(self):
+        """Update Internal device DB."""
+        current_id = hash(frozenset(self.sys_hardware.audio_devices))
+
+        # Need rebuild?
+        if current_id == self._cache:
+            return
+
+        # Clean old stuff
+        self._data[ATTR_INPUT].clear()
+        self._data[ATTR_OUTPUT].clear()
+
+        # Init database
+        _LOGGER.info("Update ALSA device list")
+        database = self._audio_database()
+
+        # Process devices
+        for dev_id, dev_data in self.sys_hardware.audio_devices.items():
+            for chan_id, chan_type in dev_data[ATTR_DEVICES].items():
+                alsa_id = f"{dev_id},{chan_id}"
+                dev_name = dev_data[ATTR_NAME]
+
+                # Lookup type
+                if chan_type.endswith('playback'):
+                    key = ATTR_OUTPUT
+                elif chan_type.endswith('capture'):
+                    key = ATTR_INPUT
+                else:
+                    _LOGGER.warning("Unknown channel type: %s", chan_type)
+                    continue
+
+                # Use name from DB or a generic name
+                self._data[key][alsa_id] = database.get(
+                    self.sys_machine, {}).get(
+                        dev_name, {}).get(alsa_id, f"{dev_name}: {chan_id}")
+
+        self._cache = current_id
+
+    @staticmethod
+    def _audio_database():
+        """Read local json audio data into dict."""
+        json_file = Path(__file__).parent.joinpath("data/audiodb.json")
+
+        try:
+            # pylint: disable=no-member
+            with json_file.open('r') as database:
+                return json.loads(database.read())
+        except (ValueError, OSError) as err:
+            _LOGGER.warning("Can't read audio DB: %s", err)
+
+        return {}
+
+    @property
+    def default(self):
+        """Generate ALSA default setting."""
+        # Init defaults
+        if self._default is None:
+            database = self._audio_database()
+            alsa_input = database.get(self.sys_machine, {}).get(ATTR_INPUT)
+            alsa_output = database.get(self.sys_machine, {}).get(ATTR_OUTPUT)
+
+            self._default = DefaultConfig(alsa_input, alsa_output)
+
+        # Search exists/new output
+        if self._default.output is None and self.output_devices:
+            self._default.output = next(iter(self.output_devices))
+            _LOGGER.info("Detect output device %s", self._default.output)
+
+        # Search exists/new input
+        if self._default.input is None and self.input_devices:
+            self._default.input = next(iter(self.input_devices))
+            _LOGGER.info("Detect input device %s", self._default.input)
+
+        return self._default
+
+    def asound(self, alsa_input=None, alsa_output=None):
+        """Generate an asound data."""
+        alsa_input = alsa_input or self.default.input
+        alsa_output = alsa_output or self.default.output
+
+        # Read Template
+        asound_file = Path(__file__).parent.joinpath("data/asound.tmpl")
+        try:
+            # pylint: disable=no-member
+            with asound_file.open('r') as asound:
+                asound_data = asound.read()
+        except OSError as err:
+            _LOGGER.error("Can't read asound.tmpl: %s", err)
+            return ""
+
+        # Process Template
+        asound_template = Template(asound_data)
+        return asound_template.safe_substitute(
+            input=alsa_input, output=alsa_output
+        )

hassio/host/apparmor.py

@@ -0,0 +1,121 @@
+"""AppArmor control for host."""
+import logging
+import shutil
+from pathlib import Path
+
+from ..coresys import CoreSysAttributes
+from ..exceptions import DBusError, HostAppArmorError
+from ..utils.apparmor import validate_profile
+
+_LOGGER = logging.getLogger(__name__)
+
+SYSTEMD_SERVICES = {'hassos-apparmor.service', 'hassio-apparmor.service'}
+
+
+class AppArmorControl(CoreSysAttributes):
+    """Handle host AppArmor controls."""
+
+    def __init__(self, coresys):
+        """Initialize host power handling."""
+        self.coresys = coresys
+        self._profiles = set()
+        self._service = None
+
+    @property
+    def available(self):
+        """Return True if AppArmor is available on host."""
+        return self._service is not None
+
+    def exists(self, profile):
+        """Return True if a profile exists."""
+        return profile in self._profiles
+
+    async def _reload_service(self):
+        """Reload internal service."""
+        try:
+            await self.sys_host.services.reload(self._service)
+        except DBusError as err:
+            _LOGGER.error("Can't reload %s: %s", self._service, err)
+
+    def _get_profile(self, profile_name):
+        """Get a profile from AppArmor store."""
+        if profile_name not in self._profiles:
+            _LOGGER.error("Can't find %s for removing", profile_name)
+            raise HostAppArmorError()
+        return Path(self.sys_config.path_apparmor, profile_name)
+
+    async def load(self):
+        """Load available profiles."""
+        for content in self.sys_config.path_apparmor.iterdir():
+            if not content.is_file():
+                continue
+            self._profiles.add(content.name)
+
+        # Is connected with systemd?
+        _LOGGER.info("Load AppArmor Profiles: %s", self._profiles)
+        for service in SYSTEMD_SERVICES:
+            if not self.sys_host.services.exists(service):
+                continue
+            self._service = service
+
+        # Load profiles
+        if self.available:
+            await self._reload_service()
+        else:
+            _LOGGER.info("AppArmor is not enabled on host")
+
+    async def load_profile(self, profile_name, profile_file):
+        """Load/Update a new/exists profile into AppArmor."""
+        if not validate_profile(profile_name, profile_file):
+            _LOGGER.error("Profile is not valid with name %s", profile_name)
+            raise HostAppArmorError()
+
+        # Copy to AppArmor folder
+        dest_profile = Path(self.sys_config.path_apparmor, profile_name)
+        try:
+            shutil.copy(profile_file, dest_profile)
+        except OSError as err:
+            _LOGGER.error("Can't copy %s: %s", profile_file, err)
+            raise HostAppArmorError() from None
+
+        # Load profiles
+        _LOGGER.info("Add or Update AppArmor profile: %s", profile_name)
+        self._profiles.add(profile_name)
+        if self.available:
+            await self._reload_service()
+
+    async def remove_profile(self, profile_name):
+        """Remove a AppArmor profile."""
+        profile_file = self._get_profile(profile_name)
+
+        # Only remove file
+        if not self.available:
+            try:
+                profile_file.unlink()
+            except OSError as err:
+                _LOGGER.error("Can't remove profile: %s", err)
+                raise HostAppArmorError()
+            return
+
+        # Marks als remove and start host process
+        remove_profile = Path(
+            self.sys_config.path_apparmor, 'remove', profile_name)
+        try:
+            profile_file.rename(remove_profile)
+        except OSError as err:
+            _LOGGER.error("Can't mark profile as remove: %s", err)
+            raise HostAppArmorError()
+
+        _LOGGER.info("Remove AppArmor profile: %s", profile_name)
+        self._profiles.remove(profile_name)
+        await self._reload_service()
+
+    def backup_profile(self, profile_name, backup_file):
+        """Backup A profile into a new file."""
+        profile_file = self._get_profile(profile_name)
+
+        try:
+            shutil.copy(profile_file, backup_file)
+        except OSError as err:
+            _LOGGER.error("Can't backup profile %s: %s", profile_name, err)
+            raise HostAppArmorError()

hassio/host/control.py

@@ -0,0 +1,56 @@
+"""Power control for host."""
+import logging
+
+from ..coresys import CoreSysAttributes
+from ..exceptions import HostNotSupportedError
+
+_LOGGER = logging.getLogger(__name__)
+
+MANAGER = 'manager'
+HOSTNAME = 'hostname'
+
+
+class SystemControl(CoreSysAttributes):
+    """Handle host power controls."""
+
+    def __init__(self, coresys):
+        """Initialize host power handling."""
+        self.coresys = coresys
+
+    def _check_dbus(self, flag):
+        """Check if systemd is connect or raise error."""
+        if flag == MANAGER and self.sys_dbus.systemd.is_connected:
+            return
+        if flag == HOSTNAME and self.sys_dbus.hostname.is_connected:
+            return
+
+        _LOGGER.error("No %s D-Bus connection available", flag)
+        raise HostNotSupportedError()
+
+    async def reboot(self):
+        """Reboot host system."""
+        self._check_dbus(MANAGER)
+
+        _LOGGER.info("Initialize host reboot over systemd")
+        try:
+            await self.sys_core.shutdown()
+        finally:
+            await self.sys_dbus.systemd.reboot()
+
+    async def shutdown(self):
+        """Shutdown host system."""
+        self._check_dbus(MANAGER)
+
+        _LOGGER.info("Initialize host power off over systemd")
+        try:
+            await self.sys_core.shutdown()
+        finally:
+            await self.sys_dbus.systemd.power_off()
+
+    async def set_hostname(self, hostname):
+        """Set local a new Hostname."""
+        self._check_dbus(HOSTNAME)
+
+        _LOGGER.info("Set hostname %s", hostname)
+        await self.sys_dbus.hostname.set_static_hostname(hostname)
+        await self.sys_host.info.update()

hassio/host/data/asound.tmpl

@@ -0,0 +1,17 @@
+pcm.!default {
+  type asym
+  capture.pcm "mic"
+  playback.pcm "speaker"
+}
+pcm.mic {
+  type plug
+  slave {
+    pcm "hw:$input"
+  }
+}
+pcm.speaker {
+  type plug
+  slave {
+    pcm "hw:$output"
+  }
+}

hassio/host/data/audiodb.json

@@ -0,0 +1,18 @@
+{
+    "raspberrypi3": {
+        "bcm2835 - bcm2835 ALSA": {
+            "0,0": "Raspberry Jack",
+            "0,1": "Raspberry HDMI"
+        },
+        "output": "0,0",
+        "input": null
+    },
+    "raspberrypi2": {
+        "output": "0,0",
+        "input": null
+    },
+    "raspberrypi": {
+        "output": "0,0",
+        "input": null
+    }
+}

hassio/host/info.py

@@ -0,0 +1,58 @@
+"""Info control for host."""
+import logging
+
+from ..coresys import CoreSysAttributes
+from ..exceptions import HassioError, HostNotSupportedError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class InfoCenter(CoreSysAttributes):
+    """Handle local system information controls."""
+
+    def __init__(self, coresys):
+        """Initialize system center handling."""
+        self.coresys = coresys
+        self._data = {}
+
+    @property
+    def hostname(self):
+        """Return local hostname."""
+        return self._data.get('StaticHostname') or None
+
+    @property
+    def chassis(self):
+        """Return local chassis type."""
+        return self._data.get('Chassis') or None
+
+    @property
+    def deployment(self):
+        """Return local deployment type."""
+        return self._data.get('Deployment') or None
+
+    @property
+    def kernel(self):
+        """Return local kernel version."""
+        return self._data.get('KernelRelease') or None
+
+    @property
+    def operating_system(self):
+        """Return local operating system."""
+        return self._data.get('OperatingSystemPrettyName') or None
+
+    @property
+    def cpe(self):
+        """Return local CPE."""
+        return self._data.get('OperatingSystemCPEName') or None
+
+    async def update(self):
+        """Update properties over dbus."""
+        if not self.sys_dbus.hostname.is_connected:
+            _LOGGER.error("No hostname D-Bus connection available")
+            raise HostNotSupportedError()
+
+        _LOGGER.info("Update local host information")
+        try:
+            self._data = await self.sys_dbus.hostname.get_properties()
+        except HassioError:
+            _LOGGER.warning("Can't update host system information!")

hassio/host/services.py

@@ -0,0 +1,99 @@
+"""Service control for host."""
+import logging
+
+import attr
+
+from ..coresys import CoreSysAttributes
+from ..exceptions import HassioError, HostNotSupportedError, HostServiceError
+
+_LOGGER = logging.getLogger(__name__)
+
+MOD_REPLACE = 'replace'
+
+
+class ServiceManager(CoreSysAttributes):
+    """Handle local service information controls."""
+
+    def __init__(self, coresys):
+        """Initialize system center handling."""
+        self.coresys = coresys
+        self._services = set()
+
+    def __iter__(self):
+        """Iterator trought services."""
+        return iter(self._services)
+
+    def _check_dbus(self, unit=None):
+        """Check available dbus connection."""
+        if not self.sys_dbus.systemd.is_connected:
+            _LOGGER.error("No systemd dbus connection available")
+            raise HostNotSupportedError()
+
+        if unit and not self.exists(unit):
+            _LOGGER.error("Unit '%s' not found", unit)
+            raise HostServiceError()
+
+    def start(self, unit):
+        """Start a service on host."""
+        self._check_dbus(unit)
+
+        _LOGGER.info("Start local service %s", unit)
+        return self.sys_dbus.systemd.start_unit(unit, MOD_REPLACE)
+
+    def stop(self, unit):
+        """Stop a service on host."""
+        self._check_dbus(unit)
+
+        _LOGGER.info("Stop local service %s", unit)
+        return self.sys_dbus.systemd.stop_unit(unit, MOD_REPLACE)
+
+    def reload(self, unit):
+        """Reload a service on host."""
+        self._check_dbus(unit)
+
+        _LOGGER.info("Reload local service %s", unit)
+        return self.sys_dbus.systemd.reload_unit(unit, MOD_REPLACE)
+
+    def restart(self, unit):
+        """Restart a service on host."""
+        self._check_dbus(unit)
+
+        _LOGGER.info("Restart local service %s", unit)
+        return self.sys_dbus.systemd.restart_unit(unit, MOD_REPLACE)
+
+    def exists(self, unit):
+        """Check if a unit exists and return True."""
+        for service in self._services:
+            if unit == service.name:
+                return True
+        return False
+
+    async def update(self):
+        """Update properties over dbus."""
+        self._check_dbus()
+
+        _LOGGER.info("Update service information")
+        self._services.clear()
+        try:
+            systemd_units = await self.sys_dbus.systemd.list_units()
+            for service_data in systemd_units[0]:
+                if not service_data[0].endswith(".service") or \
+                        service_data[2] != 'loaded':
+                    continue
+                self._services.add(ServiceInfo.read_from(service_data))
+        except (HassioError, IndexError):
+            _LOGGER.warning("Can't update host service information!")
+
+
+@attr.s(frozen=True)
+class ServiceInfo:
+    """Represent a single Service."""
+
+    name = attr.ib(type=str)
+    description = attr.ib(type=str)
+    state = attr.ib(type=str)
+
+    @staticmethod
+    def read_from(unit):
+        """Parse data from D-Bus into this object."""
+        return ServiceInfo(unit[0], unit[1], unit[3])

hassio/misc/dns.py

@@ -3,12 +3,14 @@ import asyncio
 import logging
 import shlex
 
+import async_timeout
+
 _LOGGER = logging.getLogger(__name__)
 
 COMMAND = "socat UDP-RECVFROM:53,fork UDP-SENDTO:127.0.0.11:53"
 
 
-class DNSForward(object):
+class DNSForward:
     """Manage DNS forwarding to internal DNS."""
 
     def __init__(self, loop):
@@ -38,5 +40,10 @@ class DNSForward(object):
             return
 
         self.proc.kill()
-        await self.proc.wait()
+        try:
+            with async_timeout.timeout(5):
+                await self.proc.wait()
+        except asyncio.TimeoutError:
+            _LOGGER.warning("Stop waiting for DNS shutdown")
+
         _LOGGER.info("Stop DNS forwarding")

hassio/misc/hardware.py

@@ -23,8 +23,8 @@ GPIO_DEVICES = Path("/sys/class/gpio")
 RE_TTY = re.compile(r"tty[A-Z]+")
 
 
-class Hardware(object):
-    """Represent a interface to procfs, sysfs and udev."""
+class Hardware:
+    """Representation of an interface to procfs, sysfs and udev."""
 
     def __init__(self):
         """Init hardware object."""
@@ -63,6 +63,10 @@ class Hardware(object):
     @property
     def audio_devices(self):
         """Return all available audio interfaces."""
+        if not ASOUND_CARDS.exists():
+            _LOGGER.info("No audio devices found")
+            return {}
+
         try:
             with ASOUND_CARDS.open('r') as cards_file:
                 cards = cards_file.read()

hassio/misc/host_control.py

@@ -1,124 +0,0 @@
-"""Host control for HassIO."""
-import asyncio
-import json
-import logging
-
-import async_timeout
-
-from ..const import (
-    SOCKET_HC, ATTR_LAST_VERSION, ATTR_VERSION, ATTR_TYPE, ATTR_FEATURES,
-    ATTR_HOSTNAME, ATTR_OS)
-
-_LOGGER = logging.getLogger(__name__)
-
-TIMEOUT = 15
-UNKNOWN = 'unknown'
-
-FEATURES_SHUTDOWN = 'shutdown'
-FEATURES_REBOOT = 'reboot'
-FEATURES_UPDATE = 'update'
-FEATURES_HOSTNAME = 'hostname'
-FEATURES_NETWORK_INFO = 'network_info'
-FEATURES_NETWORK_CONTROL = 'network_control'
-
-
-class HostControl(object):
-    """Client for host control."""
-
-    def __init__(self, loop):
-        """Initialize HostControl socket client."""
-        self.loop = loop
-        self.active = False
-        self.version = UNKNOWN
-        self.last_version = UNKNOWN
-        self.type = UNKNOWN
-        self.features = []
-        self.hostname = UNKNOWN
-        self.os_info = UNKNOWN
-
-        if SOCKET_HC.is_socket():
-            self.active = True
-
-    async def _send_command(self, command):
-        """Send command to host.
-
-        Is a coroutine.
-        """
-        if not self.active:
-            return
-
-        reader, writer = await asyncio.open_unix_connection(
-            str(SOCKET_HC), loop=self.loop)
-
-        try:
-            # send
-            _LOGGER.info("Send '%s' to HostControl.", command)
-
-            with async_timeout.timeout(TIMEOUT, loop=self.loop):
-                writer.write("{}\n".format(command).encode())
-                data = await reader.readline()
-
-            response = data.decode().rstrip()
-            _LOGGER.info("Receive from HostControl: %s.", response)
-
-            if response == "OK":
-                return True
-            elif response == "ERROR":
-                return False
-            elif response == "WRONG":
-                return None
-            else:
-                try:
-                    return json.loads(response)
-                except json.JSONDecodeError:
-                    _LOGGER.warning("Json parse error from HostControl '%s'.",
-                                    response)
-
-        except asyncio.TimeoutError:
-            _LOGGER.error("Timeout from HostControl!")
-
-        finally:
-            writer.close()
-
-    async def load(self):
-        """Load Info from host.
-
-        Return a coroutine.
-        """
-        info = await self._send_command("info")
-        if not info:
-            return
-
-        self.version = info.get(ATTR_VERSION, UNKNOWN)
-        self.last_version = info.get(ATTR_LAST_VERSION, UNKNOWN)
-        self.type = info.get(ATTR_TYPE, UNKNOWN)
-        self.features = info.get(ATTR_FEATURES, [])
-        self.hostname = info.get(ATTR_HOSTNAME, UNKNOWN)
-        self.os_info = info.get(ATTR_OS, UNKNOWN)
-
-    def reboot(self):
-        """Reboot the host system.
-
-        Return a coroutine.
-        """
-        return self._send_command("reboot")
-
-    def shutdown(self):
-        """Shutdown the host system.
-
-        Return a coroutine.
-        """
-        return self._send_command("shutdown")
-
-    def update(self, version=None):
-        """Update the host system.
-
-        Return a coroutine.
-        """
-        if version:
-            return self._send_command("update {}".format(version))
-        return self._send_command("update")
-
-    def set_hostname(self, hostname):
-        """Update hostname on host."""
-        return self._send_command("hostname {}".format(hostname))

hassio/misc/scheduler.py

@@ -1,4 +1,4 @@
-"""Schedule for HassIO."""
+"""Schedule for Hass.io."""
 import logging
 from datetime import date, datetime, time, timedelta
 
@@ -10,8 +10,8 @@ CALL = 'callback'
 TASK = 'task'
 
 
-class Scheduler(object):
-    """Schedule task inside HassIO."""
+class Scheduler:
+    """Schedule task inside Hass.io."""
 
     def __init__(self, loop):
         """Initialize task schedule."""
@@ -22,18 +22,18 @@ class Scheduler(object):
     def register_task(self, coro_callback, interval, repeat=True):
         """Schedule a coroutine.
 
-        The coroutien need to be a callback without arguments.
+        The coroutine need to be a callback without arguments.
         """
         task_id = hash(coro_callback)
 
-        # generate data
+        # Generate data
         opts = {
             CALL: coro_callback,
             INTERVAL: interval,
             REPEAT: repeat,
         }
 
-        # schedule task
+        # Schedule task
         self._data[task_id] = opts
         self._schedule_task(interval, task_id)
 
@@ -60,7 +60,7 @@ class Scheduler(object):
             tomorrow = datetime.combine(
                 date.today() + timedelta(days=1), interval)
 
-            # check if we run it today or next day
+            # Check if we run it today or next day
             if today > datetime.today():
                 calc = today
             else:
@@ -68,7 +68,7 @@ class Scheduler(object):
 
             job = self.loop.call_at(calc.timestamp(), self._run_task, task_id)
         else:
-            _LOGGER.fatal("Unknow interval %s (type: %s) for scheduler %s",
+            _LOGGER.fatal("Unknown interval %s (type: %s) for scheduler %s",
                           interval, type(interval), task_id)
 
         # Store job

hassio/services/__init__.py

@@ -1,8 +1,6 @@
 """Handle internal services discovery."""
-
 from .mqtt import MQTTService
 from .data import ServicesData
-from .discovery import Discovery
 from ..const import SERVICE_MQTT
 from ..coresys import CoreSysAttributes
 
@@ -19,7 +17,6 @@ class ServiceManager(CoreSysAttributes):
         """Initialize Services handler."""
         self.coresys = coresys
         self.data = ServicesData()
-        self.discovery = Discovery(coresys)
         self.services_obj = {}
 
     @property
@@ -36,10 +33,6 @@ class ServiceManager(CoreSysAttributes):
         for slug, service in AVAILABLE_SERVICES.items():
             self.services_obj[slug] = service(self.coresys)
 
-        # Read exists discovery messages
-        self.discovery.load()
-
     def reset(self):
         """Reset available data."""
         self.data.reset_data()
-        self.discovery.load()

hassio/services/data.py

@@ -1,7 +1,7 @@
 """Handle service data for persistent supervisor reboot."""
 
-from .validate import SCHEMA_SERVICES_FILE
-from ..const import FILE_HASSIO_SERVICES, ATTR_DISCOVERY, SERVICE_MQTT
+from .validate import SCHEMA_SERVICES_CONFIG
+from ..const import FILE_HASSIO_SERVICES, SERVICE_MQTT
 from ..utils.json import JsonConfig
 
 
@@ -10,14 +10,9 @@ class ServicesData(JsonConfig):
 
     def __init__(self):
         """Initialize services data."""
-        super().__init__(FILE_HASSIO_SERVICES, SCHEMA_SERVICES_FILE)
-
-    @property
-    def discovery(self):
-        """Return discovery data for home-assistant."""
-        return self._data[ATTR_DISCOVERY]
+        super().__init__(FILE_HASSIO_SERVICES, SCHEMA_SERVICES_CONFIG)
 
     @property
     def mqtt(self):
-        """Return settings for mqtt service."""
+        """Return settings for MQTT service."""
         return self._data[SERVICE_MQTT]

hassio/services/discovery.py

@@ -1,107 +0,0 @@
-"""Handle discover message for Home-Assistant."""
-import logging
-from uuid import uuid4
-
-from ..const import ATTR_UUID
-from ..coresys import CoreSysAttributes
-
-_LOGGER = logging.getLogger(__name__)
-
-EVENT_DISCOVERY_ADD = 'hassio_discovery_add'
-EVENT_DISCOVERY_DEL = 'hassio_discovery_del'
-
-
-class Discovery(CoreSysAttributes):
-    """Home-Assistant Discovery handler."""
-
-    def __init__(self, coresys):
-        """Initialize discovery handler."""
-        self.coresys = coresys
-        self.message_obj = {}
-
-    def load(self):
-        """Load exists discovery message into storage."""
-        messages = {}
-        for message in self._data:
-            discovery = Message(**message)
-            messages[discovery.uuid] = discovery
-
-        self.message_obj = messages
-
-    def save(self):
-        """Write discovery message into data file."""
-        messages = []
-        for message in self.message_obj.values():
-            messages.append(message.raw())
-
-        self._data.clear()
-        self._data.extend(messages)
-        self._services.data.save_data()
-
-    def get(self, uuid):
-        """Return discovery message."""
-        return self.message_obj.get(uuid)
-
-    @property
-    def _data(self):
-        """Return discovery data."""
-        return self._services.data.discovery
-
-    @property
-    def list_messages(self):
-        """Return list of available discovery messages."""
-        return self.message_obj.values()
-
-    def send(self, provider, component, platform=None, config=None):
-        """Send a discovery message to Home-Assistant."""
-        message = Message(provider, component, platform, config)
-
-        # Allready exists?
-        for exists_message in self.message_obj:
-            if exists_message == message:
-                _LOGGER.warning("Found douplicate discovery message from %s",
-                                provider)
-                return exists_message
-
-        _LOGGER.info("Send discovery to Home-Assistant %s/%s from %s",
-                     component, platform, provider)
-        self.message_obj[message.uuid] = message
-        self.save()
-
-        # send event to Home-Assistant
-        self._loop.create_task(self._homeassistant.send_event(
-            EVENT_DISCOVERY_ADD, {ATTR_UUID: message.uuid}))
-
-        return message
-
-    def remove(self, message):
-        """Remove a discovery message from Home-Assistant."""
-        self.message_obj.pop(message.uuid, None)
-        self.save()
-
-        # send event to Home-Assistant
-        self._loop.create_task(self._homeassistant.send_event(
-            EVENT_DISCOVERY_DEL, {ATTR_UUID: message.uuid}))
-
-
-class Message(object):
-    """Represent a single Discovery message."""
-
-    def __init__(self, provider, component, platform, config, uuid=None):
-        """Initialize discovery message."""
-        self.provider = provider
-        self.component = component
-        self.platform = platform
-        self.config = config
-        self.uuid = uuid or uuid4().hex
-
-    def raw(self):
-        """Return raw discovery message."""
-        return self.__dict__
-
-    def __eq__(self, other):
-        """Compare with other message."""
-        for attribute in ('provider', 'component', 'platform', 'config'):
-            if getattr(self, attribute) != getattr(other, attribute):
-                return False
-        return True

hassio/services/interface.py

@@ -1,6 +1,7 @@
 """Interface for single service."""
 
 from ..coresys import CoreSysAttributes
+from ..const import PROVIDE_SERVICE
 
 
 class ServiceInterface(CoreSysAttributes):
@@ -26,9 +27,13 @@ class ServiceInterface(CoreSysAttributes):
         return None
 
     @property
-    def provider(self):
-        """Return name of service provider."""
-        return None
+    def providers(self):
+        """Return name of service providers addon."""
+        addons = []
+        for addon in self.sys_addons.list_installed:
+            if addon.services_role.get(self.slug) == PROVIDE_SERVICE:
+                addons.append(addon.slug)
+        return addons
 
     @property
     def enabled(self):
@@ -37,7 +42,7 @@ class ServiceInterface(CoreSysAttributes):
 
     def save(self):
         """Save changes."""
-        self._services.data.save_data()
+        self.sys_services.data.save_data()
 
     def get_service_data(self):
         """Return the requested service data."""
@@ -45,10 +50,10 @@ class ServiceInterface(CoreSysAttributes):
             return self._data
         return None
 
-    def set_service_data(self, provider, data):
+    def set_service_data(self, addon, data):
         """Write the data into service object."""
         raise NotImplementedError()
 
-    def del_service_data(self, provider):
+    def del_service_data(self, addon):
         """Remove the data from service object."""
         raise NotImplementedError()

hassio/services/mqtt.py

@@ -1,17 +1,16 @@
-"""Provide MQTT Service."""
+"""Provide the MQTT Service."""
 import logging
 
 from .interface import ServiceInterface
 from .validate import SCHEMA_SERVICE_MQTT
-from ..const import (
-    ATTR_PROVIDER, SERVICE_MQTT, ATTR_HOST, ATTR_PORT, ATTR_USERNAME,
-    ATTR_PASSWORD, ATTR_PROTOCOL, ATTR_DISCOVERY_ID)
+from ..const import ATTR_ADDON, SERVICE_MQTT
+from ..exceptions import ServicesError
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class MQTTService(ServiceInterface):
-    """Provide mqtt services."""
+    """Provide MQTT services."""
 
     @property
     def slug(self):
@@ -21,69 +20,31 @@ class MQTTService(ServiceInterface):
     @property
     def _data(self):
         """Return data of this service."""
-        return self._services.data.mqtt
+        return self.sys_services.data.mqtt
 
     @property
     def schema(self):
         """Return data schema of this service."""
         return SCHEMA_SERVICE_MQTT
 
-    @property
-    def provider(self):
-        """Return name of service provider."""
-        return self._data.get(ATTR_PROVIDER)
-
-    @property
-    def hass_config(self):
-        """Return Home-Assistant mqtt config."""
-        if not self.enabled:
-            return None
-
-        hass_config = {
-            'host': self._data[ATTR_HOST],
-            'port': self._data[ATTR_PORT],
-            'protocol': self._data[ATTR_PROTOCOL]
-        }
-        if ATTR_USERNAME in self._data:
-            hass_config['user']: self._data[ATTR_USERNAME]
-        if ATTR_PASSWORD in self._data:
-            hass_config['password']: self._data[ATTR_PASSWORD]
-
-        return hass_config
-
-    def set_service_data(self, provider, data):
+    def set_service_data(self, addon, data):
         """Write the data into service object."""
         if self.enabled:
-            _LOGGER.error("It is already a mqtt in use from %s", self.provider)
-            return False
+            _LOGGER.error(
+                "It is already a MQTT in use from %s", self._data[ATTR_ADDON])
+            raise ServicesError()
 
         self._data.update(data)
-        self._data[ATTR_PROVIDER] = provider
+        self._data[ATTR_ADDON] = addon.slug
 
-        if provider == 'homeassistant':
-            _LOGGER.info("Use mqtt settings from Home-Assistant")
-            self.save()
-            return True
-
-        # discover mqtt to homeassistant
-        message = self._services.discovery.send(
-            provider, SERVICE_MQTT, None, self.hass_config)
-
-        self._data[ATTR_DISCOVERY_ID] = message.uuid
+        _LOGGER.info("Set %s as service provider for mqtt", addon.slug)
         self.save()
-        return True
 
-    def del_service_data(self, provider):
+    def del_service_data(self, addon):
         """Remove the data from service object."""
         if not self.enabled:
-            _LOGGER.warning("Can't remove not exists services.")
-            return False
-
-        discovery_id = self._data.get(ATTR_DISCOVERY_ID)
-        if discovery_id:
-            self._services.discovery.remove(
-                self._services.discovery.get(discovery_id))
+            _LOGGER.warning("Can't remove not exists services")
+            raise ServicesError()
 
         self._data.clear()
         self.save()
-        return True