Fix version conflict

* Add support for home-assistant bootup

* fix bug

* fix

* fix ip bug

* bugfix

API.md

@@ -4,7 +4,7 @@
 
 Interface for Home Assistant to control things from supervisor.
 
-On error:
+On error / Code 400:
 
 ```json
 {
@@ -13,7 +13,7 @@ On error:
 }
 ```
 
-On success:
+On success / Code 200:
 
 ```json
 {
@@ -22,6 +22,8 @@ On success:
 }
 ```
 
+For access to API you need set the `X-HASSIO-KEY` they will be available for Add-ons/HomeAssistant with envoriment `HASSIO_TOKEN`.
+
 ### Hass.io
 
 - GET `/supervisor/ping`
@@ -45,6 +47,7 @@ The addons from `addons` are only installed one.
             "repository": "12345678|null",
             "version": "LAST_VERSION",
             "installed": "INSTALL_VERSION",
+            "icon": "bool",
             "logo": "bool",
             "state": "started|stopped",
         }
@@ -99,44 +102,7 @@ Output is the raw docker log.
 }
 ```
 
-### Security
-
-- GET `/security/info`
-
-```json
-{
-    "initialize": "bool",
-    "totp": "bool"
-}
-```
-
-- POST `/security/options`
-
-```json
-{
-    "password": "xy"
-}
-```
-
-- POST `/security/totp`
-
-```json
-{
-    "password": "xy"
-}
-```
-
-Return QR-Code
-
-- POST `/security/session`
-```json
-{
-    "password": "xy",
-    "totp": "null|123456"
-}
-```
-
-### Backup/Snapshot
+### Snapshot
 
 - GET `/snapshots`
 
@@ -146,7 +112,8 @@ Return QR-Code
         {
             "slug": "SLUG",
             "date": "ISO",
-            "name": "Custom name"
+            "name": "Custom name",
+            "type": "full|partial"
         }
     ]
 }
@@ -301,7 +268,8 @@ Optional:
     "boot": "bool",
     "port": 8123,
     "ssl": "bool",
-    "watchdog": "bool"
+    "watchdog": "bool",
+    "startup_time": 600
 }
 ```
 
@@ -333,7 +301,8 @@ Output is the raw Docker log.
     "port": "port for access hass",
     "ssl": "bool",
     "password": "",
-    "watchdog": "bool"
+    "watchdog": "bool",
+    "startup_time": 600
 }
 ```
 
@@ -380,6 +349,7 @@ Get all available addons.
             "detached": "bool",
             "build": "bool",
             "url": "null|url",
+            "icon": "bool",
             "logo": "bool"
         }
     ],
@@ -420,6 +390,7 @@ Get all available addons.
     "privileged": ["NET_ADMIN", "SYS_ADMIN"],
     "devices": ["/dev/xy"],
     "auto_uart": "bool",
+    "icon": "bool",
     "logo": "bool",
     "changelog": "bool",
     "hassio_api": "bool",
@@ -429,10 +400,14 @@ Get all available addons.
     "gpio": "bool",
     "audio": "bool",
     "audio_input": "null|0,0",
-    "audio_output": "null|0,0"
+    "audio_output": "null|0,0",
+    "services": "null|['mqtt']",
+    "discovery": "null|['component/platform']"
 }
 ```
 
+- GET `/addons/{addon}/icon`
+
 - GET `/addons/{addon}/logo`
 
 - GET `/addons/{addon}/changelog`
@@ -452,7 +427,7 @@ Get all available addons.
 }
 ```
 
-For reset custom network/audio settings, set it `null`.
+Reset custom network/audio/options, set it `null`.
 
 - POST `/addons/{addon}/start`
 
@@ -491,6 +466,104 @@ Write data to add-on stdin
 }
 ```
 
+### Service discovery
+
+- GET `/services/discovery`
+```json
+{
+    "discovery": [
+        {
+            "provider": "name",
+            "uuid": "uuid",
+            "component": "component",
+            "platform": "null|platform",
+            "config": {}
+        }
+    ]
+}
+```
+
+- GET `/services/discovery/{UUID}`
+```json
+{
+    "provider": "name",
+    "uuid": "uuid",
+    "component": "component",
+    "platform": "null|platform",
+    "config": {}
+}
+```
+
+- POST `/services/discovery`
+```json
+{
+    "component": "component",
+    "platform": "null|platform",
+    "config": {}
+}
+```
+
+return:
+```json
+{
+    "uuid": "uuid"
+}
+```
+
+- DEL `/services/discovery/{UUID}`
+
+- GET `/services`
+```json
+{
+    "services": [
+        {
+            "slug": "name",
+            "available": "bool",
+            "provider": "null|name|list"
+        }
+    ]
+}
+```
+
+- GET `/services/xy`
+```json
+{
+    "available": "bool",
+    "xy": {}
+}
+```
+
+#### MQTT
+
+This service perform a auto discovery to Home-Assistant.
+
+- GET `/services/mqtt`
+```json
+{
+    "provider": "name",
+    "host": "xy",
+    "port": "8883",
+    "ssl": "bool",
+    "username": "optional",
+    "password": "optional",
+    "protocol": "3.1.1"
+}
+```
+
+- POST `/services/mqtt`
+```json
+{
+    "host": "xy",
+    "port": "8883",
+    "ssl": "bool|optional",
+    "username": "optional",
+    "password": "optional",
+    "protocol": "3.1.1"
+}
+```
+
+- DEL `/services/mqtt`
+
 ## Host Control
 
 Communicate over UNIX socket with a host daemon.

README.md

@@ -1,8 +1,12 @@
 # Hass.io
 
-### First private cloud solution for home automation.
+## First private cloud solution for home automation
 
-Hass.io is a Docker based system for managing your Home Assistant installation and related applications. The system is controlled via Home Assistant which communicates with the supervisor. The supervisor provides an API to manage the installation. This includes changing network settings or installing and updating software.
+Hass.io is a Docker-based system for managing your Home Assistant installation
+and related applications. The system is controlled via Home Assistant which
+communicates with the Supervisor. The Supervisor provides an API to manage the
+installation. This includes changing network settings or installing
+and updating software.
 
 ![](misc/hassio.png?raw=true)
 
@@ -11,4 +15,4 @@ Hass.io is a Docker based system for managing your Home Assistant installation a
 
 ## Installation
 
-Installation instructions can be found at [https://home-assistant.io/hassio](https://home-assistant.io/hassio).
+Installation instructions can be found at <https://home-assistant.io/hassio>.

hassio/addons/__init__.py

@@ -4,7 +4,7 @@ import logging
 
 from .addon import Addon
 from .repository import Repository
-from .data import Data
+from .data import AddonsData
 from ..const import REPOSITORY_CORE, REPOSITORY_LOCAL, BOOT_AUTO
 from ..coresys import CoreSysAttributes
 
@@ -19,7 +19,7 @@ class AddonManager(CoreSysAttributes):
     def __init__(self, coresys):
         """Initialize docker base wrapper."""
         self.coresys = coresys
-        self.data = Data(coresys)
+        self.data = AddonsData(coresys)
         self.addons_obj = {}
         self.repositories_obj = {}
 

hassio/addons/addon.py

@@ -12,7 +12,7 @@ import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
 from .validate import (
-    validate_options, SCHEMA_ADDON_SNAPSHOT, RE_VOLUME)
+    validate_options, SCHEMA_ADDON_SNAPSHOT, RE_VOLUME, RE_SERVICE)
 from .utils import check_installed
 from ..const import (
     ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON, ATTR_BOOT, ATTR_MAP,
@@ -23,7 +23,7 @@ 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_HOST_DBUS, ATTR_AUTO_UART, ATTR_DISCOVERY, ATTR_SERVICES)
 from ..coresys import CoreSysAttributes
 from ..docker.addon import DockerAddon
 from ..utils.json import write_json_file, read_json_file
@@ -87,25 +87,25 @@ class Addon(CoreSysAttributes):
             ATTR_OPTIONS: {},
             ATTR_VERSION: version,
         }
-        self._data.save()
+        self._data.save_data()
 
     def _set_uninstall(self):
         """Set addon as uninstalled."""
         self._data.system.pop(self._id, None)
         self._data.user.pop(self._id, None)
-        self._data.save()
+        self._data.save_data()
 
     def _set_update(self, version):
         """Update version of addon."""
         self._data.system[self._id] = deepcopy(self._data.cache[self._id])
         self._data.user[self._id][ATTR_VERSION] = version
-        self._data.save()
+        self._data.save_data()
 
     def _restore_data(self, user, system):
         """Restore data to addon."""
         self._data.user[self._id] = deepcopy(user)
         self._data.system[self._id] = deepcopy(system)
-        self._data.save()
+        self._data.save_data()
 
     @property
     def options(self):
@@ -120,8 +120,10 @@ class Addon(CoreSysAttributes):
     @options.setter
     def options(self, value):
         """Store user addon options."""
-        self._data.user[self._id][ATTR_OPTIONS] = deepcopy(value)
-        self._data.save()
+        if value is None:
+            self._data.user[self._id][ATTR_OPTIONS] = {}
+        else:
+            self._data.user[self._id][ATTR_OPTIONS] = deepcopy(value)
 
     @property
     def boot(self):
@@ -134,7 +136,6 @@ class Addon(CoreSysAttributes):
     def boot(self, value):
         """Store user boot options."""
         self._data.user[self._id][ATTR_BOOT] = value
-        self._data.save()
 
     @property
     def auto_update(self):
@@ -147,7 +148,6 @@ class Addon(CoreSysAttributes):
     def auto_update(self, value):
         """Set auto update."""
         self._data.user[self._id][ATTR_AUTO_UPDATE] = value
-        self._data.save()
 
     @property
     def name(self):
@@ -160,7 +160,7 @@ class Addon(CoreSysAttributes):
         return self._mesh[ATTR_TIMEOUT]
 
     @property
-    def api_token(self):
+    def uuid(self):
         """Return a API token for this add-on."""
         if self.is_installed:
             return self._data.user[self._id][ATTR_UUID]
@@ -201,6 +201,26 @@ class Addon(CoreSysAttributes):
         """Return startup type of addon."""
         return self._mesh.get(ATTR_STARTUP)
 
+    @property
+    def services(self):
+        """Return dict of services with rights."""
+        raw_services = self._mesh.get(ATTR_SERVICES)
+        if not raw_services:
+            return None
+
+        formated_services = {}
+        for data in raw_services:
+            service = RE_SERVICE.match(data)
+            formated_services[service.group('service')] = \
+                service.group('rights') or 'ro'
+
+        return formated_services
+
+    @property
+    def discovery(self):
+        """Return list of discoverable components/platforms."""
+        return self._mesh.get(ATTR_DISCOVERY)
+
     @property
     def ports(self):
         """Return ports of addon."""
@@ -225,8 +245,6 @@ class Addon(CoreSysAttributes):
 
             self._data.user[self._id][ATTR_NETWORK] = new_ports
 
-        self._data.save()
-
     @property
     def webui(self):
         """Return URL to webui or None."""
@@ -347,7 +365,6 @@ class Addon(CoreSysAttributes):
             self._data.user[self._id].pop(ATTR_AUDIO_OUTPUT, None)
         else:
             self._data.user[self._id][ATTR_AUDIO_OUTPUT] = value
-        self._data.save()
 
     @property
     def audio_input(self):
@@ -367,13 +384,17 @@ class Addon(CoreSysAttributes):
             self._data.user[self._id].pop(ATTR_AUDIO_INPUT, None)
         else:
             self._data.user[self._id][ATTR_AUDIO_INPUT] = value
-        self._data.save()
 
     @property
     def url(self):
         """Return url of addon."""
         return self._mesh.get(ATTR_URL)
 
+    @property
+    def with_icon(self):
+        """Return True if a icon exists."""
+        return self.path_icon.exists()
+
     @property
     def with_logo(self):
         """Return True if a logo exists."""
@@ -438,6 +459,11 @@ class Addon(CoreSysAttributes):
         """Return path to this addon."""
         return Path(self._mesh[ATTR_LOCATON])
 
+    @property
+    def path_icon(self):
+        """Return path to addon icon."""
+        return Path(self.path_location, 'icon.png')
+
     @property
     def path_logo(self):
         """Return path to addon logo."""
@@ -448,6 +474,10 @@ class Addon(CoreSysAttributes):
         """Return path to addon changelog."""
         return Path(self.path_location, 'CHANGELOG.md')
 
+    def save_data(self):
+        """Save data of addon."""
+        self._addons.data.save_data()
+
     def write_options(self):
         """Return True if addon options is written to data."""
         schema = self.schema
@@ -455,10 +485,14 @@ class Addon(CoreSysAttributes):
 
         try:
             schema(options)
-            return write_json_file(self.path_options, options)
+            write_json_file(self.path_options, options)
         except vol.Invalid as ex:
             _LOGGER.error("Addon %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)
+        else:
+            return True
 
         return False
 
@@ -547,12 +581,12 @@ class Addon(CoreSysAttributes):
         return STATE_STOPPED
 
     @check_installed
-    def start(self):
-        """Set options and start addon.
+    async def start(self):
+        """Set options and start addon."""
+        if not self.write_options():
+            return False
 
-        Return a coroutine.
-        """
-        return self.instance.run()
+        return await self.instance.run()
 
     @check_installed
     def stop(self):
@@ -577,16 +611,14 @@ class Addon(CoreSysAttributes):
 
         # restore state
         if last_state == STATE_STARTED:
-            await self.instance.run()
+            await self.start()
         return True
 
     @check_installed
-    def restart(self):
-        """Restart addon.
-
-        Return a coroutine.
-        """
-        return self.instance.restart()
+    async def restart(self):
+        """Restart addon."""
+        await self.stop()
+        return await self.start()
 
     @check_installed
     def logs(self):
@@ -622,7 +654,7 @@ class Addon(CoreSysAttributes):
 
         # restore state
         if last_state == STATE_STARTED:
-            await self.instance.run()
+            await self.start()
         return True
 
     @check_installed
@@ -654,8 +686,10 @@ class Addon(CoreSysAttributes):
             }
 
             # store local configs/state
-            if not write_json_file(Path(temp, "addon.json"), data):
-                _LOGGER.error("Can't write addon.json for %s", self._id)
+            try:
+                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
 
             # write into tarfile

hassio/addons/build.py

@@ -10,18 +10,23 @@ from ..utils.json import JsonConfig
 class AddonBuild(JsonConfig, CoreSysAttributes):
     """Handle build options for addons."""
 
-    def __init__(self, coresys, addon):
+    def __init__(self, coresys, slug):
         """Initialize addon builder."""
         self.coresys = coresys
-        self.addon = addon
+        self._id = slug
 
         super().__init__(
-            Path(addon.path_location, 'build.json'), SCHEMA_BUILD_CONFIG)
+            Path(self.addon.path_location, 'build.json'), SCHEMA_BUILD_CONFIG)
 
-    def save(self):
+    def save_data(self):
         """Ignore save function."""
         pass
 
+    @property
+    def addon(self):
+        """Return addon of build data."""
+        return self._addons.get(self._id)
+
     @property
     def base_image(self):
         """Base images for this addon."""

hassio/addons/data.py

@@ -9,7 +9,7 @@ from voluptuous.humanize import humanize_error
 
 from .utils import extract_hash_from_path
 from .validate import (
-    SCHEMA_ADDON_CONFIG, SCHEMA_ADDON_FILE, SCHEMA_REPOSITORY_CONFIG)
+    SCHEMA_ADDON_CONFIG, SCHEMA_ADDONS_FILE, SCHEMA_REPOSITORY_CONFIG)
 from ..const import (
     FILE_HASSIO_ADDONS, ATTR_VERSION, ATTR_SLUG, ATTR_REPOSITORY, ATTR_LOCATON,
     REPOSITORY_CORE, REPOSITORY_LOCAL, ATTR_USER, ATTR_SYSTEM)
@@ -19,12 +19,12 @@ from ..utils.json import JsonConfig, read_json_file
 _LOGGER = logging.getLogger(__name__)
 
 
-class Data(JsonConfig, CoreSysAttributes):
+class AddonsData(JsonConfig, CoreSysAttributes):
     """Hold data for addons inside HassIO."""
 
     def __init__(self, coresys):
         """Initialize data holder."""
-        super().__init__(FILE_HASSIO_ADDONS, SCHEMA_ADDON_FILE)
+        super().__init__(FILE_HASSIO_ADDONS, SCHEMA_ADDONS_FILE)
         self.coresys = coresys
         self._repositories = {}
         self._cache = {}
@@ -159,4 +159,4 @@ class Data(JsonConfig, CoreSysAttributes):
                     have_change = True
 
         if have_change:
-            self.save()
+            self.save_data()

hassio/addons/validate.py

@@ -17,13 +17,15 @@ 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_HOST_DBUS, ATTR_AUTO_UART, ATTR_SERVICES, ATTR_DISCOVERY)
 from ..validate import NETWORK_PORT, DOCKER_PORTS, ALSA_CHANNEL
 
 _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*>))?$")
 
 V_STR = 'str'
 V_INT = 'int'
@@ -101,7 +103,7 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Optional(ATTR_AUTO_UART, default=False): vol.Boolean(),
     vol.Optional(ATTR_TMPFS):
         vol.Match(r"^size=(\d)*[kmg](,uid=\d{1,4})?(,rw)?$"),
-    vol.Optional(ATTR_MAP, default=[]): [vol.Match(RE_VOLUME)],
+    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_AUDIO, default=False): vol.Boolean(),
@@ -110,6 +112,8 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     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_SERVICES): [vol.Match(RE_SERVICE)],
+    vol.Optional(ATTR_DISCOVERY): [vol.Match(RE_DISCOVERY)],
     vol.Required(ATTR_OPTIONS): dict,
     vol.Required(ATTR_SCHEMA): vol.Any(vol.Schema({
         vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [
@@ -141,7 +145,7 @@ SCHEMA_BUILD_CONFIG = vol.Schema({
         vol.In(ARCH_ALL): vol.Match(r"(?:^[\w{}]+/)?[\-\w{}]+:[\.\-\w{}]+$"),
     }),
     vol.Optional(ATTR_SQUASH, default=False): vol.Boolean(),
-    vol.Optional(ATTR_ARGS, default={}): vol.Schema({
+    vol.Optional(ATTR_ARGS, default=dict): vol.Schema({
         vol.Coerce(str): vol.Coerce(str)
     }),
 }, extra=vol.REMOVE_EXTRA)
@@ -152,7 +156,7 @@ 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_OPTIONS, default={}): dict,
+    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]),
@@ -168,11 +172,11 @@ SCHEMA_ADDON_SYSTEM = SCHEMA_ADDON_CONFIG.extend({
 })
 
 
-SCHEMA_ADDON_FILE = vol.Schema({
-    vol.Optional(ATTR_USER, default={}): {
+SCHEMA_ADDONS_FILE = vol.Schema({
+    vol.Optional(ATTR_USER, default=dict): {
         vol.Coerce(str): SCHEMA_ADDON_USER,
     },
-    vol.Optional(ATTR_SYSTEM, default={}): {
+    vol.Optional(ATTR_SYSTEM, default=dict): {
         vol.Coerce(str): SCHEMA_ADDON_SYSTEM,
     }
 })

hassio/api/__init__.py

@@ -5,13 +5,15 @@ from pathlib import Path
 from aiohttp import web
 
 from .addons import APIAddons
+from .discovery import APIDiscovery
 from .homeassistant import APIHomeAssistant
 from .host import APIHost
 from .network import APINetwork
 from .proxy import APIProxy
 from .supervisor import APISupervisor
-from .security import APISecurity
 from .snapshots import APISnapshots
+from .services import APIServices
+from .security import security_layer
 from ..coresys import CoreSysAttributes
 
 _LOGGER = logging.getLogger(__name__)
@@ -23,12 +25,16 @@ class RestAPI(CoreSysAttributes):
     def __init__(self, coresys):
         """Initialize docker base wrapper."""
         self.coresys = coresys
-        self.webapp = web.Application(loop=self._loop)
+        self.webapp = web.Application(
+            middlewares=[security_layer], loop=self._loop)
 
         # service stuff
         self._handler = None
         self.server = None
 
+        # middleware
+        self.webapp['coresys'] = coresys
+
     async def load(self):
         """Register REST API Calls."""
         self._register_supervisor()
@@ -38,8 +44,9 @@ class RestAPI(CoreSysAttributes):
         self._register_panel()
         self._register_addons()
         self._register_snapshots()
-        self._register_security()
         self._register_network()
+        self._register_discovery()
+        self._register_services()
 
     def _register_host(self):
         """Register hostcontrol function."""
@@ -102,12 +109,14 @@ class RestAPI(CoreSysAttributes):
             '/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)
+            '/homeassistant/api/', api_proxy.api)
 
     def _register_addons(self):
         """Register homeassistant function."""
@@ -132,22 +141,13 @@ class RestAPI(CoreSysAttributes):
         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)
 
-    def _register_security(self):
-        """Register security function."""
-        api_security = APISecurity()
-        api_security.coresys = self.coresys
-
-        self.webapp.router.add_get('/security/info', api_security.info)
-        self.webapp.router.add_post('/security/options', api_security.options)
-        self.webapp.router.add_post('/security/totp', api_security.totp)
-        self.webapp.router.add_post('/security/session', api_security.session)
-
     def _register_snapshots(self):
         """Register snapshots function."""
         api_snapshots = APISnapshots()
@@ -171,20 +171,55 @@ class RestAPI(CoreSysAttributes):
             '/snapshots/{snapshot}/restore/partial',
             api_snapshots.restore_partial)
 
+    def _register_services(self):
+        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)
+
+    def _register_discovery(self):
+        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)
+
     def _register_panel(self):
         """Register panel for homeassistant."""
         def create_panel_response(build_type):
             """Create a function to generate a response."""
             path = Path(__file__).parent.joinpath(
-                'panel/hassio-main-{}.html'.format(build_type))
-
+                f"panel/{build_type}.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('es5'))
-        self.webapp.router.add_get('/panel_es5', create_panel_response('es5'))
         self.webapp.router.add_get(
-            '/panel_latest', create_panel_response('latest'))
+            '/panel', create_panel_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'))
+
+        # 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'))
 
     async def start(self):
         """Run rest api webserver."""

hassio/api/addons.py

@@ -16,7 +16,8 @@ from ..const import (
     ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, BOOT_AUTO, BOOT_MANUAL,
     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_NETWORK_RX, ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_ICON, ATTR_SERVICES,
+    ATTR_DISCOVERY,
     CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY, CONTENT_TYPE_TEXT)
 from ..coresys import CoreSysAttributes
 from ..validate import DOCKER_PORTS
@@ -73,6 +74,7 @@ class APIAddons(CoreSysAttributes):
                 ATTR_REPOSITORY: addon.repository,
                 ATTR_BUILD: addon.need_build,
                 ATTR_URL: addon.url,
+                ATTR_ICON: addon.with_icon,
                 ATTR_LOGO: addon.with_logo,
             })
 
@@ -122,6 +124,7 @@ class APIAddons(CoreSysAttributes):
             ATTR_HOST_DBUS: addon.host_dbus,
             ATTR_PRIVILEGED: addon.privileged,
             ATTR_DEVICES: self._pretty_devices(addon),
+            ATTR_ICON: addon.with_icon,
             ATTR_LOGO: addon.with_logo,
             ATTR_CHANGELOG: addon.with_changelog,
             ATTR_WEBUI: addon.webui,
@@ -132,6 +135,8 @@ class APIAddons(CoreSysAttributes):
             ATTR_AUDIO: addon.with_audio,
             ATTR_AUDIO_INPUT: addon.audio_input,
             ATTR_AUDIO_OUTPUT: addon.audio_output,
+            ATTR_SERVICES: addon.services,
+            ATTR_DISCOVERY: addon.discovery,
         }
 
     @api_process
@@ -140,7 +145,7 @@ class APIAddons(CoreSysAttributes):
         addon = self._extract_addon(request)
 
         addon_schema = SCHEMA_OPTIONS.extend({
-            vol.Optional(ATTR_OPTIONS): addon.schema,
+            vol.Optional(ATTR_OPTIONS): vol.Any(None, addon.schema),
         })
 
         body = await api_validate(addon_schema, request)
@@ -158,6 +163,7 @@ class APIAddons(CoreSysAttributes):
         if ATTR_AUDIO_OUTPUT in body:
             addon.audio_output = body[ATTR_AUDIO_OUTPUT]
 
+        addon.save_data()
         return True
 
     @api_process
@@ -242,12 +248,22 @@ class APIAddons(CoreSysAttributes):
         addon = self._extract_addon(request)
         return addon.logs()
 
+    @api_process_raw(CONTENT_TYPE_PNG)
+    async def icon(self, request):
+        """Return icon from addon."""
+        addon = self._extract_addon(request, check_installed=False)
+        if not addon.with_icon:
+            raise RuntimeError("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."""
         addon = self._extract_addon(request, check_installed=False)
         if not addon.with_logo:
-            raise RuntimeError("No image found!")
+            raise RuntimeError("No logo found!")
 
         with addon.path_logo.open('rb') as png:
             return png.read()
@@ -267,7 +283,7 @@ class APIAddons(CoreSysAttributes):
         """Write to stdin of addon."""
         addon = self._extract_addon(request)
         if not addon.with_stdin:
-            raise RuntimeError("STDIN not supported by addons")
+            raise RuntimeError("STDIN not supported by addon")
 
         data = await request.read()
         return await asyncio.shield(addon.write_stdin(data), loop=self._loop)

hassio/api/discovery.py

@@ -0,0 +1,72 @@
+"""Init file for HassIO network rest 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)
+from ..coresys import CoreSysAttributes
+
+
+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),
+})
+
+
+class APIDiscovery(CoreSysAttributes):
+    """Handle rest api for discovery functions."""
+
+    def _extract_message(self, request):
+        """Extract discovery message from URL."""
+        message = self._services.discovery.get(request.match_info.get('uuid'))
+        if not message:
+            raise RuntimeError("Discovery message not found")
+        return message
+
+    @api_process
+    async def list(self, request):
+        """Show register services."""
+        discovery = []
+        for message in self._services.discovery.list_messages:
+            discovery.append({
+                ATTR_PROVIDER: message.provider,
+                ATTR_UUID: message.uuid,
+                ATTR_COMPONENT: message.component,
+                ATTR_PLATFORM: message.platform,
+                ATTR_CONFIG: message.config,
+            })
+
+        return {ATTR_DISCOVERY: discovery}
+
+    @api_process
+    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)
+
+        return {ATTR_UUID: message.uuid}
+
+    @api_process
+    async def get_discovery(self, request):
+        """Read data into a discovery message."""
+        message = self._extract_message(request)
+
+        return {
+            ATTR_PROVIDER: message.provider,
+            ATTR_UUID: message.uuid,
+            ATTR_COMPONENT: message.component,
+            ATTR_PLATFORM: message.platform,
+            ATTR_CONFIG: message.config,
+        }
+
+    @api_process
+    async def del_discovery(self, request):
+        """Delete data into a discovery message."""
+        message = self._extract_message(request)
+
+        self._services.discovery.remove(message)
+        return True

hassio/api/homeassistant.py

@@ -9,9 +9,9 @@ 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, CONTENT_TYPE_BINARY)
+    ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_STARTUP_TIME, CONTENT_TYPE_BINARY)
 from ..coresys import CoreSysAttributes
-from ..validate import NETWORK_PORT
+from ..validate import NETWORK_PORT, DOCKER_IMAGE
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,11 +22,13 @@ SCHEMA_OPTIONS = vol.Schema({
     vol.Inclusive(ATTR_IMAGE, 'custom_hass'):
         vol.Any(None, vol.Coerce(str)),
     vol.Inclusive(ATTR_LAST_VERSION, 'custom_hass'):
-        vol.Any(None, vol.Coerce(str)),
+        vol.Any(None, DOCKER_IMAGE),
     vol.Optional(ATTR_PORT): NETWORK_PORT,
     vol.Optional(ATTR_PASSWORD): vol.Any(None, vol.Coerce(str)),
     vol.Optional(ATTR_SSL): vol.Boolean(),
     vol.Optional(ATTR_WATCHDOG): vol.Boolean(),
+    vol.Optional(ATTR_STARTUP_TIME):
+        vol.All(vol.Coerce(int), vol.Range(min=60)),
 })
 
 SCHEMA_VERSION = vol.Schema({
@@ -49,6 +51,7 @@ class APIHomeAssistant(CoreSysAttributes):
             ATTR_PORT: self._homeassistant.api_port,
             ATTR_SSL: self._homeassistant.api_ssl,
             ATTR_WATCHDOG: self._homeassistant.watchdog,
+            ATTR_STARTUP_TIME: self._homeassistant.startup_time,
         }
 
     @api_process
@@ -75,7 +78,10 @@ class APIHomeAssistant(CoreSysAttributes):
         if ATTR_WATCHDOG in body:
             self._homeassistant.watchdog = body[ATTR_WATCHDOG]
 
-        self._homeassistant.save()
+        if ATTR_STARTUP_TIME in body:
+            self._homeassistant.startup_time = body[ATTR_STARTUP_TIME]
+
+        self._homeassistant.save_data()
         return True
 
     @api_process
@@ -115,7 +121,7 @@ class APIHomeAssistant(CoreSysAttributes):
     @api_process
     def start(self, request):
         """Start homeassistant."""
-        return asyncio.shield(self._homeassistant.run(), loop=self._loop)
+        return asyncio.shield(self._homeassistant.start(), loop=self._loop)
 
     @api_process
     def restart(self, request):

hassio/api/host.py

@@ -49,6 +49,7 @@ class APIHost(CoreSysAttributes):
         if ATTR_AUDIO_INPUT in body:
             self._config.audio_input = body[ATTR_AUDIO_INPUT]
 
+        self._config.save_data()
         return True
 
     @api_process_hostcontrol

hassio/api/panel/index.html

@@ -0,0 +1,37 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Hass.io</title>
+    <meta name='viewport' content='width=device-width, user-scalable=no'>
+    <style>
+      body {
+        height: 100vh;
+        margin: 0;
+        padding: 0;
+      }
+    </style>
+  </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');
+      }
+    </script>
+    <link rel='import' href='./hassio-app.html'>
+    <link rel='import' href='/static/mdi.html' async>
+  </body>
+</html>

hassio/api/proxy.py

@@ -4,7 +4,7 @@ import logging
 
 import aiohttp
 from aiohttp import web
-from aiohttp.web_exceptions import HTTPBadGateway
+from aiohttp.web_exceptions import HTTPBadGateway, HTTPInternalServerError
 from aiohttp.hdrs import CONTENT_TYPE
 import async_timeout
 
@@ -25,6 +25,7 @@ class APIProxy(CoreSysAttributes):
             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):
@@ -42,7 +43,8 @@ class APIProxy(CoreSysAttributes):
                 headers = None
 
             client = await method(
-                url, data=data, headers=headers, timeout=timeout
+                url, data=data, headers=headers, timeout=timeout,
+                params=params
             )
 
             return client
@@ -55,52 +57,50 @@ class APIProxy(CoreSysAttributes):
 
         raise HTTPBadGateway()
 
+    async def stream(self, request):
+        """Proxy HomeAssistant EventStream Requests."""
+        _LOGGER.info("Home-Assistant EventStream start")
+        client = await self._api_client(request, 'stream', timeout=None)
+
+        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:
+            await response.write_eof()
+
+        except asyncio.CancelledError:
+            pass
+
+        finally:
+            client.close()
+            _LOGGER.info("Home-Assistant EventStream close")
+
     async def api(self, request):
         """Proxy HomeAssistant API Requests."""
         path = request.match_info.get('path', '')
 
-        # API stream
-        if path.startswith("stream"):
-            _LOGGER.info("Home-Assistant Event-Stream start")
-            client = await self._api_client(request, path, timeout=None)
-
-            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:
-                await response.write_eof()
-
-            except asyncio.CancelledError:
-                pass
-
-            finally:
-                client.close()
-
-            _LOGGER.info("Home-Assistant Event-Stream close")
-
         # Normal request
-        else:
-            _LOGGER.info("Home-Assistant '/api/%s' request", path)
-            client = await self._api_client(request, path)
+        _LOGGER.info("Home-Assistant /api/%s request", 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
-            )
+        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"
+        url = f"{self._homeassistant.api_url}/api/websocket"
 
         try:
             client = await self._websession_ssl.ws_connect(
@@ -133,9 +133,19 @@ class APIProxy(CoreSysAttributes):
         await server.prepare(request)
 
         # handle authentication
-        await server.send_json({'type': 'auth_required'})
-        await server.receive_json()  # get internal token
-        await server.send_json({'type': 'auth_ok'})
+        try:
+            await server.send_json({
+                'type': 'auth_required',
+                'ha_version': self._homeassistant.version,
+            })
+            await server.receive_json()  # get internal token
+            await server.send_json({
+                'type': 'auth_ok',
+                'ha_version': self._homeassistant.version,
+            })
+        except (RuntimeError, ValueError) as err:
+            _LOGGER.error("Can't initialize handshake: %s", err)
+            raise HTTPInternalServerError() from None
 
         # init connection to hass
         client = await self._websocket_client()

hassio/api/security.py

@@ -1,98 +1,34 @@
-"""Init file for HassIO security rest api."""
-from datetime import datetime, timedelta
-import io
+"""Handle security part of this API."""
 import logging
-import hashlib
-import os
 
-from aiohttp import web
-import voluptuous as vol
-import pyotp
-import pyqrcode
+from aiohttp.web import middleware
 
-from .utils import api_process, api_validate, hash_password
-from ..const import ATTR_INITIALIZE, ATTR_PASSWORD, ATTR_TOTP, ATTR_SESSION
-from ..coresys import CoreSysAttributes
+from ..const import HEADER_TOKEN, REQUEST_FROM
 
 _LOGGER = logging.getLogger(__name__)
 
-SCHEMA_PASSWORD = vol.Schema({
-    vol.Required(ATTR_PASSWORD): vol.Coerce(str),
-})
 
-SCHEMA_SESSION = SCHEMA_PASSWORD.extend({
-    vol.Optional(ATTR_TOTP, default=None): vol.Coerce(str),
-})
+@middleware
+async def security_layer(request, handler):
+    """Check security access of this layer."""
+    coresys = request.app['coresys']
+    hassio_token = request.headers.get(HEADER_TOKEN)
 
+    # Need to be removed later
+    if not hassio_token:
+        _LOGGER.warning("No valid hassio token for API access!")
+        request[REQUEST_FROM] = 'UNKNOWN'
 
-class APISecurity(CoreSysAttributes):
-    """Handle rest api for security functions."""
+    # From Home-Assistant
+    elif hassio_token == coresys.homeassistant.uuid:
+        request[REQUEST_FROM] = 'homeassistant'
 
-    def _check_password(self, body):
-        """Check if password is valid and security is initialize."""
-        if not self._config.security_initialize:
-            raise RuntimeError("First set a password")
+    # From Add-on
+    else:
+        for addon in coresys.addons.list_addons:
+            if hassio_token != addon.uuid:
+                continue
+            request[REQUEST_FROM] = addon.slug
+            break
 
-        password = hash_password(body[ATTR_PASSWORD])
-        if password != self._config.security_password:
-            raise RuntimeError("Wrong password")
-
-    @api_process
-    async def info(self, request):
-        """Return host information."""
-        return {
-            ATTR_INITIALIZE: self._config.security_initialize,
-            ATTR_TOTP: self._config.security_totp is not None,
-        }
-
-    @api_process
-    async def options(self, request):
-        """Set options / password."""
-        body = await api_validate(SCHEMA_PASSWORD, request)
-
-        if self._config.security_initialize:
-            raise RuntimeError("Password is already set!")
-
-        self._config.security_password = hash_password(body[ATTR_PASSWORD])
-        self._config.security_initialize = True
-        return True
-
-    @api_process
-    async def totp(self, request):
-        """Set and initialze TOTP."""
-        body = await api_validate(SCHEMA_PASSWORD, request)
-        self._check_password(body)
-
-        # generate TOTP
-        totp_init_key = pyotp.random_base32()
-        totp = pyotp.TOTP(totp_init_key)
-
-        # init qrcode
-        buff = io.BytesIO()
-
-        qrcode = pyqrcode.create(totp.provisioning_uri("Hass.IO"))
-        qrcode.svg(buff)
-
-        # finish
-        self._config.security_totp = totp_init_key
-        return web.Response(body=buff.getvalue(), content_type='image/svg+xml')
-
-    @api_process
-    async def session(self, request):
-        """Set and initialze session."""
-        body = await api_validate(SCHEMA_SESSION, request)
-        self._check_password(body)
-
-        # check TOTP
-        if self._config.security_totp:
-            totp = pyotp.TOTP(self._config.security_totp)
-            if body[ATTR_TOTP] != totp.now():
-                raise RuntimeError("Invalid TOTP token!")
-
-        # create session
-        valid_until = datetime.now() + timedelta(days=1)
-        session = hashlib.sha256(os.urandom(54)).hexdigest()
-
-        # store session
-        self._config.add_security_session(session, valid_until)
-        return {ATTR_SESSION: session}
+    return await handler(request)

hassio/api/services.py

@@ -0,0 +1,55 @@
+"""Init file for HassIO network rest api."""
+
+from .utils import api_process, api_validate
+from ..const import (
+    ATTR_AVAILABLE, ATTR_PROVIDER, ATTR_SLUG, ATTR_SERVICES, REQUEST_FROM)
+from ..coresys import CoreSysAttributes
+
+
+class APIServices(CoreSysAttributes):
+    """Handle rest 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'))
+        if not service:
+            raise RuntimeError("Service not exists")
+
+        return service
+
+    @api_process
+    async def list(self, request):
+        """Show register services."""
+        services = []
+        for service in self._services.list_services:
+            services.append({
+                ATTR_SLUG: service.slug,
+                ATTR_AVAILABLE: service.enabled,
+                ATTR_PROVIDER: service.provider,
+            })
+
+        return {ATTR_SERVICES: services}
+
+    @api_process
+    async def set_service(self, request):
+        """Write data into a service."""
+        service = self._extract_service(request)
+        body = await api_validate(service.schema, request)
+
+        return service.set_service_data(request[REQUEST_FROM], 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(),
+        }
+
+    @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])

hassio/api/snapshots.py

@@ -18,8 +18,10 @@ _LOGGER = logging.getLogger(__name__)
 # pylint: disable=no-value-for-parameter
 SCHEMA_RESTORE_PARTIAL = vol.Schema({
     vol.Optional(ATTR_HOMEASSISTANT): vol.Boolean(),
-    vol.Optional(ATTR_ADDONS): [vol.Coerce(str)],
-    vol.Optional(ATTR_FOLDERS): [vol.In(ALL_FOLDERS)],
+    vol.Optional(ATTR_ADDONS):
+        vol.All([vol.Coerce(str)], vol.Unique()),
+    vol.Optional(ATTR_FOLDERS):
+        vol.All([vol.In(ALL_FOLDERS)], vol.Unique()),
 })
 
 SCHEMA_SNAPSHOT_FULL = vol.Schema({
@@ -27,8 +29,10 @@ SCHEMA_SNAPSHOT_FULL = vol.Schema({
 })
 
 SCHEMA_SNAPSHOT_PARTIAL = SCHEMA_SNAPSHOT_FULL.extend({
-    vol.Optional(ATTR_ADDONS): [vol.Coerce(str)],
-    vol.Optional(ATTR_FOLDERS): [vol.In(ALL_FOLDERS)],
+    vol.Optional(ATTR_ADDONS):
+        vol.All([vol.Coerce(str)], vol.Unique()),
+    vol.Optional(ATTR_FOLDERS):
+        vol.All([vol.In(ALL_FOLDERS)], vol.Unique()),
 })
 
 
@@ -51,6 +55,7 @@ class APISnapshots(CoreSysAttributes):
                 ATTR_SLUG: snapshot.slug,
                 ATTR_NAME: snapshot.name,
                 ATTR_DATE: snapshot.date,
+                ATTR_TYPE: snapshot.sys_type,
             })
 
         return {

hassio/api/supervisor.py

@@ -11,16 +11,16 @@ from ..const import (
     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_BLK_WRITE, CONTENT_TYPE_BINARY, ATTR_ICON)
 from ..coresys import CoreSysAttributes
-from ..validate import validate_timezone, WAIT_BOOT
+from ..validate import validate_timezone, WAIT_BOOT, REPOSITORIES
 
 _LOGGER = logging.getLogger(__name__)
 
 SCHEMA_OPTIONS = vol.Schema({
     # pylint: disable=no-value-for-parameter
     vol.Optional(ATTR_BETA_CHANNEL): vol.Boolean(),
-    vol.Optional(ATTR_ADDONS_REPOSITORIES): [vol.Url()],
+    vol.Optional(ATTR_ADDONS_REPOSITORIES): REPOSITORIES,
     vol.Optional(ATTR_TIMEZONE): validate_timezone,
     vol.Optional(ATTR_WAIT_BOOT): WAIT_BOOT,
 })
@@ -52,6 +52,7 @@ class APISupervisor(CoreSysAttributes):
                     ATTR_VERSION: addon.last_version,
                     ATTR_INSTALLED: addon.version_installed,
                     ATTR_REPOSITORY: addon.repository,
+                    ATTR_ICON: addon.with_icon,
                     ATTR_LOGO: addon.with_logo,
                 })
 
@@ -84,8 +85,8 @@ class APISupervisor(CoreSysAttributes):
             new = set(body[ATTR_ADDONS_REPOSITORIES])
             await asyncio.shield(self._addons.load_repositories(new))
 
-        self._updater.save()
-        self._config.save()
+        self._updater.save_data()
+        self._config.save_data()
         return True
 
     @api_process

hassio/bootstrap.py

@@ -13,9 +13,10 @@ from .const import SOCKET_DOCKER
 from .coresys import CoreSys
 from .supervisor import Supervisor
 from .homeassistant import HomeAssistant
-from .snapshots import SnapshotsManager
+from .snapshots import SnapshotManager
 from .tasks import Tasks
 from .updater import Updater
+from .services import ServiceManager
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -30,8 +31,9 @@ def initialize_coresys(loop):
     coresys.supervisor = Supervisor(coresys)
     coresys.homeassistant = HomeAssistant(coresys)
     coresys.addons = AddonManager(coresys)
-    coresys.snapshots = SnapshotsManager(coresys)
+    coresys.snapshots = SnapshotManager(coresys)
     coresys.tasks = Tasks(coresys)
+    coresys.services = ServiceManager(coresys)
 
     # bootstrap config
     initialize_system_data(coresys)

hassio/config.py

@@ -5,8 +5,7 @@ import os
 from pathlib import Path, PurePath
 
 from .const import (
-    FILE_HASSIO_CONFIG, HASSIO_DATA, ATTR_SECURITY, ATTR_SESSIONS,
-    ATTR_PASSWORD, ATTR_TOTP, ATTR_TIMEZONE, ATTR_ADDONS_CUSTOM_LIST,
+    FILE_HASSIO_CONFIG, HASSIO_DATA, ATTR_TIMEZONE, ATTR_ADDONS_CUSTOM_LIST,
     ATTR_AUDIO_INPUT, ATTR_AUDIO_OUTPUT, ATTR_LAST_BOOT, ATTR_WAIT_BOOT)
 from .utils.dt import parse_datetime
 from .utils.json import JsonConfig
@@ -46,7 +45,6 @@ class CoreConfig(JsonConfig):
     def timezone(self, value):
         """Set system timezone."""
         self._data[ATTR_TIMEZONE] = value
-        self.save()
 
     @property
     def wait_boot(self):
@@ -57,7 +55,6 @@ class CoreConfig(JsonConfig):
     def wait_boot(self, value):
         """Set wait boot time."""
         self._data[ATTR_WAIT_BOOT] = value
-        self.save()
 
     @property
     def last_boot(self):
@@ -73,7 +70,6 @@ class CoreConfig(JsonConfig):
     def last_boot(self, value):
         """Set last boot datetime."""
         self._data[ATTR_LAST_BOOT] = value.isoformat()
-        self.save()
 
     @property
     def path_hassio(self):
@@ -171,7 +167,6 @@ class CoreConfig(JsonConfig):
             return
 
         self._data[ATTR_ADDONS_CUSTOM_LIST].append(repo)
-        self.save()
 
     def drop_addon_repository(self, repo):
         """Remove a custom repository from list."""
@@ -179,60 +174,6 @@ class CoreConfig(JsonConfig):
             return
 
         self._data[ATTR_ADDONS_CUSTOM_LIST].remove(repo)
-        self.save()
-
-    @property
-    def security_initialize(self):
-        """Return is security was initialize."""
-        return self._data[ATTR_SECURITY]
-
-    @security_initialize.setter
-    def security_initialize(self, value):
-        """Set is security initialize."""
-        self._data[ATTR_SECURITY] = value
-        self.save()
-
-    @property
-    def security_totp(self):
-        """Return the TOTP key."""
-        return self._data.get(ATTR_TOTP)
-
-    @security_totp.setter
-    def security_totp(self, value):
-        """Set the TOTP key."""
-        self._data[ATTR_TOTP] = value
-        self.save()
-
-    @property
-    def security_password(self):
-        """Return the password key."""
-        return self._data.get(ATTR_PASSWORD)
-
-    @security_password.setter
-    def security_password(self, value):
-        """Set the password key."""
-        self._data[ATTR_PASSWORD] = value
-        self.save()
-
-    @property
-    def security_sessions(self):
-        """Return api sessions."""
-        return {
-            session: parse_datetime(until) for
-            session, until in self._data[ATTR_SESSIONS].items()
-        }
-
-    def add_security_session(self, session, valid):
-        """Set the a new session."""
-        self._data[ATTR_SESSIONS].update(
-            {session: valid.isoformat()}
-        )
-        self.save()
-
-    def drop_security_session(self, session):
-        """Delete the a session."""
-        self._data[ATTR_SESSIONS].pop(session, None)
-        self.save()
 
     @property
     def audio_output(self):
@@ -243,7 +184,6 @@ class CoreConfig(JsonConfig):
     def audio_output(self, value):
         """Set ALSA audio output card,dev."""
         self._data[ATTR_AUDIO_OUTPUT] = value
-        self.save()
 
     @property
     def audio_input(self):
@@ -254,4 +194,3 @@ class CoreConfig(JsonConfig):
     def audio_input(self, value):
         """Set ALSA audio input card,dev."""
         self._data[ATTR_AUDIO_INPUT] = value
-        self.save()

hassio/const.py

@@ -2,7 +2,7 @@
 from pathlib import Path
 from ipaddress import ip_network
 
-HASSIO_VERSION = '0.80'
+HASSIO_VERSION = '0.86'
 
 URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
                       'hassio/{}/version.json')
@@ -15,6 +15,7 @@ FILE_HASSIO_ADDONS = Path(HASSIO_DATA, "addons.json")
 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")
 
 SOCKET_DOCKER = Path("/var/run/docker.sock")
 SOCKET_HC = Path("/var/run/hassio-hc.sock")
@@ -43,6 +44,12 @@ CONTENT_TYPE_PNG = 'image/png'
 CONTENT_TYPE_JSON = 'application/json'
 CONTENT_TYPE_TEXT = 'text/plain'
 HEADER_HA_ACCESS = 'x-ha-access'
+HEADER_TOKEN = 'X-HASSIO-KEY'
+
+ENV_TOKEN = 'HASSIO_TOKEN'
+ENV_TIME = 'TZ'
+
+REQUEST_FROM = 'HASSIO_FROM'
 
 ATTR_WAIT_BOOT = 'wait_boot'
 ATTR_WATCHDOG = 'watchdog'
@@ -79,6 +86,7 @@ ATTR_DETACHED = 'detached'
 ATTR_STATE = 'state'
 ATTR_SCHEMA = 'schema'
 ATTR_IMAGE = 'image'
+ATTR_ICON = 'icon'
 ATTR_LOGO = 'logo'
 ATTR_STDIN = 'stdin'
 ATTR_ADDONS_REPOSITORIES = 'addons_repositories'
@@ -135,6 +143,21 @@ ATTR_MEMORY_LIMIT = 'memory_limit'
 ATTR_MEMORY_USAGE = 'memory_usage'
 ATTR_BLK_READ = 'blk_read'
 ATTR_BLK_WRITE = 'blk_write'
+ATTR_PROVIDER = 'provider'
+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_DISCOVERY = 'discovery'
+ATTR_STARTUP_TIME = 'startup_time'
+
+SERVICE_MQTT = 'mqtt'
 
 STARTUP_INITIALIZE = 'initialize'
 STARTUP_SYSTEM = 'system'

hassio/core.py

@@ -44,6 +44,9 @@ class HassIO(CoreSysAttributes):
         # load last available data
         await self._snapshots.load()
 
+        # load services
+        await self._services.load()
+
         # start dns forwarding
         self._loop.create_task(self._dns.start())
 
@@ -54,8 +57,9 @@ class HassIO(CoreSysAttributes):
         """Start HassIO orchestration."""
         # on release channel, try update itself
         # on beta channel, only read new versions
-        if not self._updater.beta_channel:
-            await self._supervisor.update()
+        if not self._updater.beta_channel and self._supervisor.need_update:
+            if await self._supervisor.update():
+                return
         else:
             _LOGGER.info("Ignore Hass.io auto updates on beta mode")
 
@@ -69,6 +73,9 @@ class HassIO(CoreSysAttributes):
                 _LOGGER.info("Hass.io reboot detected")
                 return
 
+            # reset register services / discovery
+            self._services.reset()
+
             # start addon mark as system
             await self._addons.auto_boot(STARTUP_SYSTEM)
 
@@ -77,13 +84,14 @@ class HassIO(CoreSysAttributes):
 
             # run HomeAssistant
             if self._homeassistant.boot:
-                await self._homeassistant.run()
+                await self._homeassistant.start()
 
             # start addon mark as application
             await self._addons.auto_boot(STARTUP_APPLICATION)
 
             # store new last boot
             self._config.last_boot = self._hardware.last_boot
+            self._config.save_data()
 
         finally:
             # Add core tasks into scheduler
@@ -93,7 +101,7 @@ class HassIO(CoreSysAttributes):
             if self._homeassistant.version == 'landingpage':
                 self._loop.create_task(self._homeassistant.install())
 
-        _LOGGER.info("Hass.io is up and running")
+            _LOGGER.info("Hass.io is up and running")
 
     async def stop(self):
         """Stop a running orchestration."""

hassio/coresys.py

@@ -40,6 +40,7 @@ class CoreSys(object):
         self._updater = None
         self._snapshots = None
         self._tasks = None
+        self._services = None
 
     @property
     def arch(self):
@@ -155,19 +156,19 @@ class CoreSys(object):
 
     @property
     def snapshots(self):
-        """Return SnapshotsManager object."""
+        """Return SnapshotManager object."""
         return self._snapshots
 
     @snapshots.setter
     def snapshots(self, value):
-        """Set a SnapshotsManager object."""
+        """Set a SnapshotManager object."""
         if self._snapshots:
             raise RuntimeError("SnapshotsManager already set!")
         self._snapshots = value
 
     @property
     def tasks(self):
-        """Return SnapshotsManager object."""
+        """Return Tasks object."""
         return self._tasks
 
     @tasks.setter
@@ -177,6 +178,18 @@ class CoreSys(object):
             raise RuntimeError("Tasks already set!")
         self._tasks = value
 
+    @property
+    def services(self):
+        """Return ServiceManager object."""
+        return self._services
+
+    @services.setter
+    def services(self, value):
+        """Set a ServiceManager object."""
+        if self._services:
+            raise RuntimeError("Services already set!")
+        self._services = value
+
 
 class CoreSysAttributes(object):
     """Inheret basic CoreSysAttributes."""

hassio/docker/__init__.py

@@ -19,7 +19,8 @@ class DockerAPI(object):
     def __init__(self):
         """Initialize docker base wrapper."""
         self.docker = docker.DockerClient(
-            base_url="unix:/{}".format(str(SOCKET_DOCKER)), version='auto')
+            base_url="unix:/{}".format(str(SOCKET_DOCKER)),
+            version='auto', timeout=300)
         self.network = DockerNetwork(self.docker)
 
     @property
@@ -47,8 +48,10 @@ class DockerAPI(object):
         hostname = kwargs.get('hostname')
 
         # setup network
+        kwargs['dns_search'] = ["."]
         if network_mode:
             kwargs['dns'] = [str(self.network.supervisor)]
+            kwargs['dns_opt'] = ["ndots:0"]
         else:
             kwargs['network'] = None
 

hassio/docker/addon.py

@@ -9,7 +9,8 @@ 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)
+    MAP_CONFIG, MAP_SSL, MAP_ADDONS, MAP_BACKUP, MAP_SHARE, ENV_TOKEN,
+    ENV_TIME)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -26,7 +27,7 @@ class DockerAddon(DockerInterface):
 
     @property
     def addon(self):
-        """Return name of docker image."""
+        """Return addon of docker image."""
         return self._addons.get(self._id)
 
     @property
@@ -74,19 +75,18 @@ class DockerAddon(DockerInterface):
     def environment(self):
         """Return environment for docker add-on."""
         addon_env = self.addon.environment or {}
+
+        # Need audio settings
         if self.addon.with_audio:
             addon_env.update({
                 'ALSA_OUTPUT': self.addon.audio_output,
                 'ALSA_INPUT': self.addon.audio_input,
             })
 
-        # Set api token if any API access is needed
-        if self.addon.access_hassio_api or self.addon.access_homeassistant_api:
-            addon_env['API_TOKEN'] = self.addon.api_token
-
         return {
             **addon_env,
-            'TZ': self._config.timezone,
+            ENV_TIME: self._config.timezone,
+            ENV_TOKEN: self.addon.uuid,
         }
 
     @property
@@ -225,10 +225,6 @@ class DockerAddon(DockerInterface):
         # cleanup
         self._stop()
 
-        # write config
-        if not self.addon.write_options():
-            return False
-
         ret = self._docker.run(
             self.image,
             name=self.name,
@@ -269,7 +265,7 @@ class DockerAddon(DockerInterface):
 
         Need run inside executor.
         """
-        build_env = AddonBuild(self.coresys, self.addon)
+        build_env = AddonBuild(self.coresys, self._id)
 
         _LOGGER.info("Start build %s:%s", self.image, tag)
         try:
@@ -337,15 +333,6 @@ class DockerAddon(DockerInterface):
         self._cleanup()
         return True
 
-    def _restart(self):
-        """Restart docker container.
-
-        Addons prepare some thing on start and that is normaly not repeatable.
-        Need run inside executor.
-        """
-        self._stop()
-        return self._run()
-
     @docker_process
     def write_stdin(self, data):
         """Write to add-on stdin."""

hassio/docker/homeassistant.py

@@ -4,6 +4,7 @@ import logging
 import docker
 
 from .interface import DockerInterface
+from ..const import ENV_TOKEN, ENV_TIME
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -53,7 +54,8 @@ class DockerHomeAssistant(DockerInterface):
             network_mode='host',
             environment={
                 'HASSIO': self._docker.network.supervisor,
-                'TZ': self._config.timezone,
+                ENV_TIME: self._config.timezone,
+                ENV_TOKEN: self._homeassistant.uuid,
             },
             volumes={
                 str(self._config.path_extern_config):

hassio/docker/network.py

@@ -9,7 +9,10 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class DockerNetwork(object):
-    """Internal HassIO Network."""
+    """Internal HassIO Network.
+
+    This class is not AsyncIO safe!
+    """
 
     def __init__(self, dock):
         """Initialize internal hassio network."""
@@ -52,7 +55,8 @@ class DockerNetwork(object):
         ipam_config = docker.types.IPAMConfig(pool_configs=[ipam_pool])
 
         return self.docker.networks.create(
-            DOCKER_NETWORK, driver='bridge', ipam=ipam_config, options={
+            DOCKER_NETWORK, driver='bridge', ipam=ipam_config,
+            enable_ipv6=False, options={
                 "com.docker.network.bridge.name": DOCKER_NETWORK,
             })
 

hassio/homeassistant.py

@@ -3,14 +3,16 @@ import asyncio
 import logging
 import os
 import re
+import socket
+import time
 
 import aiohttp
 from aiohttp.hdrs import CONTENT_TYPE
 
 from .const import (
-    FILE_HASSIO_HOMEASSISTANT, ATTR_IMAGE, ATTR_LAST_VERSION,
+    FILE_HASSIO_HOMEASSISTANT, ATTR_IMAGE, ATTR_LAST_VERSION, ATTR_UUID,
     ATTR_BOOT, ATTR_PASSWORD, ATTR_PORT, ATTR_SSL, ATTR_WATCHDOG,
-    HEADER_HA_ACCESS, CONTENT_TYPE_JSON)
+    ATTR_STARTUP_TIME, HEADER_HA_ACCESS, CONTENT_TYPE_JSON)
 from .coresys import CoreSysAttributes
 from .docker.homeassistant import DockerHomeAssistant
 from .utils import convert_to_ascii
@@ -53,7 +55,6 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
     def api_port(self, value):
         """Set network port for home-assistant instance."""
         self._data[ATTR_PORT] = value
-        self.save()
 
     @property
     def api_password(self):
@@ -92,6 +93,16 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
         """Return True if the watchdog should protect Home-Assistant."""
         self._data[ATTR_WATCHDOG] = value
 
+    @property
+    def startup_time(self):
+        """Return time to wait for Home-Assistant startup."""
+        return self._data[ATTR_STARTUP_TIME]
+
+    @startup_time.setter
+    def startup_time(self, value):
+        """Set time to wait for Home-Assistant startup."""
+        self._data[ATTR_STARTUP_TIME] = value
+
     @property
     def version(self):
         """Return version of running homeassistant."""
@@ -143,6 +154,11 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
         """Set home-assistant boot options."""
         self._data[ATTR_BOOT] = value
 
+    @property
+    def uuid(self):
+        """Return a UUID of this HomeAssistant."""
+        return self._data[ATTR_UUID]
+
     async def install_landingpage(self):
         """Install a landingpage."""
         _LOGGER.info("Setup HomeAssistant landingpage")
@@ -152,8 +168,8 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
             _LOGGER.warning("Fails install landingpage, retry after 60sec")
             await asyncio.sleep(60, loop=self._loop)
 
-        # run landingpage after installation
-        await self.instance.run()
+        # Run landingpage after installation
+        await self.start()
 
     async def install(self):
         """Install a landingpage."""
@@ -172,7 +188,7 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
         # finishing
         _LOGGER.info("HomeAssistant docker now installed")
         if self.boot:
-            await self.instance.run()
+            await self.start()
         await self.instance.cleanup()
 
     async def update(self, version=None):
@@ -189,14 +205,14 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
             return await self.instance.update(version)
         finally:
             if running:
-                await self.instance.run()
+                await self.start()
 
-    def run(self):
-        """Run HomeAssistant docker.
+    async def start(self):
+        """Run HomeAssistant docker."""
+        if not await self.instance.run():
+            return False
 
-        Return a coroutine.
-        """
-        return self.instance.run()
+        return await self._block_till_run()
 
     def stop(self):
         """Stop HomeAssistant docker.
@@ -205,12 +221,12 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
         """
         return self.instance.stop()
 
-    def restart(self):
-        """Restart HomeAssistant docker.
+    async def restart(self):
+        """Restart HomeAssistant docker."""
+        if not await self.instance.restart():
+            return False
 
-        Return a coroutine.
-        """
-        return self.instance.restart()
+        return await self._block_till_run()
 
     def logs(self):
         """Get HomeAssistant docker logs.
@@ -281,3 +297,54 @@ class HomeAssistant(JsonConfig, CoreSysAttributes):
         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
+
+    async def _block_till_run(self):
+        """Block until Home-Assistant is booting up or startup timeout."""
+        start_time = time.monotonic()
+
+        def check_port():
+            """Check if port is mapped."""
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            try:
+                result = sock.connect_ex((str(self.api_ip), self.api_port))
+                sock.close()
+
+                if result == 0:
+                    return True
+                return False
+            except OSError:
+                pass
+
+        while time.monotonic() - start_time < self.startup_time:
+            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)
+
+        _LOGGER.warning("Don't wait anymore of Home-Assistant startup!")
+        return False

hassio/services/__init__.py

@@ -0,0 +1,45 @@
+"""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
+
+
+AVAILABLE_SERVICES = {
+    SERVICE_MQTT: MQTTService
+}
+
+
+class ServiceManager(CoreSysAttributes):
+    """Handle internal services discovery."""
+
+    def __init__(self, coresys):
+        """Initialize Services handler."""
+        self.coresys = coresys
+        self.data = ServicesData()
+        self.discovery = Discovery(coresys)
+        self.services_obj = {}
+
+    @property
+    def list_services(self):
+        """Return a list of services."""
+        return list(self.services_obj.values())
+
+    def get(self, slug):
+        """Return service object from slug."""
+        return self.services_obj.get(slug)
+
+    async def load(self):
+        """Load available services."""
+        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

@@ -0,0 +1,23 @@
+"""Handle service data for persistent supervisor reboot."""
+
+from .validate import SCHEMA_SERVICES_FILE
+from ..const import FILE_HASSIO_SERVICES, ATTR_DISCOVERY, SERVICE_MQTT
+from ..utils.json import JsonConfig
+
+
+class ServicesData(JsonConfig):
+    """Class to handle services data."""
+
+    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]
+
+    @property
+    def mqtt(self):
+        """Return settings for mqtt service."""
+        return self._data[SERVICE_MQTT]

hassio/services/discovery.py

@@ -0,0 +1,107 @@
+"""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

@@ -0,0 +1,54 @@
+"""Interface for single service."""
+
+from ..coresys import CoreSysAttributes
+
+
+class ServiceInterface(CoreSysAttributes):
+    """Interface class for service integration."""
+
+    def __init__(self, coresys):
+        """Initialize service interface."""
+        self.coresys = coresys
+
+    @property
+    def slug(self):
+        """Return slug of this service."""
+        return None
+
+    @property
+    def _data(self):
+        """Return data of this service."""
+        return None
+
+    @property
+    def schema(self):
+        """Return data schema of this service."""
+        return None
+
+    @property
+    def provider(self):
+        """Return name of service provider."""
+        return None
+
+    @property
+    def enabled(self):
+        """Return True if the service is in use."""
+        return bool(self._data)
+
+    def save(self):
+        """Save changes."""
+        self._services.data.save_data()
+
+    def get_service_data(self):
+        """Return the requested service data."""
+        if self.enabled:
+            return self._data
+        return None
+
+    def set_service_data(self, provider, data):
+        """Write the data into service object."""
+        raise NotImplementedError()
+
+    def del_service_data(self, provider):
+        """Remove the data from service object."""
+        raise NotImplementedError()

hassio/services/mqtt.py

@@ -0,0 +1,89 @@
+"""Provide 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)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MQTTService(ServiceInterface):
+    """Provide mqtt services."""
+
+    @property
+    def slug(self):
+        """Return slug of this service."""
+        return SERVICE_MQTT
+
+    @property
+    def _data(self):
+        """Return data of this service."""
+        return self._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):
+        """Write the data into service object."""
+        if self.enabled:
+            _LOGGER.error("It is already a mqtt in use from %s", self.provider)
+            return False
+
+        self._data.update(data)
+        self._data[ATTR_PROVIDER] = provider
+
+        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
+        self.save()
+        return True
+
+    def del_service_data(self, provider):
+        """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))
+
+        self._data.clear()
+        self.save()
+        return True

hassio/services/validate.py

@@ -0,0 +1,44 @@
+"""Validate services schema."""
+
+import voluptuous as vol
+
+from ..const import (
+    SERVICE_MQTT, ATTR_HOST, ATTR_PORT, ATTR_PASSWORD, ATTR_USERNAME, ATTR_SSL,
+    ATTR_PROVIDER, ATTR_PROTOCOL, ATTR_DISCOVERY, ATTR_COMPONENT, ATTR_UUID,
+    ATTR_PLATFORM, ATTR_CONFIG, ATTR_DISCOVERY_ID)
+from ..validate import NETWORK_PORT
+
+
+SCHEMA_DISCOVERY = vol.Schema([
+    vol.Schema({
+        vol.Required(ATTR_UUID): vol.Match(r"^[0-9a-f]{32}$"),
+        vol.Required(ATTR_PROVIDER): vol.Coerce(str),
+        vol.Required(ATTR_COMPONENT): vol.Coerce(str),
+        vol.Required(ATTR_PLATFORM): vol.Any(None, vol.Coerce(str)),
+        vol.Required(ATTR_CONFIG): vol.Any(None, dict),
+    }, extra=vol.REMOVE_EXTRA)
+])
+
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_SERVICE_MQTT = vol.Schema({
+    vol.Required(ATTR_HOST): vol.Coerce(str),
+    vol.Required(ATTR_PORT): NETWORK_PORT,
+    vol.Optional(ATTR_USERNAME): vol.Coerce(str),
+    vol.Optional(ATTR_PASSWORD): vol.Coerce(str),
+    vol.Optional(ATTR_SSL, default=False): vol.Boolean(),
+    vol.Optional(ATTR_PROTOCOL, default='3.1.1'):
+        vol.All(vol.Coerce(str), vol.In(['3.1', '3.1.1'])),
+})
+
+
+SCHEMA_CONFIG_MQTT = SCHEMA_SERVICE_MQTT.extend({
+    vol.Required(ATTR_PROVIDER): vol.Coerce(str),
+    vol.Optional(ATTR_DISCOVERY_ID): vol.Match(r"^[0-9a-f]{32}$"),
+})
+
+
+SCHEMA_SERVICES_FILE = vol.Schema({
+    vol.Optional(SERVICE_MQTT, default=dict): vol.Any({}, SCHEMA_CONFIG_MQTT),
+    vol.Optional(ATTR_DISCOVERY, default=list): vol.Any([], SCHEMA_DISCOVERY),
+}, extra=vol.REMOVE_EXTRA)

hassio/snapshots/__init__.py

@@ -14,7 +14,7 @@ from ..coresys import CoreSysAttributes
 _LOGGER = logging.getLogger(__name__)
 
 
-class SnapshotsManager(CoreSysAttributes):
+class SnapshotManager(CoreSysAttributes):
     """Manage snapshots."""
 
     def __init__(self, coresys):
@@ -112,14 +112,15 @@ class SnapshotsManager(CoreSysAttributes):
                 _LOGGER.info("Full-Snapshot %s store folders", snapshot.slug)
                 await snapshot.store_folders()
 
-            _LOGGER.info("Full-Snapshot %s done", snapshot.slug)
-            self.snapshots_obj[snapshot.slug] = snapshot
-            return True
-
         except (OSError, ValueError, tarfile.TarError) as err:
             _LOGGER.info("Full-Snapshot %s error: %s", snapshot.slug, err)
             return False
 
+        else:
+            _LOGGER.info("Full-Snapshot %s done", snapshot.slug)
+            self.snapshots_obj[snapshot.slug] = snapshot
+            return True
+
         finally:
             self._scheduler.suspend = False
             self.lock.release()
@@ -157,14 +158,15 @@ class SnapshotsManager(CoreSysAttributes):
                              snapshot.slug, folders)
                 await snapshot.store_folders(folders)
 
-            _LOGGER.info("Partial-Snapshot %s done", snapshot.slug)
-            self.snapshots_obj[snapshot.slug] = snapshot
-            return True
-
         except (OSError, ValueError, tarfile.TarError) as err:
             _LOGGER.info("Partial-Snapshot %s error: %s", snapshot.slug, err)
             return False
 
+        else:
+            _LOGGER.info("Partial-Snapshot %s done", snapshot.slug)
+            self.snapshots_obj[snapshot.slug] = snapshot
+            return True
+
         finally:
             self._scheduler.suspend = False
             self.lock.release()
@@ -229,7 +231,7 @@ class SnapshotsManager(CoreSysAttributes):
                     if addon:
                         tasks.append(addon.uninstall())
                     else:
-                        _LOGGER.warning("Can't remove addon %s", slug)
+                        _LOGGER.warning("Can't remove addon %s", snapshot.slug)
 
                 for slug in restore_addons:
                     addon = self._addons.get(slug)
@@ -247,15 +249,16 @@ class SnapshotsManager(CoreSysAttributes):
                 _LOGGER.info("Full-Restore %s wait until homeassistant ready",
                              snapshot.slug)
                 await task_hass
-                await self._homeassistant.run()
-
-            _LOGGER.info("Full-Restore %s done", snapshot.slug)
-            return True
+                await self._homeassistant.start()
 
         except (OSError, ValueError, tarfile.TarError) as err:
-            _LOGGER.info("Full-Restore %s error: %s", slug, err)
+            _LOGGER.info("Full-Restore %s error: %s", snapshot.slug, err)
             return False
 
+        else:
+            _LOGGER.info("Full-Restore %s done", snapshot.slug)
+            return True
+
         finally:
             self._scheduler.suspend = False
             self.lock.release()
@@ -298,7 +301,8 @@ class SnapshotsManager(CoreSysAttributes):
                     if addon:
                         tasks.append(snapshot.export_addon(addon))
                     else:
-                        _LOGGER.warning("Can't restore addon %s", slug)
+                        _LOGGER.warning("Can't restore addon %s",
+                                        snapshot.slug)
 
                 if tasks:
                     _LOGGER.info("Partial-Restore %s run %d tasks",
@@ -306,15 +310,16 @@ class SnapshotsManager(CoreSysAttributes):
                     await asyncio.wait(tasks, loop=self._loop)
 
                 # make sure homeassistant run agen
-                await self._homeassistant.run()
-
-            _LOGGER.info("Partial-Restore %s done", snapshot.slug)
-            return True
+                await self._homeassistant.start()
 
         except (OSError, ValueError, tarfile.TarError) as err:
-            _LOGGER.info("Partial-Restore %s error: %s", slug, err)
+            _LOGGER.info("Partial-Restore %s error: %s", snapshot.slug, err)
             return False
 
+        else:
+            _LOGGER.info("Partial-Restore %s done", snapshot.slug)
+            return True
+
         finally:
             self._scheduler.suspend = False
             self.lock.release()

hassio/snapshots/snapshot.py

@@ -15,7 +15,7 @@ from ..const import (
     ATTR_SLUG, ATTR_NAME, ATTR_DATE, ATTR_ADDONS, ATTR_REPOSITORIES,
     ATTR_HOMEASSISTANT, ATTR_FOLDERS, ATTR_VERSION, ATTR_TYPE, ATTR_IMAGE,
     ATTR_PORT, ATTR_SSL, ATTR_PASSWORD, ATTR_WATCHDOG, ATTR_BOOT,
-    ATTR_LAST_VERSION)
+    ATTR_LAST_VERSION, ATTR_STARTUP_TIME)
 from ..coresys import CoreSysAttributes
 from ..utils.json import write_json_file
 
@@ -142,6 +142,16 @@ class Snapshot(CoreSysAttributes):
         """Set snapshot homeassistant watchdog options."""
         self._data[ATTR_HOMEASSISTANT][ATTR_WATCHDOG] = value
 
+    @property
+    def homeassistant_startup_time(self):
+        """Return snapshot homeassistant startup time options."""
+        return self._data[ATTR_HOMEASSISTANT].get(ATTR_STARTUP_TIME)
+
+    @homeassistant_startup_time.setter
+    def homeassistant_startup_time(self, value):
+        """Set snapshot homeassistant startup time options."""
+        self._data[ATTR_HOMEASSISTANT][ATTR_STARTUP_TIME] = value
+
     @property
     def homeassistant_boot(self):
         """Return snapshot homeassistant boot options."""
@@ -244,12 +254,13 @@ class Snapshot(CoreSysAttributes):
             with tarfile.open(self.tar_file, "w:") as tar:
                 tar.add(self._tmp.name, arcname=".")
 
-        if write_json_file(Path(self._tmp.name, "snapshot.json"), self._data):
+        try:
+            write_json_file(Path(self._tmp.name, "snapshot.json"), self._data)
             await self._loop.run_in_executor(None, _create_snapshot)
-        else:
-            _LOGGER.error("Can't write snapshot.json")
-
-        self._tmp.cleanup()
+        except (OSError, json.JSONDecodeError) as err:
+            _LOGGER.error("Can't write snapshot: %s", err)
+        finally:
+            self._tmp.cleanup()
 
     async def import_addon(self, addon):
         """Add a addon into snapshot."""
@@ -280,7 +291,7 @@ class Snapshot(CoreSysAttributes):
 
     async def store_folders(self, folder_list=None):
         """Backup hassio data into snapshot."""
-        folder_list = folder_list or ALL_FOLDERS
+        folder_list = set(folder_list or ALL_FOLDERS)
 
         def _folder_save(name):
             """Intenal function to snapshot a folder."""
@@ -293,8 +304,8 @@ class Snapshot(CoreSysAttributes):
                 with tarfile.open(snapshot_tar, "w:gz",
                                   compresslevel=1) as tar_file:
                     tar_file.add(origin_dir, arcname=".")
-                    _LOGGER.info("Snapshot folder %s done", name)
 
+                _LOGGER.info("Snapshot folder %s done", name)
                 self._data[ATTR_FOLDERS].append(name)
             except (tarfile.TarError, OSError) as err:
                 _LOGGER.warning("Can't snapshot folder %s: %s", name, err)
@@ -307,7 +318,7 @@ class Snapshot(CoreSysAttributes):
 
     async def restore_folders(self, folder_list=None):
         """Backup hassio data into snapshot."""
-        folder_list = folder_list or ALL_FOLDERS
+        folder_list = set(folder_list or self.folders)
 
         def _folder_restore(name):
             """Intenal function to restore a folder."""
@@ -323,7 +334,7 @@ class Snapshot(CoreSysAttributes):
                 _LOGGER.info("Restore folder %s", name)
                 with tarfile.open(snapshot_tar, "r:gz") as tar_file:
                     tar_file.extractall(path=origin_dir)
-                    _LOGGER.info("Restore folder %s done", name)
+                _LOGGER.info("Restore folder %s done", name)
             except (tarfile.TarError, OSError) as err:
                 _LOGGER.warning("Can't restore folder %s: %s", name, err)
 
@@ -338,6 +349,7 @@ class Snapshot(CoreSysAttributes):
         self.homeassistant_version = self._homeassistant.version
         self.homeassistant_watchdog = self._homeassistant.watchdog
         self.homeassistant_boot = self._homeassistant.boot
+        self.homeassistant_startup_time = self._homeassistant.startup_time
 
         # custom image
         if self._homeassistant.is_custom_image:
@@ -353,6 +365,7 @@ class Snapshot(CoreSysAttributes):
         """Write all data to homeassistant object."""
         self._homeassistant.watchdog = self.homeassistant_watchdog
         self._homeassistant.boot = self.homeassistant_boot
+        self._homeassistant.startup_time = self.homeassistant_startup_time
 
         # custom image
         if self.homeassistant_image:
@@ -365,7 +378,7 @@ class Snapshot(CoreSysAttributes):
         self._homeassistant.api_password = self.homeassistant_password
 
         # save
-        self._homeassistant.save()
+        self._homeassistant.save_data()
 
     def store_repositories(self):
         """Store repository list into snapshot."""

hassio/snapshots/validate.py

@@ -6,34 +6,47 @@ from ..const import (
     ATTR_REPOSITORIES, ATTR_ADDONS, ATTR_NAME, ATTR_SLUG, ATTR_DATE,
     ATTR_VERSION, ATTR_HOMEASSISTANT, ATTR_FOLDERS, ATTR_TYPE, ATTR_IMAGE,
     ATTR_PASSWORD, ATTR_PORT, ATTR_SSL, ATTR_WATCHDOG, ATTR_BOOT,
-    ATTR_LAST_VERSION,
+    ATTR_LAST_VERSION, ATTR_STARTUP_TIME,
     FOLDER_SHARE, FOLDER_HOMEASSISTANT, FOLDER_ADDONS, FOLDER_SSL,
     SNAPSHOT_FULL, SNAPSHOT_PARTIAL)
-from ..validate import NETWORK_PORT
+from ..validate import NETWORK_PORT, REPOSITORIES, DOCKER_IMAGE
 
 ALL_FOLDERS = [FOLDER_HOMEASSISTANT, FOLDER_SHARE, FOLDER_ADDONS, FOLDER_SSL]
 
+
+def unique_addons(addons_list):
+    """Validate that a add-on is unique."""
+    single = set([addon[ATTR_SLUG] for addon in addons_list])
+
+    if len(single) != len(addons_list):
+        raise vol.Invalid("Invalid addon list on snapshot!")
+    return addons_list
+
+
 # pylint: disable=no-value-for-parameter
 SCHEMA_SNAPSHOT = vol.Schema({
     vol.Required(ATTR_SLUG): vol.Coerce(str),
     vol.Required(ATTR_TYPE): vol.In([SNAPSHOT_FULL, SNAPSHOT_PARTIAL]),
     vol.Required(ATTR_NAME): vol.Coerce(str),
     vol.Required(ATTR_DATE): vol.Coerce(str),
-    vol.Optional(ATTR_HOMEASSISTANT, default={}): vol.Schema({
+    vol.Optional(ATTR_HOMEASSISTANT, default=dict): vol.Schema({
         vol.Required(ATTR_VERSION): vol.Coerce(str),
-        vol.Optional(ATTR_IMAGE): vol.Coerce(str),
-        vol.Optional(ATTR_LAST_VERSION): vol.Coerce(str),
+        vol.Inclusive(ATTR_IMAGE, 'custom_hass'): DOCKER_IMAGE,
+        vol.Inclusive(ATTR_LAST_VERSION, 'custom_hass'): vol.Coerce(str),
         vol.Optional(ATTR_BOOT, default=True): vol.Boolean(),
         vol.Optional(ATTR_SSL, default=False): vol.Boolean(),
         vol.Optional(ATTR_PORT, default=8123): NETWORK_PORT,
         vol.Optional(ATTR_PASSWORD): vol.Any(None, vol.Coerce(str)),
         vol.Optional(ATTR_WATCHDOG, default=True): vol.Boolean(),
+        vol.Optional(ATTR_STARTUP_TIME, default=600):
+            vol.All(vol.Coerce(int), vol.Range(min=60)),
     }, extra=vol.REMOVE_EXTRA),
-    vol.Optional(ATTR_FOLDERS, default=[]): [vol.In(ALL_FOLDERS)],
-    vol.Optional(ATTR_ADDONS, default=[]): [vol.Schema({
+    vol.Optional(ATTR_FOLDERS, default=list):
+        vol.All([vol.In(ALL_FOLDERS)], vol.Unique()),
+    vol.Optional(ATTR_ADDONS, default=list): vol.All([vol.Schema({
         vol.Required(ATTR_SLUG): vol.Coerce(str),
         vol.Required(ATTR_NAME): vol.Coerce(str),
         vol.Required(ATTR_VERSION): vol.Coerce(str),
-    }, extra=vol.REMOVE_EXTRA)],
-    vol.Optional(ATTR_REPOSITORIES, default=[]): [vol.Url()],
+    }, extra=vol.REMOVE_EXTRA)], unique_addons),
+    vol.Optional(ATTR_REPOSITORIES, default=list): REPOSITORIES,
 }, extra=vol.ALLOW_EXTRA)

hassio/supervisor.py

@@ -21,6 +21,11 @@ class Supervisor(CoreSysAttributes):
             _LOGGER.fatal("Can't setup supervisor docker container!")
         await self.instance.cleanup()
 
+    @property
+    def need_update(self):
+        """Return True if a update is available."""
+        return self.version != self.last_version
+
     @property
     def version(self):
         """Return version of running homeassistant."""

hassio/tasks.py

@@ -1,6 +1,5 @@
 """Multible tasks."""
 import asyncio
-from datetime import datetime
 import logging
 
 from .coresys import CoreSysAttributes
@@ -22,8 +21,6 @@ class Tasks(CoreSysAttributes):
     RUN_WATCHDOG_HOMEASSISTANT_DOCKER = 15
     RUN_WATCHDOG_HOMEASSISTANT_API = 300
 
-    RUN_CLEANUP_API_SESSIONS = 900
-
     def __init__(self, coresys):
         """Initialize Tasks."""
         self.coresys = coresys
@@ -32,7 +29,6 @@ class Tasks(CoreSysAttributes):
 
     async def load(self):
         """Add Tasks to scheduler."""
-
         self.jobs.add(self._scheduler.register_task(
             self._update_addons, self.RUN_UPDATE_ADDONS))
         self.jobs.add(self._scheduler.register_task(
@@ -54,12 +50,7 @@ class Tasks(CoreSysAttributes):
             self._watchdog_homeassistant_api,
             self.RUN_WATCHDOG_HOMEASSISTANT_API))
 
-    async def _cleanup_sessions(self):
-        """Cleanup old api sessions."""
-        now = datetime.now()
-        for session, until_valid in self._config.security_sessions.items():
-            if now >= until_valid:
-                self._config.drop_security_session(session)
+        _LOGGER.info("All core tasks are scheduled")
 
     async def _update_addons(self):
         """Check if a update is available of a addon and update it."""
@@ -83,8 +74,7 @@ class Tasks(CoreSysAttributes):
 
     async def _update_supervisor(self):
         """Check and run update of supervisor hassio."""
-        await self._updater.reload()
-        if self._supervisor.last_version == self._supervisor.version:
+        if not self._supervisor.need_update:
             return
 
         # don't perform a update on beta/dev channel
@@ -108,7 +98,7 @@ class Tasks(CoreSysAttributes):
             return
 
         _LOGGER.warning("Watchdog found a problem with Home-Assistant docker!")
-        await self._homeassistant.run()
+        await self._homeassistant.start()
 
     async def _watchdog_homeassistant_api(self):
         """Create scheduler task for montoring running state of API.

hassio/updater.py

@@ -89,4 +89,4 @@ class Updater(JsonConfig, CoreSysAttributes):
         # update versions
         self._data[ATTR_HOMEASSISTANT] = data.get('homeassistant')
         self._data[ATTR_HASSIO] = data.get('hassio')
-        self.save()
+        self.save_data()

hassio/utils/json.py

@@ -10,14 +10,9 @@ _LOGGER = logging.getLogger(__name__)
 
 def write_json_file(jsonfile, data):
     """Write a json file."""
-    try:
-        json_str = json.dumps(data, indent=2)
-        with jsonfile.open('w') as conf_file:
-            conf_file.write(json_str)
-    except (OSError, json.JSONDecodeError):
-        return False
-
-    return True
+    json_str = json.dumps(data, indent=2)
+    with jsonfile.open('w') as conf_file:
+        conf_file.write(json_str)
 
 
 def read_json_file(jsonfile):
@@ -35,7 +30,18 @@ class JsonConfig(object):
         self._schema = schema
         self._data = {}
 
-        # init or load data
+        self.read_data()
+
+    def reset_data(self):
+        """Reset json file to default."""
+        try:
+            self._data = self._schema({})
+        except vol.Invalid as ex:
+            _LOGGER.error("Can't reset %s: %s",
+                          self._file, humanize_error(self._data, ex))
+
+    def read_data(self):
+        """Read json file & validate."""
         if self._file.is_file():
             try:
                 self._data = read_json_file(self._file)
@@ -43,27 +49,33 @@ class JsonConfig(object):
                 _LOGGER.warning("Can't read %s", self._file)
                 self._data = {}
 
-        # validate
+        # Validate
         try:
             self._data = self._schema(self._data)
         except vol.Invalid as ex:
             _LOGGER.error("Can't parse %s: %s",
                           self._file, humanize_error(self._data, ex))
-            # reset data to default
+
+            # Reset data to default
+            _LOGGER.warning("Reset %s to default", self._file)
             self._data = self._schema({})
 
-    def save(self):
+    def save_data(self):
         """Store data to config file."""
-        # validate
+        # Validate
         try:
             self._data = self._schema(self._data)
         except vol.Invalid as ex:
             _LOGGER.error("Can't parse data: %s",
                           humanize_error(self._data, ex))
-            return False
+
+            # Load last valid data
+            _LOGGER.warning("Reset %s to last version", self._file)
+            self.read_data()
+            return
 
         # write
-        if not write_json_file(self._file, self._data):
-            _LOGGER.error("Can't store config in %s", self._file)
-            return False
-        return True
+        try:
+            write_json_file(self._file, self._data)
+        except (OSError, json.JSONDecodeError) as err:
+            _LOGGER.error("Can't store config in %s: %s", self._file, err)

hassio/validate.py

@@ -1,19 +1,24 @@
 """Validate functions."""
-import voluptuous as vol
+import uuid
 
+import voluptuous as vol
 import pytz
 
 from .const import (
-    ATTR_IMAGE, ATTR_LAST_VERSION, ATTR_SESSIONS, ATTR_PASSWORD, ATTR_TOTP,
-    ATTR_SECURITY, ATTR_BETA_CHANNEL, ATTR_TIMEZONE, ATTR_ADDONS_CUSTOM_LIST,
-    ATTR_AUDIO_OUTPUT, ATTR_AUDIO_INPUT, ATTR_HOMEASSISTANT, ATTR_HASSIO,
-    ATTR_BOOT, ATTR_LAST_BOOT, ATTR_SSL, ATTR_PORT, ATTR_WATCHDOG,
-    ATTR_WAIT_BOOT)
+    ATTR_IMAGE, ATTR_LAST_VERSION, ATTR_BETA_CHANNEL, ATTR_TIMEZONE,
+    ATTR_ADDONS_CUSTOM_LIST, ATTR_AUDIO_OUTPUT, ATTR_AUDIO_INPUT,
+    ATTR_PASSWORD, ATTR_HOMEASSISTANT, ATTR_HASSIO, ATTR_BOOT, ATTR_LAST_BOOT,
+    ATTR_SSL, ATTR_PORT, ATTR_WATCHDOG, ATTR_WAIT_BOOT, ATTR_UUID,
+    ATTR_STARTUP_TIME)
 
 
 NETWORK_PORT = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
 ALSA_CHANNEL = vol.Match(r"\d+,\d+")
 WAIT_BOOT = vol.All(vol.Coerce(int), vol.Range(min=1, max=60))
+DOCKER_IMAGE = vol.Match(r"^[\w{}]+/[\-\w{}]+$")
+
+# pylint: disable=no-value-for-parameter
+REPOSITORIES = vol.All([vol.Url()], vol.Unique())
 
 
 def validate_timezone(timezone):
@@ -59,13 +64,17 @@ DOCKER_PORTS = vol.Schema({
 
 # pylint: disable=no-value-for-parameter
 SCHEMA_HASS_CONFIG = vol.Schema({
+    vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex):
+        vol.Match(r"^[0-9a-f]{32}$"),
     vol.Optional(ATTR_BOOT, default=True): vol.Boolean(),
-    vol.Inclusive(ATTR_IMAGE, 'custom_hass'): vol.Coerce(str),
+    vol.Inclusive(ATTR_IMAGE, 'custom_hass'): DOCKER_IMAGE,
     vol.Inclusive(ATTR_LAST_VERSION, 'custom_hass'): vol.Coerce(str),
     vol.Optional(ATTR_PORT, default=8123): NETWORK_PORT,
     vol.Optional(ATTR_PASSWORD): vol.Any(None, vol.Coerce(str)),
     vol.Optional(ATTR_SSL, default=False): vol.Boolean(),
     vol.Optional(ATTR_WATCHDOG, default=True): vol.Boolean(),
+    vol.Optional(ATTR_STARTUP_TIME, default=600):
+        vol.All(vol.Coerce(int), vol.Range(min=60)),
 }, extra=vol.REMOVE_EXTRA)
 
 
@@ -83,12 +92,7 @@ SCHEMA_HASSIO_CONFIG = vol.Schema({
     vol.Optional(ATTR_LAST_BOOT): vol.Coerce(str),
     vol.Optional(ATTR_ADDONS_CUSTOM_LIST, default=[
         "https://github.com/hassio-addons/repository",
-    ]): [vol.Url()],
-    vol.Optional(ATTR_SECURITY, default=False): vol.Boolean(),
-    vol.Optional(ATTR_TOTP): vol.Coerce(str),
-    vol.Optional(ATTR_PASSWORD): vol.Coerce(str),
-    vol.Optional(ATTR_SESSIONS, default={}):
-        vol.Schema({vol.Coerce(str): vol.Coerce(str)}),
+    ]): REPOSITORIES,
     vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_CHANNEL,
     vol.Optional(ATTR_AUDIO_INPUT): ALSA_CHANNEL,
     vol.Optional(ATTR_WAIT_BOOT, default=5): WAIT_BOOT,

misc/hassio.xml

@@ -1 +1 @@
-<mxfile userAgent="Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36" version="6.5.6" editor="www.draw.io" type="device"><diagram name="Page-1">5Vptc6M2EP41/ng3gHj9mPiSy820c5n6Q3sfsVBsNTJyhYid/voKkABZkOBY+KYtmYnR6pVn99ld1l6A5e74laX77a80Q2ThOdlxAb4sPC8OY/G/Erw2At9xG8GG4awR9QQr/DeSQkdKS5yhQhvIKSUc73UhpHmOINdkKWP0oA97okTfdZ9ukCFYwZSY0t9xxrdS6oZJ1/GA8GYrt469sOlYp/B5w2iZy/0WHniqr6Z7l6q15IMW2zSjh54I3C3AklHKm7vdcYlIBa2CrZl3P9LbnpuhnE+Z4DUTXlJSInXikIipt09UrCAOyF8lKOFfJVUdn4paZTdigNjtKD5ERw206DtIYKrenLJdSrrJ4m5TfX5fqX3E2Zqtmg4JS7urd9hijlb7FFbtg7A2MWjLd0S03Oo0mJAlJZTVowXYKIRQyAvO6DPq9Tj1Jc+/kutLvF4Q4+g4CqHbKkbYO6I7xNmrGKImJKCZIm09SKRuD53l+Arobc9oQjkulca6aZfuFCZupM6G9QcM/X3LcaW31WvB0e5CNGGG1vF6CE0QggRkrb7sAhhNBNCzAKBvAPiFwmfELkUOokCQ/trI+SZy3hBywAJyoYHcw9JArXaFqJpRUe9MLscQDXN5HQd+4NjB0A8DHcPQxDBwTAgDCxAmBl4oE3FINinjW7qheUruOumtjmgPPXTE/I9K/DkKZPOH6srFwZq+QDV/yBX+RJy/ygiclpwKUbfxL5Tu5RrNUavzvQ20eBxaMihHRTJ4p2yDeM9uTHUwRFKOX/TVLwFX5RK20fXeQDcB3im+deMRMSweALGfBbp/JdCj0Xxi3UX48xIMN6wSjNMEYlXuEXvBhXAJagOm+h7Sovj2fTTBaMXr0aSjMwP3fbdluKflMgybVEN3aFmA4sy347ZAoLstMJB1uPGA33JtRE3Xm4Nbbo9Yyou13NJ4VbuxeUnkqveOHouiK7EIzOO6NHh1dE/iQtc89VyFwIPfVK9YQgCJYBqGSnyPidpzqm5QnpmLCWFvqcFMfrm0qlgvvlZQUm8cvaxJrPLpRjy6wLByU9dxRSmKn6CtLFR3Rd5A/t56HS1/9224ovDKXHE/O3qQ/+zG8aWBfiKtPmjxwLR4d0Sn1i3enyVUSJ30srCJCPYcTk5zpHmb8xQ2Vl+AJXtp+WpPYdeKPa5ZUrjJMpoXhhqLbbqvbveMQlQU73sn3ZVN9lX34qr9fZMTCt07XhiBxANhEHtx7PhgpqRqyJN5bmB6ssSCI1O1nDmJ0rVOHdWlqYAkU59uc7zoXEAAOfWR4vq9Q5WqneE0Wq3Q0FJO6hdSz1ynobKxTm0U7dNMs5PYJCjk1KxYKX6WO9IMALcVOzAUyKdrRB5pgTmmuRiyppzTnRhAqo7btoitVVbrMna3xg3Bm2oup+fRvCvEnpZu5QYWiHxS0wEDNR0wkJBYqciaNJ5AUifSWOq/x1LX5OgUOk5Ity8PgO97LQshEng/L0SqvXsMPBwOpvcmBO+LWg2SiZDQMrs4Tl6FQInuz3xnIKeP5iovgLcLo9K4P5DEn8mRmTLEXqzt3hyaQ3qj0faDNPFNmjTmaz+S+icmc+pN7YVAMP6tjfNQrkcjIUzZ5fQL62uAfkH1Z4d+CThJJ4boN1TdsxLBopnY17f7yGaWOT9lP8i+YAb2TVZjYJDkK+bbuekxFp2QmwUomocevnppvQo94v9LcEpCnaOR5dgU/idjk/m9+G9oX71qUYbReBXl30s+Vf6dgXyi2f0WqlFG93szcPcP</diagram></mxfile>
+<mxfile userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36" version="7.9.5" editor="www.draw.io" type="device"><diagram name="Page-1" id="535f6c39-9b73-04c2-941c-82630de90f1a">5VrLcqM4FP0aLzsFiOcycefRVTPVqfFippdYKLYmMvII4cd8/QiQDEKQ4Bicnmp7Yevqybk691zJnoH55vDI4u36d5ogMnOs5DADX2eOY1vAER+F5VhZ3DCoDCuGE9moNizwv0j1lNYcJyjTGnJKCcdb3QhpmiLINVvMGN3rzV4o0WfdxitkGBYwJqb1T5zwtbTaflRXPCG8WsupQ8evKpYxfF0xmqdyvpkDXspXVb2J1VjyQbN1nNB9wwTuZ2DOKOXVt81hjkiBrYKt6vfQU3taN0MpH9JB+mkXkxypFftEdL17oWIEsUB+lKD4/+RUVXzJSpfdigZitoP4EBUl0KJuL4EpalPKNjGpO4tvq+Lz+0LNI9ZWTVVVSFhOszr7NeZosY1hUd6L7SYarfmGiJJdrAYTMqeEsrK1ABv5EAp7xhl9RY0aq3zJ9S/k+B14SdMOMY4ODZPE7xHRDeLsKJqo2ghUXeRe9yLp2329c1wF9LqxaXzZLpabdXUaunaY+CJ91u0/YPjvW4oLvy2OGUebC9GECVqGyy40gQ8ikJz8NS6AwUAAnREAdA0Av1L4itilyEHkCdJfGznXRM7pQg6MgJxvIPc0N1ArQyEqehTUO5PLIUTdXF6GnutZ42Do+p6OoW9i6FkmhN4IEEYGXigROiSLlPE1XdE0Jve19U5HtIEeOmD+V2G+CTxZ/KGqUrGwqs5TxR9yhL8R50epwHHOqTDVE/9G6VaO0Qt1RnMG5fKlyvOYrRDXtknxYG+6gyESc7zTBfgScFUuMTa6zhvoRiLxaeFbFp4Rw+IBELsS6O5ngR705hPLWuHPSzBsv0gw2gnEIt8itsOZCAlqAqbqnuIs+/a9N8E4mZe9SUe9Dez3w5YRnuZz369SDT2gJR4KE3ecsAU8PWyBjqzDDjvilj2GatrOFNyyG8RSUezELY1XZRgbSqJMMIPfFqcCYYBEbA4MlfkBE7WKQVyz1WmkQbbgs8gGpolwmhd0J7Tkoy62A9xAzIe6EKWJOZgwNobqTPjn80sc64Sfpl0qHjSSKzHKl1vx6ALDIppdJ2LFKHyBYyWresRyOtL8U3DS0nx3jIjlX5kr9o2l5wI3dhhemg8MpFWDLilNkcaVN9NmjRHAZITal9dnhDuJ4kifNZK5kRAe7tC+awqYs92Jzx922Kdpk2veTHzAgRoIvd4832d9InK52zrx/rjrrqE1pqduk4SmmeGvbB1vi69bRiHKsvd1RhelwarzIF6lcleHAMFSy/EDEDnA90InDC0XTJRFd2mSY3umJkUjSJK6vJsypNWltuRcmtTJsNck2Sgn2/FClez6THF50JQuV2ei9rlJjVDRUnZyGjfnZ45TUdkYp9wUp6cZtk9Ck6CQU/OKUvEz35CqAbgrqIChQD5eIvJMM8wxTUWTJeWcbkQDUlTcnX610K7Sy98t6jFuCV4VfTk9j+b1zXv7rl5OMAKRW5d4oOMSD3SklqNcwZs0HkBSK9BY6r7HUtvk6BA6XkXzztTxQYqofkH8KZIZtZgGA/f7vRm9CcHbrHSDZCIkNE8u1smrECjS45lrdZzOgqnuk8DbN+Fyc3/gOHYmRybK5RtaW58Bq0U6vWo7jCauSRO1WydXUre1ZdrRdDwJBP0/01lP+bJXCWHMLqefX7466OcV73HoF4FWOtFFv67r3FEULJiIfc19H4yZZU5P2WHs867BvsFu9AySPGK+npoefeqE7MRDwTT0cNWh9Sr0CH8VcYp8naPBZdrk/xraZP4R4g+0LY5alGHUf4vy/yWfusifgHyiWP/5rXJG/Q9DcP8f</diagram></mxfile>

misc/security.xml

@@ -1 +0,0 @@
-<mxfile userAgent="Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0" version="6.5.8" editor="www.draw.io" type="device"><diagram name="Page-1">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</diagram></mxfile>

setup.py

@@ -46,8 +46,6 @@ setup(
         'colorlog',
         'voluptuous',
         'gitpython',
-        'pyotp',
-        'pyqrcode',
         'pytz',
         'pyudev'
     ]

version.json

@@ -1,6 +1,6 @@
 {
-    "hassio": "0.80",
-    "homeassistant": "0.60.1",
+    "hassio": "0.86",
+    "homeassistant": "0.62.1",
     "resinos": "1.1",
     "resinhup": "0.3",
     "generic": "0.3",