Fix version merge conflict

* Allow serving two types of panels

* Remove old panel

* Make backwards compatible

* Add comment

.dockerignore

@@ -0,0 +1,9 @@
+# General files
+.git
+.github
+
+# Test related files
+.tox
+
+# Temporary files
+**/__pycache__

API.md

@@ -243,6 +243,7 @@ Optional:
     "serial": ["/dev/xy"],
     "input": ["Input device name"],
     "disk": ["/dev/sdax"],
+    "gpio": ["gpiochip0", "gpiochip100"],
     "audio": {
         "CARD_ID": {
             "name": "xy",
@@ -283,7 +284,11 @@ Optional:
     "last_version": "LAST_VERSION",
     "devices": [""],
     "image": "str",
-    "custom": "bool -> if custom image"
+    "custom": "bool -> if custom image",
+    "boot": "bool",
+    "port": 8123,
+    "ssl": "bool",
+    "watchdog": "bool"
 }
 ```
 
@@ -302,19 +307,30 @@ Optional:
 Output is the raw Docker log.
 
 - POST `/homeassistant/restart`
-- POST `/homeassistant/options`
 - POST `/homeassistant/check`
+- POST `/homeassistant/start`
+- POST `/homeassistant/stop`
+
+- POST `/homeassistant/options`
 
 ```json
 {
     "devices": [],
     "image": "Optional|null",
-    "last_version": "Optional for custom image|null"
+    "last_version": "Optional for custom image|null",
+    "port": "port for access hass",
+    "ssl": "bool",
+    "password": "",
+    "watchdog": "bool"
 }
 ```
 
 Image with `null` and last_version with `null` reset this options.
 
+- POST/GET `/homeassistant/api`
+
+Proxy to real home-assistant instance.
+
 ### RESTful for API addons
 
 - GET `/addons`
@@ -339,7 +355,10 @@ Get all available addons.
             "url": "null|url",
             "logo": "bool",
             "audio": "bool",
-            "hassio_api": "bool"
+            "gpio": "bool",
+            "stdin": "bool",
+            "hassio_api": "bool",
+            "homeassistant_api": "bool"
         }
     ],
     "repositories": [
@@ -377,7 +396,10 @@ Get all available addons.
     "devices": ["/dev/xy"],
     "logo": "bool",
     "hassio_api": "bool",
+    "homeassistant_api": "bool",
+    "stdin": "bool",
     "webui": "null|http(s)://[HOST]:port/xy/zx",
+    "gpio": "bool",
     "audio": "bool",
     "audio_input": "null|0,0",
     "audio_output": "null|0,0"
@@ -409,26 +431,10 @@ For reset custom network/audio settings, set it `null`.
 
 - POST `/addons/{addon}/install`
 
-Optional:
-
-```json
-{
-    "version": "VERSION"
-}
-```
-
 - POST `/addons/{addon}/uninstall`
 
 - POST `/addons/{addon}/update`
 
-Optional:
-
-```json
-{
-    "version": "VERSION"
-}
-```
-
 - GET `/addons/{addon}/logs`
 
 Output is the raw Docker log.
@@ -439,6 +445,10 @@ Output is the raw Docker log.
 
 Only supported for local build addons
 
+- POST `/addons/{addon}/stdin`
+
+Write data to add-on stdin
+
 ## Host Control
 
 Communicate over UNIX socket with a host daemon.

Dockerfile

@@ -0,0 +1,23 @@
+ARG BUILD_FROM
+FROM $BUILD_FROM
+
+# add env
+ENV LANG C.UTF-8
+
+# setup base
+RUN apk add --no-cache python3 python3-dev \
+        libressl libressl-dev \
+        libffi libffi-dev \
+        musl musl-dev \
+        gcc libstdc++ \
+        git socat \
+    && pip3 install --no-cache-dir --upgrade pip \
+    && pip3 install --no-cache-dir --upgrade cryptography jwcrypto \
+    && apk del python3-dev libressl-dev libffi-dev musl-dev gcc
+
+# install HassIO
+COPY . /usr/src/hassio
+RUN pip3 install --no-cache-dir /usr/src/hassio \
+    && rm -rf /usr/src/hassio
+
+CMD [ "python3", "-m", "hassio" ]

hassio/__main__.py

@@ -13,11 +13,12 @@ _LOGGER = logging.getLogger(__name__)
 # pylint: disable=invalid-name
 if __name__ == "__main__":
     bootstrap.initialize_logging()
+    loop = asyncio.get_event_loop()
 
     if not bootstrap.check_environment():
-        exit(1)
+        sys.exit(1)
 
-    loop = asyncio.get_event_loop()
+    # init executor pool
     executor = ThreadPoolExecutor(thread_name_prefix="SyncWorker")
     loop.set_default_executor(executor)
 
@@ -27,19 +28,20 @@ if __name__ == "__main__":
 
     bootstrap.migrate_system_env(config)
 
-    _LOGGER.info("Run Hassio setup")
+    _LOGGER.info("Setup HassIO")
     loop.run_until_complete(hassio.setup())
 
-    _LOGGER.info("Start Hassio")
     loop.call_soon_threadsafe(loop.create_task, hassio.start())
-    loop.call_soon_threadsafe(bootstrap.reg_signal, loop, hassio)
+    loop.call_soon_threadsafe(bootstrap.reg_signal, loop)
 
-    _LOGGER.info("Run Hassio loop")
-    loop.run_forever()
-
-    _LOGGER.info("Cleanup system")
-    executor.shutdown(wait=False)
-    loop.close()
+    try:
+        _LOGGER.info("Run HassIO")
+        loop.run_forever()
+    finally:
+        _LOGGER.info("Stopping HassIO")
+        loop.run_until_complete(hassio.stop())
+        executor.shutdown(wait=False)
+        loop.close()
 
     _LOGGER.info("Close Hassio")
-    sys.exit(hassio.exit_code)
+    sys.exit(0)

hassio/addons/addon.py

@@ -8,30 +8,29 @@ import shutil
 import tarfile
 from tempfile import TemporaryDirectory
 
-from deepmerge import Merger
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
 from .validate import (
-    validate_options, SCHEMA_ADDON_SNAPSHOT, MAP_VOLUME)
+    validate_options, SCHEMA_ADDON_SNAPSHOT, RE_VOLUME)
 from ..const import (
     ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON, ATTR_BOOT, ATTR_MAP,
     ATTR_OPTIONS, ATTR_PORTS, ATTR_SCHEMA, ATTR_IMAGE, ATTR_REPOSITORY,
     ATTR_URL, ATTR_ARCH, ATTR_LOCATON, ATTR_DEVICES, ATTR_ENVIRONMENT,
-    ATTR_HOST_NETWORK, ATTR_TMPFS, ATTR_PRIVILEGED, ATTR_STARTUP,
+    ATTR_HOST_NETWORK, ATTR_TMPFS, ATTR_PRIVILEGED, ATTR_STARTUP, ATTR_UUID,
     STATE_STARTED, STATE_STOPPED, STATE_NONE, ATTR_USER, ATTR_SYSTEM,
     ATTR_STATE, ATTR_TIMEOUT, ATTR_AUTO_UPDATE, ATTR_NETWORK, ATTR_WEBUI,
-    ATTR_HASSIO_API, ATTR_AUDIO, ATTR_AUDIO_OUTPUT, ATTR_AUDIO_INPUT)
+    ATTR_HASSIO_API, ATTR_AUDIO, ATTR_AUDIO_OUTPUT, ATTR_AUDIO_INPUT,
+    ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY)
 from .util import check_installed
 from ..dock.addon import DockerAddon
 from ..tools import write_json_file, read_json_file
 
 _LOGGER = logging.getLogger(__name__)
 
-RE_VOLUME = re.compile(MAP_VOLUME)
-RE_WEBUI = re.compile(r"^(.*\[HOST\]:)\[PORT:(\d+)\](.*)$")
-
-MERGE_OPT = Merger([(dict, ['merge'])], ['override'], ['override'])
+RE_WEBUI = re.compile(
+    r"^(?:(?P<s_prefix>https?)|\[PROTO:(?P<t_proto>\w+)\])"
+    r":\/\/\[HOST\]:\[PORT:(?P<t_port>\d+)\](?P<s_suffix>.*)$")
 
 
 class Addon(object):
@@ -107,10 +106,10 @@ class Addon(object):
     def options(self):
         """Return options with local changes."""
         if self.is_installed:
-            return MERGE_OPT.merge(
-                self.data.system[self._id][ATTR_OPTIONS],
-                self.data.user[self._id][ATTR_OPTIONS],
-            )
+            return {
+                **self.data.system[self._id][ATTR_OPTIONS],
+                **self.data.user[self._id][ATTR_OPTIONS]
+            }
         return self.data.cache[self._id][ATTR_OPTIONS]
 
     @options.setter
@@ -154,6 +153,12 @@ class Addon(object):
         """Return timeout of addon for docker stop."""
         return self._mesh[ATTR_TIMEOUT]
 
+    @property
+    def api_token(self):
+        """Return a API token for this add-on."""
+        if self.is_installed:
+            return self.data.user[self._id][ATTR_UUID]
+
     @property
     def description(self):
         """Return description of addon."""
@@ -207,19 +212,31 @@ class Addon(object):
         """Return URL to webui or None."""
         if ATTR_WEBUI not in self._mesh:
             return None
+        webui = RE_WEBUI.match(self._mesh[ATTR_WEBUI])
 
-        webui = self._mesh[ATTR_WEBUI]
-        dock_port = RE_WEBUI.sub(r"\2", webui)
+        # extract arguments
+        t_port = webui.group('t_port')
+        t_proto = webui.group('t_proto')
+        s_prefix = webui.group('s_prefix') or ""
+        s_suffix = webui.group('s_suffix') or ""
+
+        # search host port for this docker port
         if self.ports is None:
-            real_port = dock_port
+            port = t_port
         else:
-            real_port = self.ports.get("{}/tcp".format(dock_port), dock_port)
+            port = self.ports.get("{}/tcp".format(t_port), t_port)
 
         # for interface config or port lists
-        if isinstance(real_port, (tuple, list)):
-            real_port = real_port[-1]
+        if isinstance(port, (tuple, list)):
+            port = port[-1]
 
-        return RE_WEBUI.sub(r"\g<1>{}\g<3>".format(real_port), webui)
+        # lookup the correct protocol from config
+        if t_proto:
+            proto = 'https' if self.options[t_proto] else 'http'
+        else:
+            proto = s_prefix
+
+        return "{}://[HOST]:{}{}".format(proto, port, s_suffix)
 
     @property
     def host_network(self):
@@ -247,10 +264,30 @@ class Addon(object):
         return self._mesh.get(ATTR_PRIVILEGED)
 
     @property
-    def use_hassio_api(self):
+    def legacy(self):
+        """Return if the add-on don't support hass labels."""
+        return self._mesh.get(ATTR_LEGACY)
+
+    @property
+    def access_hassio_api(self):
         """Return True if the add-on access to hassio api."""
         return self._mesh[ATTR_HASSIO_API]
 
+    @property
+    def access_homeassistant_api(self):
+        """Return True if the add-on access to Home-Assistant api proxy."""
+        return self._mesh[ATTR_HOMEASSISTANT_API]
+
+    @property
+    def with_stdin(self):
+        """Return True if the add-on access use stdin input."""
+        return self._mesh[ATTR_STDIN]
+
+    @property
+    def with_gpio(self):
+        """Return True if the add-on access to gpio interface."""
+        return self._mesh[ATTR_GPIO]
+
     @property
     def with_audio(self):
         """Return True if the add-on access to audio."""
@@ -418,7 +455,7 @@ class Addon(object):
             return False
         return True
 
-    async def install(self, version=None):
+    async def install(self):
         """Install a addon."""
         if self.config.arch not in self.supported_arch:
             _LOGGER.error(
@@ -434,11 +471,10 @@ class Addon(object):
                 "Create Home-Assistant addon data folder %s", self.path_data)
             self.path_data.mkdir()
 
-        version = version or self.last_version
-        if not await self.docker.install(version):
+        if not await self.docker.install(self.last_version):
             return False
 
-        self._set_install(version)
+        self._set_install(self.last_version)
         return True
 
     @check_installed
@@ -481,19 +517,18 @@ class Addon(object):
         return self.docker.stop()
 
     @check_installed
-    async def update(self, version=None):
+    async def update(self):
         """Update addon."""
-        version = version or self.last_version
         last_state = await self.state()
 
-        if version == self.version_installed:
+        if self.last_version == self.version_installed:
             _LOGGER.warning(
-                "Addon %s is already installed in %s", self._id, version)
+                "No update available for Addon %s", self._id)
             return False
 
-        if not await self.docker.update(version):
+        if not await self.docker.update(self.last_version):
             return False
-        self._set_update(version)
+        self._set_update(self.last_version)
 
         # restore state
         if last_state == STATE_STARTED:
@@ -537,6 +572,18 @@ class Addon(object):
             await self.docker.run()
         return True
 
+    @check_installed
+    async def write_stdin(self, data):
+        """Write data to add-on stdin.
+
+        Return a coroutine.
+        """
+        if not self.with_stdin:
+            _LOGGER.error("Add-on don't support write to stdin!")
+            return False
+
+        return await self.docker.write_stdin(data)
+
     @check_installed
     async def snapshot(self, tar_file):
         """Snapshot a state of a addon."""
@@ -567,11 +614,13 @@ class Addon(object):
                     snapshot.add(self.path_data, arcname="data")
 
             try:
+                _LOGGER.info("Build snapshot for addon %s", self._id)
                 await self.loop.run_in_executor(None, _create_tar)
             except tarfile.TarError as err:
                 _LOGGER.error("Can't write tarfile %s -> %s", tar_file, err)
                 return False
 
+        _LOGGER.info("Finish snapshot for addon %s", self._id)
         return True
 
     async def restore(self, tar_file):
@@ -626,6 +675,7 @@ class Addon(object):
                 shutil.copytree(str(Path(temp, "data")), str(self.path_data))
 
             try:
+                _LOGGER.info("Restore data for addon %s", self._id)
                 await self.loop.run_in_executor(None, _restore_data)
             except shutil.Error as err:
                 _LOGGER.error("Can't restore origin data -> %s", err)
@@ -635,4 +685,5 @@ class Addon(object):
             if data[ATTR_STATE] == STATE_STARTED:
                 return await self.start()
 
+        _LOGGER.info("Finish restore for addon %s", self._id)
         return True

hassio/addons/build.py

@@ -0,0 +1,65 @@
+"""HassIO addons build environment."""
+from pathlib import Path
+
+from .validate import SCHEMA_BUILD_CONFIG
+from ..const import ATTR_SQUASH, ATTR_BUILD_FROM, ATTR_ARGS, META_ADDON
+from ..tools import JsonConfig
+
+
+class AddonBuild(JsonConfig):
+    """Handle build options for addons."""
+
+    def __init__(self, config, addon):
+        """Initialize addon builder."""
+        self.config = config
+        self.addon = addon
+
+        super().__init__(
+            Path(addon.path_location, 'build.json'), SCHEMA_BUILD_CONFIG)
+
+    def save(self):
+        """Ignore save function."""
+        pass
+
+    @property
+    def base_image(self):
+        """Base images for this addon."""
+        return self._data[ATTR_BUILD_FROM][self.config.arch]
+
+    @property
+    def squash(self):
+        """Return True or False if squash is active."""
+        return self._data[ATTR_SQUASH]
+
+    @property
+    def additional_args(self):
+        """Return additional docker build arguments."""
+        return self._data[ATTR_ARGS]
+
+    def get_docker_args(self, version):
+        """Create a dict with docker build arguments."""
+        args = {
+            'path': str(self.addon.path_location),
+            'tag': "{}:{}".format(self.addon.image, version),
+            'pull': True,
+            'forcerm': True,
+            'squash': self.squash,
+            'labels': {
+                'io.hass.version': version,
+                'io.hass.arch': self.config.arch,
+                'io.hass.type': META_ADDON,
+                'io.hass.name': self.addon.name,
+                'io.hass.description': self.addon.description,
+            },
+            'buildargs': {
+                'BUILD_FROM': self.base_image,
+                'BUILD_VERSION': version,
+                'BUILD_ARCH': self.config.arch,
+                **self.additional_args,
+            }
+        }
+
+        if self.addon.url:
+            args['labels']['io.hass.url'] = self.addon.url
+
+        return args

hassio/addons/data.py

@@ -3,15 +3,13 @@ import copy
 import logging
 import json
 from pathlib import Path
-import re
 
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
 from .util import extract_hash_from_path
 from .validate import (
-    SCHEMA_ADDON_CONFIG, SCHEMA_ADDON_FILE, SCHEMA_REPOSITORY_CONFIG,
-    MAP_VOLUME)
+    SCHEMA_ADDON_CONFIG, SCHEMA_ADDON_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,8 +17,6 @@ from ..tools import JsonConfig, read_json_file
 
 _LOGGER = logging.getLogger(__name__)
 
-RE_VOLUME = re.compile(MAP_VOLUME)
-
 
 class Data(JsonConfig):
     """Hold data for addons inside HassIO."""

hassio/addons/git.py

@@ -73,7 +73,7 @@ class GitRepo(object):
                     None, self.repo.remotes.origin.pull)
 
             except (git.InvalidGitRepositoryError, git.NoSuchPathError,
-                    git.exc.GitCommandError) as err:
+                    git.GitCommandError) as err:
                 _LOGGER.error("Can't pull %s repo: %s.", self.url, err)
                 return False
 

hassio/addons/validate.py

@@ -1,4 +1,8 @@
 """Validate addons options schema."""
+import logging
+import re
+import uuid
+
 import voluptuous as vol
 
 from ..const import (
@@ -9,13 +13,16 @@ from ..const import (
     ATTR_ARCH, ATTR_DEVICES, ATTR_ENVIRONMENT, ATTR_HOST_NETWORK, ARCH_ARMHF,
     ARCH_AARCH64, ARCH_AMD64, ARCH_I386, ATTR_TMPFS, ATTR_PRIVILEGED,
     ATTR_USER, ATTR_STATE, ATTR_SYSTEM, STATE_STARTED, STATE_STOPPED,
-    ATTR_LOCATON, ATTR_REPOSITORY, ATTR_TIMEOUT, ATTR_NETWORK,
+    ATTR_LOCATON, ATTR_REPOSITORY, ATTR_TIMEOUT, ATTR_NETWORK, ATTR_UUID,
     ATTR_AUTO_UPDATE, ATTR_WEBUI, ATTR_AUDIO, ATTR_AUDIO_INPUT,
-    ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API)
+    ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API, ATTR_BUILD_FROM, ATTR_SQUASH,
+    ATTR_ARGS, ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY)
 from ..validate import NETWORK_PORT, DOCKER_PORTS, ALSA_CHANNEL
 
+_LOGGER = logging.getLogger(__name__)
 
-MAP_VOLUME = r"^(config|ssl|addons|backup|share)(?::(rw|:ro))?$"
+
+RE_VOLUME = re.compile(r"^(config|ssl|addons|backup|share)(?::(rw|:ro))?$")
 
 V_STR = 'str'
 V_INT = 'int'
@@ -24,8 +31,18 @@ V_BOOL = 'bool'
 V_EMAIL = 'email'
 V_URL = 'url'
 V_PORT = 'port'
+V_MATCH = 'match'
 
-ADDON_ELEMENT = vol.In([V_STR, V_INT, V_FLOAT, V_BOOL, V_EMAIL, V_URL, V_PORT])
+RE_SCHEMA_ELEMENT = re.compile(
+    r"^(?:"
+    r"|str|bool|email|url|port"
+    r"|int(?:\((?P<i_min>\d+)?,(?P<i_max>\d+)?\))?"
+    r"|float(?:\((?P<f_min>[\d\.]+)?,(?P<f_max>[\d\.]+)?\))?"
+    r"|match\((?P<match>.*)\)"
+    r")\??$"
+)
+
+SCHEMA_ELEMENT = vol.Match(RE_SCHEMA_ELEMENT)
 
 ARCH_ALL = [
     ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386
@@ -42,6 +59,13 @@ PRIVILEGED_ALL = [
     "SYS_RAWIO"
 ]
 
+BASE_IMAGE = {
+    ARCH_ARMHF: "homeassistant/armhf-base:latest",
+    ARCH_AARCH64: "homeassistant/aarch64-base:latest",
+    ARCH_I386: "homeassistant/i386-base:latest",
+    ARCH_AMD64: "homeassistant/amd64-base:latest",
+}
+
 
 def _simple_startup(value):
     """Simple startup schema."""
@@ -66,26 +90,35 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
         vol.In([BOOT_AUTO, BOOT_MANUAL]),
     vol.Optional(ATTR_PORTS): DOCKER_PORTS,
     vol.Optional(ATTR_WEBUI):
-        vol.Match(r"^(?:https?):\/\/\[HOST\]:\[PORT:\d+\].*$"),
+        vol.Match(r"^(?:https?|\[PROTO:\w+\]):\/\/\[HOST\]:\[PORT:\d+\].*$"),
     vol.Optional(ATTR_HOST_NETWORK, default=False): vol.Boolean(),
     vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
     vol.Optional(ATTR_TMPFS):
         vol.Match(r"^size=(\d)*[kmg](,uid=\d{1,4})?(,rw)?$"),
-    vol.Optional(ATTR_MAP, default=[]): [vol.Match(MAP_VOLUME)],
+    vol.Optional(ATTR_MAP, default=[]): [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(),
+    vol.Optional(ATTR_GPIO, default=False): vol.Boolean(),
     vol.Optional(ATTR_HASSIO_API, default=False): vol.Boolean(),
+    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.Required(ATTR_OPTIONS): dict,
     vol.Required(ATTR_SCHEMA): vol.Any(vol.Schema({
-        vol.Coerce(str): vol.Any(ADDON_ELEMENT, [
-            vol.Any(ADDON_ELEMENT, {vol.Coerce(str): ADDON_ELEMENT})
-        ], vol.Schema({vol.Coerce(str): ADDON_ELEMENT}))
+        vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [
+            vol.Any(
+                SCHEMA_ELEMENT,
+                {vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [SCHEMA_ELEMENT])}
+            ),
+        ], vol.Schema({
+            vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [SCHEMA_ELEMENT])
+        }))
     }), False),
-    vol.Optional(ATTR_IMAGE): vol.Match(r"\w*/\w*"),
+    vol.Optional(ATTR_IMAGE): vol.Match(r"^[\w{}]+/[\-\w{}]+$"),
     vol.Optional(ATTR_TIMEOUT, default=10):
-        vol.All(vol.Coerce(int), vol.Range(min=10, max=120))
-}, extra=vol.ALLOW_EXTRA)
+        vol.All(vol.Coerce(int), vol.Range(min=10, max=120)),
+}, extra=vol.REMOVE_EXTRA)
 
 
 # pylint: disable=no-value-for-parameter
@@ -93,12 +126,26 @@ SCHEMA_REPOSITORY_CONFIG = vol.Schema({
     vol.Required(ATTR_NAME): vol.Coerce(str),
     vol.Optional(ATTR_URL): vol.Url(),
     vol.Optional(ATTR_MAINTAINER): vol.Coerce(str),
-}, extra=vol.ALLOW_EXTRA)
+}, extra=vol.REMOVE_EXTRA)
+
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_BUILD_CONFIG = vol.Schema({
+    vol.Optional(ATTR_BUILD_FROM, default=BASE_IMAGE): 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.Coerce(str): vol.Coerce(str)
+    }),
+}, extra=vol.REMOVE_EXTRA)
 
 
 # pylint: disable=no-value-for-parameter
 SCHEMA_ADDON_USER = vol.Schema({
     vol.Required(ATTR_VERSION): vol.Coerce(str),
+    vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex):
+        vol.Match(r"^[0-9a-f]{32}$"),
     vol.Optional(ATTR_OPTIONS, default={}): dict,
     vol.Optional(ATTR_AUTO_UPDATE, default=False): vol.Boolean(),
     vol.Optional(ATTR_BOOT):
@@ -106,7 +153,7 @@ SCHEMA_ADDON_USER = vol.Schema({
     vol.Optional(ATTR_NETWORK): DOCKER_PORTS,
     vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_CHANNEL,
     vol.Optional(ATTR_AUDIO_INPUT): ALSA_CHANNEL,
-})
+}, extra=vol.REMOVE_EXTRA)
 
 
 SCHEMA_ADDON_SYSTEM = SCHEMA_ADDON_CONFIG.extend({
@@ -141,8 +188,10 @@ def validate_options(raw_schema):
 
         # read options
         for key, value in struct.items():
+            # Ignore unknown options / remove from list
             if key not in raw_schema:
-                raise vol.Invalid("Unknown options {}.".format(key))
+                _LOGGER.warning("Unknown options %s", key)
+                continue
 
             typ = raw_schema[key]
             try:
@@ -159,6 +208,7 @@ def validate_options(raw_schema):
                 raise vol.Invalid(
                     "Type error for {}.".format(key)) from None
 
+        _check_missing_options(raw_schema, options, 'root')
         return options
 
     return validate
@@ -167,30 +217,38 @@ def validate_options(raw_schema):
 # pylint: disable=no-value-for-parameter
 def _single_validate(typ, value, key):
     """Validate a single element."""
-    try:
-        # if required argument
-        if value is None:
-            raise vol.Invalid("Missing required option '{}'.".format(key))
+    # if required argument
+    if value is None:
+        raise vol.Invalid("Missing required option '{}'.".format(key))
 
-        if typ == V_STR:
-            return str(value)
-        elif typ == V_INT:
-            return int(value)
-        elif typ == V_FLOAT:
-            return float(value)
-        elif typ == V_BOOL:
-            return vol.Boolean()(value)
-        elif typ == V_EMAIL:
-            return vol.Email()(value)
-        elif typ == V_URL:
-            return vol.Url()(value)
-        elif typ == V_PORT:
-            return NETWORK_PORT(value)
+    # parse extend data from type
+    match = RE_SCHEMA_ELEMENT.match(typ)
 
-        raise vol.Invalid("Fatal error for {} type {}".format(key, typ))
-    except ValueError:
-        raise vol.Invalid(
-            "Type {} error for '{}' on {}.".format(typ, value, key)) from None
+    # prepare range
+    range_args = {}
+    for group_name in ('i_min', 'i_max', 'f_min', 'f_max'):
+        group_value = match.group(group_name)
+        if group_value:
+            range_args[group_name[2:]] = float(group_value)
+
+    if typ.startswith(V_STR):
+        return str(value)
+    elif typ.startswith(V_INT):
+        return vol.All(vol.Coerce(int), vol.Range(**range_args))(value)
+    elif typ.startswith(V_FLOAT):
+        return vol.All(vol.Coerce(float), vol.Range(**range_args))(value)
+    elif typ.startswith(V_BOOL):
+        return vol.Boolean()(value)
+    elif typ.startswith(V_EMAIL):
+        return vol.Email()(value)
+    elif typ.startswith(V_URL):
+        return vol.Url()(value)
+    elif typ.startswith(V_PORT):
+        return NETWORK_PORT(value)
+    elif typ.startswith(V_MATCH):
+        return vol.Match(match.group('match'))(str(value))
+
+    raise vol.Invalid("Fatal error for {} type {}".format(key, typ))
 
 
 def _nested_validate_list(typ, data_list, key):
@@ -198,17 +256,10 @@ def _nested_validate_list(typ, data_list, key):
     options = []
 
     for element in data_list:
-        # dict list
+        # Nested?
         if isinstance(typ, dict):
-            c_options = {}
-            for c_key, c_value in element.items():
-                if c_key not in typ:
-                    raise vol.Invalid(
-                        "Unknown nested options {}".format(c_key))
-
-                c_options[c_key] = _single_validate(typ[c_key], c_value, c_key)
+            c_options = _nested_validate_dict(typ, element, key)
             options.append(c_options)
-        # normal list
         else:
             options.append(_single_validate(typ, element, key))
 
@@ -220,9 +271,28 @@ def _nested_validate_dict(typ, data_dict, key):
     options = {}
 
     for c_key, c_value in data_dict.items():
+        # Ignore unknown options / remove from list
         if c_key not in typ:
-            raise vol.Invalid("Unknow nested dict options {}".format(c_key))
+            _LOGGER.warning("Unknown options %s", c_key)
+            continue
 
-        options[c_key] = _single_validate(typ[c_key], c_value, c_key)
+        # Nested?
+        if isinstance(typ[c_key], list):
+            options[c_key] = _nested_validate_list(typ[c_key][0],
+                                                   c_value, c_key)
+        else:
+            options[c_key] = _single_validate(typ[c_key], c_value, c_key)
 
+    _check_missing_options(typ, options, key)
     return options
+
+
+def _check_missing_options(origin, exists, root):
+    """Check if all options are exists."""
+    missing = set(origin) - set(exists)
+    for miss_opt in missing:
+        if isinstance(origin[miss_opt], str) and \
+                origin[miss_opt].endswith("?"):
+            continue
+        raise vol.Invalid(
+            "Missing option {} in {}".format(miss_opt, root))

hassio/api/__init__.py

@@ -72,7 +72,13 @@ class RestAPI(object):
         self.webapp.router.add_post('/homeassistant/options', api_hass.options)
         self.webapp.router.add_post('/homeassistant/update', api_hass.update)
         self.webapp.router.add_post('/homeassistant/restart', api_hass.restart)
+        self.webapp.router.add_post('/homeassistant/stop', api_hass.stop)
+        self.webapp.router.add_post('/homeassistant/start', api_hass.start)
         self.webapp.router.add_post('/homeassistant/check', api_hass.check)
+        self.webapp.router.add_post(
+            '/homeassistant/api/{path:.+}', api_hass.api)
+        self.webapp.router.add_get(
+            '/homeassistant/api/{path:.+}', api_hass.api)
 
     def register_addons(self, addons):
         """Register homeassistant function."""
@@ -98,6 +104,7 @@ class RestAPI(object):
             '/addons/{addon}/rebuild', api_addons.rebuild)
         self.webapp.router.add_get('/addons/{addon}/logs', api_addons.logs)
         self.webapp.router.add_get('/addons/{addon}/logo', api_addons.logo)
+        self.webapp.router.add_post('/addons/{addon}/stdin', api_addons.stdin)
 
     def register_security(self):
         """Register security function."""
@@ -132,13 +139,18 @@ class RestAPI(object):
 
     def register_panel(self):
         """Register panel for homeassistant."""
-        panel = Path(__file__).parents[1].joinpath('panel/hassio-main.html')
+        def create_panel_response(build_type):
+            """Create a function to generate a response."""
+            path = Path(__file__).parents[1].joinpath(
+                'panel/hassio-main-{}.html'.format(build_type))
 
-        def get_panel(request):
-            """Return file response with panel."""
-            return web.FileResponse(panel)
+            return lambda request: web.FileResponse(path)
 
-        self.webapp.router.add_get('/panel', get_panel)
+        # 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'))
 
     async def start(self):
         """Run rest api webserver."""
@@ -159,5 +171,5 @@ class RestAPI(object):
         await self.webapp.shutdown()
 
         if self._handler:
-            await self._handler.finish_connections(60)
+            await self._handler.shutdown(60)
         await self.webapp.cleanup()

hassio/api/addons.py

@@ -13,7 +13,8 @@ from ..const import (
     ATTR_SOURCE, ATTR_REPOSITORIES, ATTR_ADDONS, ATTR_ARCH, ATTR_MAINTAINER,
     ATTR_INSTALLED, ATTR_LOGO, ATTR_WEBUI, ATTR_DEVICES, ATTR_PRIVILEGED,
     ATTR_AUDIO, ATTR_AUDIO_INPUT, ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API,
-    BOOT_AUTO, BOOT_MANUAL, CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY)
+    ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, BOOT_AUTO, BOOT_MANUAL,
+    CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY)
 from ..validate import DOCKER_PORTS
 
 _LOGGER = logging.getLogger(__name__)
@@ -77,8 +78,11 @@ class APIAddons(object):
                 ATTR_DEVICES: self._pretty_devices(addon),
                 ATTR_URL: addon.url,
                 ATTR_LOGO: addon.with_logo,
-                ATTR_HASSIO_API: addon.use_hassio_api,
+                ATTR_STDIN: addon.with_stdin,
+                ATTR_HASSIO_API: addon.access_hassio_api,
+                ATTR_HOMEASSISTANT_API: addon.access_homeassistant_api,
                 ATTR_AUDIO: addon.with_audio,
+                ATTR_GPIO: addon.with_gpio,
             })
 
         data_repositories = []
@@ -126,7 +130,10 @@ class APIAddons(object):
             ATTR_DEVICES: self._pretty_devices(addon),
             ATTR_LOGO: addon.with_logo,
             ATTR_WEBUI: addon.webui,
-            ATTR_HASSIO_API: addon.use_hassio_api,
+            ATTR_STDIN: addon.with_stdin,
+            ATTR_HASSIO_API: addon.access_hassio_api,
+            ATTR_HOMEASSISTANT_API: addon.access_homeassistant_api,
+            ATTR_GPIO: addon.with_gpio,
             ATTR_AUDIO: addon.with_audio,
             ATTR_AUDIO_INPUT: addon.audio_input,
             ATTR_AUDIO_OUTPUT: addon.audio_output,
@@ -159,14 +166,10 @@ class APIAddons(object):
         return True
 
     @api_process
-    async def install(self, request):
+    def install(self, request):
         """Install addon."""
-        body = await api_validate(SCHEMA_VERSION, request)
         addon = self._extract_addon(request, check_installed=False)
-        version = body.get(ATTR_VERSION, addon.last_version)
-
-        return await asyncio.shield(
-            addon.install(version=version), loop=self.loop)
+        return asyncio.shield(addon.install(), loop=self.loop)
 
     @api_process
     def uninstall(self, request):
@@ -195,17 +198,14 @@ class APIAddons(object):
         return asyncio.shield(addon.stop(), loop=self.loop)
 
     @api_process
-    async def update(self, request):
+    def update(self, request):
         """Update addon."""
-        body = await api_validate(SCHEMA_VERSION, request)
         addon = self._extract_addon(request)
-        version = body.get(ATTR_VERSION, addon.last_version)
 
-        if version == addon.version_installed:
-            raise RuntimeError("Version %s is already in use", version)
+        if addon.last_version == addon.version_installed:
+            raise RuntimeError("No update available!")
 
-        return await asyncio.shield(
-            addon.update(version=version), loop=self.loop)
+        return asyncio.shield(addon.update(), loop=self.loop)
 
     @api_process
     def restart(self, request):
@@ -237,3 +237,13 @@ class APIAddons(object):
 
         with addon.path_logo.open('rb') as png:
             return png.read()
+
+    @api_process
+    async def stdin(self, request):
+        """Write to stdin of addon."""
+        addon = self._extract_addon(request)
+        if not addon.with_stdin:
+            raise RuntimeError("STDIN not supported by addons")
+
+        data = await request.read()
+        return await asyncio.shield(addon.write_stdin(data), loop=self.loop)

hassio/api/homeassistant.py

@@ -2,22 +2,34 @@
 import asyncio
 import logging
 
+import aiohttp
+from aiohttp import web
+from aiohttp.web_exceptions import HTTPBadGateway
+from aiohttp.hdrs import CONTENT_TYPE
+import async_timeout
 import voluptuous as vol
 
 from .util import api_process, api_process_raw, api_validate
 from ..const import (
     ATTR_VERSION, ATTR_LAST_VERSION, ATTR_DEVICES, ATTR_IMAGE, ATTR_CUSTOM,
-    CONTENT_TYPE_BINARY)
-from ..validate import HASS_DEVICES
+    ATTR_BOOT, ATTR_PORT, ATTR_PASSWORD, ATTR_SSL, ATTR_WATCHDOG,
+    CONTENT_TYPE_BINARY, HEADER_HA_ACCESS)
+from ..validate import HASS_DEVICES, NETWORK_PORT
 
 _LOGGER = logging.getLogger(__name__)
 
 
+# pylint: disable=no-value-for-parameter
 SCHEMA_OPTIONS = vol.Schema({
     vol.Optional(ATTR_DEVICES): HASS_DEVICES,
+    vol.Optional(ATTR_BOOT): vol.Boolean(),
     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.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(),
 })
 
 SCHEMA_VERSION = vol.Schema({
@@ -34,6 +46,45 @@ class APIHomeAssistant(object):
         self.loop = loop
         self.homeassistant = homeassistant
 
+    async def homeassistant_proxy(self, path, request):
+        """Return a client request with proxy origin for Home-Assistant."""
+        url = "{}/api/{}".format(self.homeassistant.api_url, path)
+
+        try:
+            data = None
+            headers = {}
+            method = getattr(
+                self.homeassistant.websession, request.method.lower())
+
+            # read data
+            with async_timeout.timeout(10, loop=self.loop):
+                data = await request.read()
+
+            if data:
+                headers.update({CONTENT_TYPE: request.content_type})
+
+            # need api password?
+            if self.homeassistant.api_password:
+                headers = {HEADER_HA_ACCESS: self.homeassistant.api_password}
+
+            # reset headers
+            if not headers:
+                headers = None
+
+            client = await method(
+                url, data=data, headers=headers, timeout=300
+            )
+
+            return client
+
+        except aiohttp.ClientError as err:
+            _LOGGER.error("Client error on api %s request %s.", path, err)
+
+        except asyncio.TimeoutError:
+            _LOGGER.error("Client timeout error on api request %s.", path)
+
+        raise HTTPBadGateway()
+
     @api_process
     async def info(self, request):
         """Return host information."""
@@ -43,6 +94,10 @@ class APIHomeAssistant(object):
             ATTR_IMAGE: self.homeassistant.image,
             ATTR_DEVICES: self.homeassistant.devices,
             ATTR_CUSTOM: self.homeassistant.is_custom_image,
+            ATTR_BOOT: self.homeassistant.boot,
+            ATTR_PORT: self.homeassistant.api_port,
+            ATTR_SSL: self.homeassistant.api_ssl,
+            ATTR_WATCHDOG: self.homeassistant.watchdog,
         }
 
     @api_process
@@ -57,6 +112,21 @@ class APIHomeAssistant(object):
             self.homeassistant.set_custom(
                 body[ATTR_IMAGE], body[ATTR_LAST_VERSION])
 
+        if ATTR_BOOT in body:
+            self.homeassistant.boot = body[ATTR_BOOT]
+
+        if ATTR_PORT in body:
+            self.homeassistant.api_port = body[ATTR_PORT]
+
+        if ATTR_PASSWORD in body:
+            self.homeassistant.api_password = body[ATTR_PASSWORD]
+
+        if ATTR_SSL in body:
+            self.homeassistant.api_ssl = body[ATTR_SSL]
+
+        if ATTR_WATCHDOG in body:
+            self.homeassistant.watchdog = body[ATTR_WATCHDOG]
+
         return True
 
     @api_process
@@ -71,6 +141,16 @@ class APIHomeAssistant(object):
         return await asyncio.shield(
             self.homeassistant.update(version), loop=self.loop)
 
+    @api_process
+    def stop(self, request):
+        """Stop homeassistant."""
+        return asyncio.shield(self.homeassistant.stop(), loop=self.loop)
+
+    @api_process
+    def start(self, request):
+        """Start homeassistant."""
+        return asyncio.shield(self.homeassistant.run(), loop=self.loop)
+
     @api_process
     def restart(self, request):
         """Restart homeassistant."""
@@ -89,3 +169,14 @@ class APIHomeAssistant(object):
             raise RuntimeError(message)
 
         return True
+
+    async def api(self, request):
+        """Proxy API request to Home-Assistant."""
+        path = request.match_info.get('path')
+
+        client = await self.homeassistant_proxy(path, request)
+        return web.Response(
+            body=await client.read(),
+            status=client.status,
+            content_type=client.content_type
+        )

hassio/api/host.py

@@ -8,7 +8,7 @@ from .util import api_process_hostcontrol, api_process, api_validate
 from ..const import (
     ATTR_VERSION, ATTR_LAST_VERSION, ATTR_TYPE, ATTR_HOSTNAME, ATTR_FEATURES,
     ATTR_OS, ATTR_SERIAL, ATTR_INPUT, ATTR_DISK, ATTR_AUDIO, ATTR_AUDIO_INPUT,
-    ATTR_AUDIO_OUTPUT)
+    ATTR_AUDIO_OUTPUT, ATTR_GPIO)
 from ..validate import ALSA_CHANNEL
 
 _LOGGER = logging.getLogger(__name__)
@@ -83,8 +83,9 @@ class APIHost(object):
     async def hardware(self, request):
         """Return local hardware infos."""
         return {
-            ATTR_SERIAL: self.local_hw.serial_devices,
-            ATTR_INPUT: self.local_hw.input_devices,
-            ATTR_DISK: self.local_hw.disk_devices,
+            ATTR_SERIAL: list(self.local_hw.serial_devices),
+            ATTR_INPUT: list(self.local_hw.input_devices),
+            ATTR_DISK: list(self.local_hw.disk_devices),
+            ATTR_GPIO: list(self.local_hw.gpio_devices),
             ATTR_AUDIO: self.local_hw.audio_devices,
         }

hassio/bootstrap.py

@@ -123,22 +123,22 @@ def check_environment():
     return True
 
 
-def reg_signal(loop, hassio):
+def reg_signal(loop):
     """Register SIGTERM, SIGKILL to stop system."""
     try:
         loop.add_signal_handler(
-            signal.SIGTERM, lambda: loop.create_task(hassio.stop()))
+            signal.SIGTERM, lambda: loop.call_soon(loop.stop))
     except (ValueError, RuntimeError):
         _LOGGER.warning("Could not bind to SIGTERM")
 
     try:
         loop.add_signal_handler(
-            signal.SIGHUP, lambda: loop.create_task(hassio.stop()))
+            signal.SIGHUP, lambda: loop.call_soon(loop.stop))
     except (ValueError, RuntimeError):
         _LOGGER.warning("Could not bind to SIGHUP")
 
     try:
         loop.add_signal_handler(
-            signal.SIGINT, lambda: loop.create_task(hassio.stop()))
+            signal.SIGINT, lambda: loop.call_soon(loop.stop))
     except (ValueError, RuntimeError):
         _LOGGER.warning("Could not bind to SIGINT")

hassio/config.py

@@ -7,14 +7,12 @@ 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,
-    ATTR_AUDIO_INPUT, ATTR_AUDIO_OUTPUT)
-from .tools import JsonConfig
+    ATTR_AUDIO_INPUT, ATTR_AUDIO_OUTPUT, ATTR_LAST_BOOT)
+from .tools import JsonConfig, parse_datetime
 from .validate import SCHEMA_HASSIO_CONFIG
 
 _LOGGER = logging.getLogger(__name__)
 
-DATETIME_FORMAT = "%Y%m%d %H:%M:%S"
-
 HOMEASSISTANT_CONFIG = PurePath("homeassistant")
 
 HASSIO_SSL = PurePath("ssl")
@@ -28,6 +26,8 @@ BACKUP_DATA = PurePath("backup")
 SHARE_DATA = PurePath("share")
 TMP_DATA = PurePath("tmp")
 
+DEFAULT_BOOT_TIME = datetime.utcfromtimestamp(0).isoformat()
+
 
 class CoreConfig(JsonConfig):
     """Hold all core config data."""
@@ -48,6 +48,22 @@ class CoreConfig(JsonConfig):
         self._data[ATTR_TIMEZONE] = value
         self.save()
 
+    @property
+    def last_boot(self):
+        """Return last boot datetime."""
+        boot_str = self._data.get(ATTR_LAST_BOOT, DEFAULT_BOOT_TIME)
+
+        boot_time = parse_datetime(boot_str)
+        if not boot_time:
+            return datetime.utcfromtimestamp(1)
+        return boot_time
+
+    @last_boot.setter
+    def last_boot(self, value):
+        """Set last boot datetime."""
+        self._data[ATTR_LAST_BOOT] = value.isoformat()
+        self.save()
+
     @property
     def path_hassio(self):
         """Return hassio data path."""
@@ -191,14 +207,14 @@ class CoreConfig(JsonConfig):
     def security_sessions(self):
         """Return api sessions."""
         return {
-            session: datetime.strptime(until, DATETIME_FORMAT) for
+            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.strftime(DATETIME_FORMAT)}
+            {session: valid.isoformat()}
         )
         self.save()
 

hassio/const.py

@@ -2,7 +2,7 @@
 from pathlib import Path
 from ipaddress import ip_network
 
-HASSIO_VERSION = '0.58'
+HASSIO_VERSION = '0.75'
 
 URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
                       'hassio/{}/version.json')
@@ -16,11 +16,10 @@ RUN_UPDATE_SUPERVISOR_TASKS = 29100
 RUN_UPDATE_ADDONS_TASKS = 57600
 RUN_RELOAD_ADDONS_TASKS = 28800
 RUN_RELOAD_SNAPSHOTS_TASKS = 72000
-RUN_WATCHDOG_HOMEASSISTANT = 15
+RUN_WATCHDOG_HOMEASSISTANT_DOCKER = 15
+RUN_WATCHDOG_HOMEASSISTANT_API = 300
 RUN_CLEANUP_API_SESSIONS = 900
 
-RESTART_EXIT_CODE = 100
-
 FILE_HASSIO_ADDONS = Path(HASSIO_DATA, "addons.json")
 FILE_HASSIO_CONFIG = Path(HASSIO_DATA, "config.json")
 FILE_HASSIO_HOMEASSISTANT = Path(HASSIO_DATA, "homeassistant.json")
@@ -50,17 +49,22 @@ RESULT_OK = 'ok'
 
 CONTENT_TYPE_BINARY = 'application/octet-stream'
 CONTENT_TYPE_PNG = 'image/png'
+CONTENT_TYPE_JSON = 'application/json'
+HEADER_HA_ACCESS = 'x-ha-access'
 
+ATTR_WATCHDOG = 'watchdog'
 ATTR_DATE = 'date'
 ATTR_ARCH = 'arch'
 ATTR_HOSTNAME = 'hostname'
 ATTR_TIMEZONE = 'timezone'
+ATTR_ARGS = 'args'
 ATTR_OS = 'os'
 ATTR_TYPE = 'type'
 ATTR_SOURCE = 'source'
 ATTR_FEATURES = 'features'
 ATTR_ADDONS = 'addons'
 ATTR_VERSION = 'version'
+ATTR_LAST_BOOT = 'last_boot'
 ATTR_LAST_VERSION = 'last_version'
 ATTR_BETA_CHANNEL = 'beta_channel'
 ATTR_NAME = 'name'
@@ -69,6 +73,8 @@ ATTR_DESCRIPTON = 'description'
 ATTR_STARTUP = 'startup'
 ATTR_BOOT = 'boot'
 ATTR_PORTS = 'ports'
+ATTR_PORT = 'port'
+ATTR_SSL = 'ssl'
 ATTR_MAP = 'map'
 ATTR_WEBUI = 'webui'
 ATTR_OPTIONS = 'options'
@@ -78,6 +84,7 @@ ATTR_STATE = 'state'
 ATTR_SCHEMA = 'schema'
 ATTR_IMAGE = 'image'
 ATTR_LOGO = 'logo'
+ATTR_STDIN = 'stdin'
 ATTR_ADDONS_REPOSITORIES = 'addons_repositories'
 ATTR_REPOSITORY = 'repository'
 ATTR_REPOSITORIES = 'repositories'
@@ -102,6 +109,8 @@ ATTR_SNAPSHOTS = 'snapshots'
 ATTR_HOMEASSISTANT = 'homeassistant'
 ATTR_HASSIO = 'hassio'
 ATTR_HASSIO_API = 'hassio_api'
+ATTR_HOMEASSISTANT_API = 'homeassistant_api'
+ATTR_UUID = 'uuid'
 ATTR_FOLDERS = 'folders'
 ATTR_SIZE = 'size'
 ATTR_TYPE = 'type'
@@ -116,6 +125,10 @@ ATTR_OUTPUT = 'output'
 ATTR_DISK = 'disk'
 ATTR_SERIAL = 'serial'
 ATTR_SECURITY = 'security'
+ATTR_BUILD_FROM = 'build_from'
+ATTR_SQUASH = 'squash'
+ATTR_GPIO = 'gpio'
+ATTR_LEGACY = 'legacy'
 ATTR_ADDONS_CUSTOM_LIST = 'addons_custom_list'
 
 STARTUP_INITIALIZE = 'initialize'

hassio/core.py

@@ -9,7 +9,7 @@ from .api import RestAPI
 from .host_control import HostControl
 from .const import (
     RUN_UPDATE_INFO_TASKS, RUN_RELOAD_ADDONS_TASKS,
-    RUN_UPDATE_SUPERVISOR_TASKS, RUN_WATCHDOG_HOMEASSISTANT,
+    RUN_UPDATE_SUPERVISOR_TASKS, RUN_WATCHDOG_HOMEASSISTANT_DOCKER,
     RUN_CLEANUP_API_SESSIONS, STARTUP_SYSTEM, STARTUP_SERVICES,
     STARTUP_APPLICATION, STARTUP_INITIALIZE, RUN_RELOAD_SNAPSHOTS_TASKS,
     RUN_UPDATE_ADDONS_TASKS)
@@ -22,7 +22,8 @@ from .dns import DNSForward
 from .snapshots import SnapshotsManager
 from .updater import Updater
 from .tasks import (
-    hassio_update, homeassistant_watchdog, api_sessions_cleanup, addons_update)
+    hassio_update, homeassistant_watchdog_docker, api_sessions_cleanup,
+    addons_update)
 from .tools import fetch_timezone
 
 _LOGGER = logging.getLogger(__name__)
@@ -142,7 +143,7 @@ class HassIO(object):
 
         try:
             # HomeAssistant is already running / supervisor have only reboot
-            if await self.homeassistant.is_running():
+            if self.hardware.last_boot == self.config.last_boot:
                 _LOGGER.info("HassIO reboot detected")
                 return
 
@@ -153,29 +154,37 @@ class HassIO(object):
             await self.addons.auto_boot(STARTUP_SERVICES)
 
             # run HomeAssistant
-            await self.homeassistant.run()
+            if self.homeassistant.boot:
+                await self.homeassistant.run()
 
             # start addon mark as application
             await self.addons.auto_boot(STARTUP_APPLICATION)
 
+            # store new last boot
+            self.config.last_boot = self.hardware.last_boot
+
         finally:
             # schedule homeassistant watchdog
             self.scheduler.register_task(
-                homeassistant_watchdog(self.loop, self.homeassistant),
-                RUN_WATCHDOG_HOMEASSISTANT)
+                homeassistant_watchdog_docker(self.loop, self.homeassistant),
+                RUN_WATCHDOG_HOMEASSISTANT_DOCKER)
+
+            # self.scheduler.register_task(
+            #    homeassistant_watchdog_api(self.loop, self.homeassistant),
+            #    RUN_WATCHDOG_HOMEASSISTANT_API)
 
             # If landingpage / run upgrade in background
             if self.homeassistant.version == 'landingpage':
                 self.loop.create_task(self.homeassistant.install())
 
-    async def stop(self, exit_code=0):
+    async def stop(self):
         """Stop a running orchestration."""
         # don't process scheduler anymore
         self.scheduler.suspend = True
 
         # process stop tasks
         self.websession.close()
-        await asyncio.wait([self.api.stop(), self.dns.stop()], loop=self.loop)
+        self.homeassistant.websession.close()
 
-        self.exit_code = exit_code
-        self.loop.stop()
+        # process async stop tasks
+        await asyncio.wait([self.api.stop(), self.dns.stop()], loop=self.loop)

hassio/dns.py

@@ -5,7 +5,7 @@ import shlex
 
 _LOGGER = logging.getLogger(__name__)
 
-COMMAND = "socat UDP-LISTEN:53,fork UDP:127.0.0.11:53"
+COMMAND = "socat UDP-RECVFROM:53,fork UDP-SENDTO:127.0.0.11:53"
 
 
 class DNSForward(object):

hassio/dock/__init__.py

@@ -62,7 +62,9 @@ class DockerAPI(object):
         # attach network
         if not network_mode:
             alias = [hostname] if hostname else None
-            if not self.network.attach_container(container, alias=alias):
+            if self.network.attach_container(container, alias=alias):
+                self.network.detach_default_bridge(container)
+            else:
                 _LOGGER.warning("Can't attach %s to hassio-net!", name)
 
         # run container

hassio/dock/addon.py

@@ -1,15 +1,15 @@
 """Init file for HassIO addon docker object."""
 import logging
-from pathlib import Path
-import shutil
+import os
 
 import docker
 import requests
 
 from .interface import DockerInterface
-from .util import dockerfile_template, docker_process
+from .util import docker_process
+from ..addons.build import AddonBuild
 from ..const import (
-    META_ADDON, MAP_CONFIG, MAP_SSL, MAP_ADDONS, MAP_BACKUP, MAP_SHARE)
+    MAP_CONFIG, MAP_SSL, MAP_ADDONS, MAP_BACKUP, MAP_SHARE)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -25,6 +25,21 @@ class DockerAddon(DockerInterface):
             config, loop, api, image=addon.image, timeout=addon.timeout)
         self.addon = addon
 
+    def process_metadata(self, metadata, force=False):
+        """Use addon data instead meta data with legacy."""
+        if not self.addon.legacy:
+            return super().process_metadata(metadata, force=force)
+
+        # set meta data
+        if not self.version or force:
+            if force:  # called on install/update/build
+                self.version = self.addon.last_version
+            else:
+                self.version = self.addon.version_installed
+
+        if not self.arch:
+            self.arch = self.config.arch
+
     @property
     def name(self):
         """Return name of docker container."""
@@ -45,6 +60,10 @@ class DockerAddon(DockerInterface):
                 '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,
@@ -89,6 +108,7 @@ class DockerAddon(DockerInterface):
         """Return hosts mapping."""
         return {
             'homeassistant': self.docker.network.gateway,
+            'hassio': self.docker.network.supervisor,
         }
 
     @property
@@ -108,6 +128,7 @@ class DockerAddon(DockerInterface):
 
         addon_mapping = self.addon.map_volumes
 
+        # setup config mappings
         if MAP_CONFIG in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_config): {
@@ -138,6 +159,17 @@ class DockerAddon(DockerInterface):
                     'bind': '/share', 'mode': addon_mapping[MAP_SHARE]
                 }})
 
+        # init other hardware mappings
+        if self.addon.with_gpio:
+            volumes.update({
+                '/sys/class/gpio': {
+                    'bind': '/sys/class/gpio', 'mode': "rw"
+                },
+                '/sys/devices/platform/soc': {
+                    'bind': '/sys/devices/platform/soc', 'mode': "rw"
+                },
+            })
+
         return volumes
 
     def _run(self):
@@ -160,6 +192,8 @@ class DockerAddon(DockerInterface):
             name=self.name,
             hostname=self.hostname,
             detach=True,
+            init=True,
+            stdin_open=self.addon.with_stdin,
             network_mode=self.network_mode,
             ports=self.ports,
             extra_hosts=self.network_mapping,
@@ -191,47 +225,21 @@ class DockerAddon(DockerInterface):
 
         Need run inside executor.
         """
-        build_dir = Path(self.config.path_tmp, self.addon.slug)
+        build_env = AddonBuild(self.config, self.addon)
+
+        _LOGGER.info("Start build %s:%s", self.image, tag)
         try:
-            # prepare temporary addon build folder
-            try:
-                source = self.addon.path_location
-                shutil.copytree(str(source), str(build_dir))
-            except shutil.Error as err:
-                _LOGGER.error("Can't copy %s to temporary build folder -> %s",
-                              source, err)
-                return False
+            image = self.docker.images.build(**build_env.get_docker_args(tag))
 
-            # prepare Dockerfile
-            try:
-                dockerfile_template(
-                    Path(build_dir, 'Dockerfile'), self.config.arch,
-                    tag, META_ADDON)
-            except OSError as err:
-                _LOGGER.error("Can't prepare dockerfile -> %s", err)
+            image.tag(self.image, tag='latest')
+            self.process_metadata(image.attrs, force=True)
 
-            # run docker build
-            try:
-                build_tag = "{}:{}".format(self.image, tag)
+        except (docker.errors.DockerException) as err:
+            _LOGGER.error("Can't build %s:%s -> %s", self.image, tag, err)
+            return False
 
-                _LOGGER.info("Start build %s on %s", build_tag, build_dir)
-                image = self.docker.images.build(
-                    path=str(build_dir), tag=build_tag, pull=True,
-                    forcerm=True
-                )
-
-                image.tag(self.image, tag='latest')
-                self.process_metadata(image.attrs, force=True)
-
-            except (docker.errors.DockerException, TypeError) as err:
-                _LOGGER.error("Can't build %s -> %s", build_tag, err)
-                return False
-
-            _LOGGER.info("Build %s done", build_tag)
-            return True
-
-        finally:
-            shutil.rmtree(str(build_dir), ignore_errors=True)
+        _LOGGER.info("Build %s:%s done", self.image, tag)
+        return True
 
     @docker_process
     def export_image(self, path):
@@ -293,3 +301,35 @@ class DockerAddon(DockerInterface):
         """
         self._stop()
         return self._run()
+
+    @docker_process
+    def write_stdin(self, data):
+        """Write to add-on stdin."""
+        return self.loop.run_in_executor(None, self._write_stdin, data)
+
+    def _write_stdin(self, data):
+        """Write to add-on stdin.
+
+        Need run inside executor.
+        """
+        if not self._is_running():
+            return False
+
+        try:
+            # load needed docker objects
+            container = self.docker.containers.get(self.name)
+            socket = container.attach_socket(params={'stdin': 1, 'stream': 1})
+        except docker.errors.DockerException as err:
+            _LOGGER.error("Can't attach to %s stdin -> %s", self.name, err)
+            return False
+
+        try:
+            # write to stdin
+            data += b"\n"
+            os.write(socket.fileno(), data)
+            socket.close()
+        except OSError as err:
+            _LOGGER.error("Can't write to %s stdin -> %s", self.name, err)
+            return False
+
+        return True

hassio/dock/homeassistant.py

@@ -1,6 +1,8 @@
 """Init file for HassIO docker object."""
 import logging
 
+import docker
+
 from .interface import DockerInterface
 
 _LOGGER = logging.getLogger(__name__)
@@ -50,6 +52,7 @@ class DockerHomeAssistant(DockerInterface):
             hostname=self.name,
             detach=True,
             privileged=True,
+            init=True,
             devices=self.devices,
             network_mode='host',
             environment={
@@ -93,3 +96,19 @@ class DockerHomeAssistant(DockerInterface):
                     {'bind': '/ssl', 'mode': 'ro'},
             }
         )
+
+    def is_initialize(self):
+        """Return True if docker container exists."""
+        return self.loop.run_in_executor(None, self._is_initialize)
+
+    def _is_initialize(self):
+        """Return True if docker container exists.
+
+        Need run inside executor.
+        """
+        try:
+            self.docker.containers.get(self.name)
+        except docker.errors.DockerException:
+            return False
+
+        return True

hassio/dock/interface.py

@@ -241,9 +241,11 @@ class DockerInterface(object):
 
         return True
 
-    @docker_process
     def logs(self):
-        """Return docker logs of container."""
+        """Return docker logs of container.
+
+        Return a Future.
+        """
         return self.loop.run_in_executor(None, self._logs)
 
     def _logs(self):

hassio/dock/network.py

@@ -71,3 +71,19 @@ class DockerNetwork(object):
 
         self.network.reload()
         return True
+
+    def detach_default_bridge(self, container):
+        """Detach default docker bridge.
+
+        Need run inside executor.
+        """
+        try:
+            default_network = self.docker.networks.get('bridge')
+            default_network.disconnect(container)
+
+        except docker.errors.NotFound:
+            return
+
+        except docker.errors.APIError as err:
+            _LOGGER.warning(
+                "Can't disconnect container from default -> %s", err)

hassio/dock/supervisor.py

@@ -6,7 +6,6 @@ import docker
 
 from .interface import DockerInterface
 from .util import docker_process
-from ..const import RESTART_EXIT_CODE
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -52,7 +51,7 @@ class DockerSupervisor(DockerInterface):
         _LOGGER.info("Update supervisor docker to %s:%s", self.image, tag)
 
         if await self.loop.run_in_executor(None, self._install, tag):
-            self.loop.create_task(self.stop_callback(RESTART_EXIT_CODE))
+            self.loop.call_later(1, self.loop.stop)
             return True
 
         return False

hassio/dock/util.py

@@ -1,48 +1,8 @@
 """HassIO docker utilitys."""
 import logging
-import re
-
-from ..const import ARCH_AARCH64, ARCH_ARMHF, ARCH_I386, ARCH_AMD64
 
 _LOGGER = logging.getLogger(__name__)
 
-HASSIO_BASE_IMAGE = {
-    ARCH_ARMHF: "homeassistant/armhf-base:latest",
-    ARCH_AARCH64: "homeassistant/aarch64-base:latest",
-    ARCH_I386: "homeassistant/i386-base:latest",
-    ARCH_AMD64: "homeassistant/amd64-base:latest",
-}
-
-TMPL_IMAGE = re.compile(r"%%BASE_IMAGE%%")
-
-
-def dockerfile_template(dockerfile, arch, version, meta_type):
-    """Prepare a Hass.IO dockerfile."""
-    buff = []
-    hassio_image = HASSIO_BASE_IMAGE[arch]
-    custom_image = re.compile(r"^#{}:FROM".format(arch))
-
-    # read docker
-    with dockerfile.open('r') as dock_input:
-        for line in dock_input:
-            line = TMPL_IMAGE.sub(hassio_image, line)
-            line = custom_image.sub("FROM", line)
-            buff.append(line)
-
-    # add metadata
-    buff.append(create_metadata(version, arch, meta_type))
-
-    # write docker
-    with dockerfile.open('w') as dock_output:
-        dock_output.writelines(buff)
-
-
-def create_metadata(version, arch, meta_type):
-    """Generate docker label layer for hassio."""
-    return ('LABEL io.hass.version="{}" '
-            'io.hass.arch="{}" '
-            'io.hass.type="{}"').format(version, arch, meta_type)
-
 
 # pylint: disable=protected-access
 def docker_process(method):

hassio/hardware.py

@@ -1,4 +1,5 @@
 """Read hardware info from system."""
+from datetime import datetime
 import logging
 from pathlib import Path
 import re
@@ -15,6 +16,11 @@ RE_CARDS = re.compile(r"(\d+) \[(\w*) *\]: (.*\w)")
 ASOUND_DEVICES = Path("/proc/asound/devices")
 RE_DEVICES = re.compile(r"\[.*(\d+)- (\d+).*\]: ([\w ]*)")
 
+PROC_STAT = Path("/proc/stat")
+RE_BOOT_TIME = re.compile(r"btime (\d+)")
+
+GPIO_DEVICES = Path("/sys/class/gpio")
+
 
 class Hardware(object):
     """Represent a interface to procfs, sysfs and udev."""
@@ -31,7 +37,7 @@ class Hardware(object):
             if 'ID_VENDOR' in device:
                 dev_list.add(device.device_node)
 
-        return list(dev_list)
+        return dev_list
 
     @property
     def input_devices(self):
@@ -41,7 +47,7 @@ class Hardware(object):
             if 'NAME' in device:
                 dev_list.add(device['NAME'].replace('"', ''))
 
-        return list(dev_list)
+        return dev_list
 
     @property
     def disk_devices(self):
@@ -51,7 +57,7 @@ class Hardware(object):
             if device.device_node.startswith('/dev/sd'):
                 dev_list.add(device.device_node)
 
-        return list(dev_list)
+        return dev_list
 
     @property
     def audio_devices(self):
@@ -85,3 +91,30 @@ class Hardware(object):
                 continue
 
         return audio_list
+
+    @property
+    def gpio_devices(self):
+        """Return list of GPIO interface on device."""
+        dev_list = set()
+        for interface in GPIO_DEVICES.glob("gpio*"):
+            dev_list.add(interface.name)
+
+        return dev_list
+
+    @property
+    def last_boot(self):
+        """Return last boot time."""
+        try:
+            with PROC_STAT.open("r") as stat_file:
+                stats = stat_file.read()
+        except OSError as err:
+            _LOGGER.error("Can't read stat data -> %s", err)
+            return
+
+        # parse stat file
+        found = RE_BOOT_TIME.search(stats)
+        if not found:
+            _LOGGER.error("Can't found last boot time!")
+            return
+
+        return datetime.utcfromtimestamp(int(found.group(1)))

hassio/homeassistant.py

@@ -4,9 +4,14 @@ import logging
 import os
 import re
 
+import aiohttp
+from aiohttp.hdrs import CONTENT_TYPE
+import async_timeout
+
 from .const import (
     FILE_HASSIO_HOMEASSISTANT, ATTR_DEVICES, ATTR_IMAGE, ATTR_LAST_VERSION,
-    ATTR_VERSION)
+    ATTR_VERSION, ATTR_BOOT, ATTR_PASSWORD, ATTR_PORT, ATTR_SSL, ATTR_WATCHDOG,
+    HEADER_HA_ACCESS, CONTENT_TYPE_JSON)
 from .dock.homeassistant import DockerHomeAssistant
 from .tools import JsonConfig, convert_to_ascii
 from .validate import SCHEMA_HASS_CONFIG
@@ -26,6 +31,9 @@ class HomeAssistant(JsonConfig):
         self.loop = loop
         self.updater = updater
         self.docker = DockerHomeAssistant(config, loop, docker, self)
+        self.api_ip = docker.network.gateway
+        self.websession = aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(verify_ssl=False), loop=loop)
 
     async def prepare(self):
         """Prepare HomeAssistant object."""
@@ -38,6 +46,57 @@ class HomeAssistant(JsonConfig):
         else:
             await self.docker.attach()
 
+    @property
+    def api_port(self):
+        """Return network port to home-assistant instance."""
+        return self._data[ATTR_PORT]
+
+    @api_port.setter
+    def api_port(self, value):
+        """Set network port for home-assistant instance."""
+        self._data[ATTR_PORT] = value
+        self.save()
+
+    @property
+    def api_password(self):
+        """Return password for home-assistant instance."""
+        return self._data.get(ATTR_PASSWORD)
+
+    @api_password.setter
+    def api_password(self, value):
+        """Set password for home-assistant instance."""
+        self._data[ATTR_PASSWORD] = value
+        self.save()
+
+    @property
+    def api_ssl(self):
+        """Return if we need ssl to home-assistant instance."""
+        return self._data[ATTR_SSL]
+
+    @api_ssl.setter
+    def api_ssl(self, value):
+        """Set SSL for home-assistant instance."""
+        self._data[ATTR_SSL] = value
+        self.save()
+
+    @property
+    def api_url(self):
+        """Return API url to Home-Assistant."""
+        return "{}://{}:{}".format(
+            'https' if self.api_ssl else 'http', self.api_ip, self.api_port
+        )
+
+    @property
+    def watchdog(self):
+        """Return True if the watchdog should protect Home-Assistant."""
+        return self._data[ATTR_WATCHDOG]
+
+    @watchdog.setter
+    def watchdog(self, value):
+        """Return True if the watchdog should protect Home-Assistant."""
+        self._data[ATTR_WATCHDOG] = value
+        self.save()
+
     @property
     def version(self):
         """Return version of running homeassistant."""
@@ -73,6 +132,17 @@ class HomeAssistant(JsonConfig):
         self._data[ATTR_DEVICES] = value
         self.save()
 
+    @property
+    def boot(self):
+        """Return True if home-assistant boot is enabled."""
+        return self._data[ATTR_BOOT]
+
+    @boot.setter
+    def boot(self, value):
+        """Set home-assistant boot options."""
+        self._data[ATTR_BOOT] = value
+        self.save()
+
     def set_custom(self, image, version):
         """Set a custom image for homeassistant."""
         # reset
@@ -98,6 +168,9 @@ class HomeAssistant(JsonConfig):
             _LOGGER.warning("Fails install landingpage, retry after 60sec")
             await asyncio.sleep(60, loop=self.loop)
 
+        # run landingpage after installation
+        await self.docker.run()
+
     async def install(self):
         """Install a landingpage."""
         _LOGGER.info("Setup HomeAssistant")
@@ -112,13 +185,16 @@ class HomeAssistant(JsonConfig):
             _LOGGER.warning("Error on install HomeAssistant. Retry in 60sec")
             await asyncio.sleep(60, loop=self.loop)
 
-        # store version
+        # finishing
         _LOGGER.info("HomeAssistant docker now installed")
+        if self.boot:
+            await self.docker.run()
         await self.docker.cleanup()
 
     async def update(self, version=None):
         """Update HomeAssistant version."""
         version = version or self.last_version
+        running = await self.docker.is_running()
 
         if version == self.docker.version:
             _LOGGER.warning("Version %s is already installed", version)
@@ -127,7 +203,8 @@ class HomeAssistant(JsonConfig):
         try:
             return await self.docker.update(version)
         finally:
-            await self.docker.run()
+            if running:
+                await self.docker.run()
 
     def run(self):
         """Run HomeAssistant docker.
@@ -164,6 +241,13 @@ class HomeAssistant(JsonConfig):
         """
         return self.docker.is_running()
 
+    def is_initialize(self):
+        """Return True if a docker container is exists.
+
+        Return a coroutine.
+        """
+        return self.docker.is_initialize()
+
     @property
     def in_progress(self):
         """Return True if a task is in progress."""
@@ -184,3 +268,23 @@ class HomeAssistant(JsonConfig):
         if exit_code != 0 or RE_YAML_ERROR.search(log):
             return (False, log)
         return (True, log)
+
+    async def check_api_state(self):
+        """Check if Home-Assistant up and running."""
+        url = "{}/api/".format(self.api_url)
+        header = {CONTENT_TYPE: CONTENT_TYPE_JSON}
+
+        if self.api_password:
+            header.update({HEADER_HA_ACCESS: self.api_password})
+
+        try:
+            async with async_timeout.timeout(30, loop=self.loop):
+                async with self.websession.get(url, headers=header) as request:
+                    status = request.status
+
+        except (asyncio.TimeoutError, aiohttp.ClientError):
+            return False
+
+        if status not in (200, 201):
+            _LOGGER.warning("Home-Assistant API config missmatch")
+        return True

hassio/snapshots/__init__.py

@@ -197,6 +197,8 @@ class SnapshotsManager(object):
                 await snapshot.restore_folders()
 
                 # start homeassistant restore
+                _LOGGER.info("Full-Restore %s restore Home-Assistant",
+                             snapshot.slug)
                 snapshot.restore_homeassistant(self.homeassistant)
                 task_hass = self.loop.create_task(
                     self.homeassistant.update(snapshot.homeassistant_version))
@@ -279,6 +281,8 @@ class SnapshotsManager(object):
                     await snapshot.restore_folders(folders)
 
                 if homeassistant:
+                    _LOGGER.info("Partial-Restore %s restore Home-Assistant",
+                                 snapshot.slug)
                     snapshot.restore_homeassistant(self.homeassistant)
                     tasks.append(self.homeassistant.update(
                         snapshot.homeassistant_version))

hassio/snapshots/snapshot.py

@@ -14,7 +14,7 @@ from .util import remove_folder
 from ..const import (
     ATTR_SLUG, ATTR_NAME, ATTR_DATE, ATTR_ADDONS, ATTR_REPOSITORIES,
     ATTR_HOMEASSISTANT, ATTR_FOLDERS, ATTR_VERSION, ATTR_TYPE, ATTR_DEVICES,
-    ATTR_IMAGE)
+    ATTR_IMAGE, ATTR_PORT, ATTR_SSL, ATTR_PASSWORD, ATTR_WATCHDOG, ATTR_BOOT)
 from ..tools import write_json_file
 
 _LOGGER = logging.getLogger(__name__)
@@ -101,6 +101,56 @@ class Snapshot(object):
         """Set snapshot homeassistant custom image."""
         self._data[ATTR_HOMEASSISTANT][ATTR_IMAGE] = value
 
+    @property
+    def homeassistant_ssl(self):
+        """Return snapshot homeassistant api ssl."""
+        return self._data[ATTR_HOMEASSISTANT].get(ATTR_SSL)
+
+    @homeassistant_ssl.setter
+    def homeassistant_ssl(self, value):
+        """Set snapshot homeassistant api ssl."""
+        self._data[ATTR_HOMEASSISTANT][ATTR_SSL] = value
+
+    @property
+    def homeassistant_port(self):
+        """Return snapshot homeassistant api port."""
+        return self._data[ATTR_HOMEASSISTANT].get(ATTR_PORT)
+
+    @homeassistant_port.setter
+    def homeassistant_port(self, value):
+        """Set snapshot homeassistant api port."""
+        self._data[ATTR_HOMEASSISTANT][ATTR_PORT] = value
+
+    @property
+    def homeassistant_password(self):
+        """Return snapshot homeassistant api password."""
+        return self._data[ATTR_HOMEASSISTANT].get(ATTR_PASSWORD)
+
+    @homeassistant_password.setter
+    def homeassistant_password(self, value):
+        """Set snapshot homeassistant api password."""
+        self._data[ATTR_HOMEASSISTANT][ATTR_PASSWORD] = value
+
+    @property
+    def homeassistant_watchdog(self):
+        """Return snapshot homeassistant watchdog options."""
+        return self._data[ATTR_HOMEASSISTANT].get(ATTR_WATCHDOG)
+
+    @homeassistant_watchdog.setter
+    def homeassistant_watchdog(self, value):
+        """Set snapshot homeassistant watchdog options."""
+        self._data[ATTR_HOMEASSISTANT][ATTR_WATCHDOG] = value
+
+    @property
+    def homeassistant_boot(self):
+        """Return snapshot homeassistant boot options."""
+        return self._data[ATTR_HOMEASSISTANT].get(ATTR_BOOT)
+
+    @homeassistant_boot.setter
+    def homeassistant_boot(self, value):
+        """Set snapshot homeassistant boot options."""
+        self._data[ATTR_HOMEASSISTANT][ATTR_BOOT] = value
+
     @property
     def size(self):
         """Return snapshot size."""
@@ -126,20 +176,34 @@ class Snapshot(object):
         """Read all data from homeassistant object."""
         self.homeassistant_version = homeassistant.version
         self.homeassistant_devices = homeassistant.devices
+        self.homeassistant_watchdog = homeassistant.watchdog
+        self.homeassistant_boot = homeassistant.boot
 
         # custom image
         if homeassistant.is_custom_image:
             self.homeassistant_image = homeassistant.image
 
+        # api
+        self.homeassistant_port = homeassistant.api_port
+        self.homeassistant_ssl = homeassistant.api_ssl
+        self.homeassistant_password = homeassistant.api_password
+
     def restore_homeassistant(self, homeassistant):
         """Write all data to homeassistant object."""
         homeassistant.devices = self.homeassistant_devices
+        homeassistant.watchdog = self.homeassistant_watchdog
+        homeassistant.boot = self.homeassistant_boot
 
         # custom image
         if self.homeassistant_image:
             homeassistant.set_custom(
                 self.homeassistant_image, self.homeassistant_version)
 
+        # api
+        homeassistant.api_port = self.homeassistant_port
+        homeassistant.api_ssl = self.homeassistant_ssl
+        homeassistant.api_password = self.homeassistant_password
+
     async def load(self):
         """Read snapshot.json from tar file."""
         if not self.tar_file.is_file():
@@ -197,7 +261,8 @@ class Snapshot(object):
         """Async context to close a snapshot."""
         # exists snapshot or exception on build
         if self.tar_file.is_file() or exception_type is not None:
-            return self._tmp.cleanup()
+            self._tmp.cleanup()
+            return
 
         # validate data
         try:
@@ -219,7 +284,6 @@ class Snapshot(object):
             _LOGGER.error("Can't write snapshot.json")
 
         self._tmp.cleanup()
-        self._tmp = None
 
     async def import_addon(self, addon):
         """Add a addon into snapshot."""
@@ -259,9 +323,11 @@ class Snapshot(object):
             origin_dir = Path(self.config.path_hassio, name)
 
             try:
+                _LOGGER.info("Snapshot folder %s", name)
                 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)
 
                 self._data[ATTR_FOLDERS].append(name)
             except tarfile.TarError as err:
@@ -288,8 +354,10 @@ class Snapshot(object):
                 remove_folder(origin_dir)
 
             try:
+                _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)
             except tarfile.TarError as err:
                 _LOGGER.warning("Can't restore folder %s -> %s", name, err)
 

hassio/snapshots/validate.py

@@ -5,9 +5,10 @@ import voluptuous as vol
 from ..const import (
     ATTR_REPOSITORIES, ATTR_ADDONS, ATTR_NAME, ATTR_SLUG, ATTR_DATE,
     ATTR_VERSION, ATTR_HOMEASSISTANT, ATTR_FOLDERS, ATTR_TYPE, ATTR_DEVICES,
-    ATTR_IMAGE, FOLDER_SHARE, FOLDER_HOMEASSISTANT, FOLDER_ADDONS, FOLDER_SSL,
+    ATTR_IMAGE, ATTR_PASSWORD, ATTR_PORT, ATTR_SSL, ATTR_WATCHDOG, ATTR_BOOT,
+    FOLDER_SHARE, FOLDER_HOMEASSISTANT, FOLDER_ADDONS, FOLDER_SSL,
     SNAPSHOT_FULL, SNAPSHOT_PARTIAL)
-from ..validate import HASS_DEVICES
+from ..validate import HASS_DEVICES, NETWORK_PORT
 
 ALL_FOLDERS = [FOLDER_HOMEASSISTANT, FOLDER_SHARE, FOLDER_ADDONS, FOLDER_SSL]
 
@@ -21,6 +22,11 @@ SCHEMA_SNAPSHOT = vol.Schema({
         vol.Required(ATTR_VERSION): vol.Coerce(str),
         vol.Optional(ATTR_DEVICES, default=[]): HASS_DEVICES,
         vol.Optional(ATTR_IMAGE): 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_FOLDERS, default=[]): [vol.In(ALL_FOLDERS)],
     vol.Optional(ATTR_ADDONS, default=[]): [vol.Schema({

hassio/tasks.py

@@ -62,13 +62,54 @@ def hassio_update(supervisor, updater):
     return _hassio_update
 
 
-def homeassistant_watchdog(loop, homeassistant):
-    """Create scheduler task for montoring running state."""
-    async def _homeassistant_watchdog():
-        """Check running state and start if they is close."""
+def homeassistant_watchdog_docker(loop, homeassistant):
+    """Create scheduler task for montoring running state of docker."""
+    async def _homeassistant_watchdog_docker():
+        """Check running state of docker and start if they is close."""
+        # if Home-Assistant is active
+        if not await homeassistant.is_initialize() or \
+                not homeassistant.watchdog:
+            return
+
+        # if Home-Assistant is running
         if homeassistant.in_progress or await homeassistant.is_running():
             return
 
         loop.create_task(homeassistant.run())
+        _LOGGER.error("Watchdog found a problem with Home-Assistant docker!")
 
-    return _homeassistant_watchdog
+    return _homeassistant_watchdog_docker
+
+
+def homeassistant_watchdog_api(loop, homeassistant):
+    """Create scheduler task for montoring running state of API.
+
+    Try 2 times to call API before we restart Home-Assistant. Maybe we had a
+    delay in our system.
+    """
+    retry_scan = 0
+
+    async def _homeassistant_watchdog_api():
+        """Check running state of API and start if they is close."""
+        nonlocal retry_scan
+
+        # if Home-Assistant is active
+        if not await homeassistant.is_initialize() or \
+                not homeassistant.watchdog:
+            return
+
+        # if Home-Assistant API is up
+        if homeassistant.in_progress or await homeassistant.check_api_state():
+            return
+        retry_scan += 1
+
+        # Retry active
+        if retry_scan == 1:
+            _LOGGER.warning("Watchdog miss API response from Home-Assistant")
+            return
+
+        loop.create_task(homeassistant.restart())
+        _LOGGER.error("Watchdog found a problem with Home-Assistant API!")
+        retry_scan = 0
+
+    return _homeassistant_watchdog_api

hassio/tools.py

@@ -1,13 +1,14 @@
 """Tools file for HassIO."""
 import asyncio
 from contextlib import suppress
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 import json
 import logging
 import re
 
 import aiohttp
 import async_timeout
+import pytz
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
@@ -17,6 +18,16 @@ FREEGEOIP_URL = "https://freegeoip.io/json/"
 
 RE_STRING = re.compile(r"\x1b(\[.*?[@-~]|\].*?(\x07|\x1b\\))")
 
+# Copyright (c) Django Software Foundation and individual contributors.
+# All rights reserved.
+# https://github.com/django/django/blob/master/LICENSE
+DATETIME_RE = re.compile(
+    r'(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})'
+    r'[T ](?P<hour>\d{1,2}):(?P<minute>\d{1,2})'
+    r'(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?'
+    r'(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$'
+)
+
 
 def write_json_file(jsonfile, data):
     """Write a json file."""
@@ -53,6 +64,42 @@ def convert_to_ascii(raw):
     return RE_STRING.sub("", raw.decode())
 
 
+# Copyright (c) Django Software Foundation and individual contributors.
+# All rights reserved.
+# https://github.com/django/django/blob/master/LICENSE
+def parse_datetime(dt_str):
+    """Parse a string and return a datetime.datetime.
+
+    This function supports time zone offsets. When the input contains one,
+    the output uses a timezone with a fixed offset from UTC.
+    Raises ValueError if the input is well formatted but not a valid datetime.
+    Returns None if the input isn't well formatted.
+    """
+    match = DATETIME_RE.match(dt_str)
+    if not match:
+        return None
+    kws = match.groupdict()  # type: Dict[str, Any]
+    if kws['microsecond']:
+        kws['microsecond'] = kws['microsecond'].ljust(6, '0')
+    tzinfo_str = kws.pop('tzinfo')
+
+    tzinfo = None  # type: Optional[dt.tzinfo]
+    if tzinfo_str == 'Z':
+        tzinfo = pytz.utc
+    elif tzinfo_str is not None:
+        offset_mins = int(tzinfo_str[-2:]) if len(tzinfo_str) > 3 else 0
+        offset_hours = int(tzinfo_str[1:3])
+        offset = timedelta(hours=offset_hours, minutes=offset_mins)
+        if tzinfo_str[0] == '-':
+            offset = -offset
+        tzinfo = timezone(offset)
+    else:
+        tzinfo = None
+    kws = {k: int(v) for k, v in kws.items() if v is not None}
+    kws['tzinfo'] = tzinfo
+    return datetime(**kws)
+
+
 class JsonConfig(object):
     """Hass core object for handle it."""
 
@@ -76,6 +123,8 @@ class JsonConfig(object):
         except vol.Invalid as ex:
             _LOGGER.error("Can't parse %s -> %s",
                           self._file, humanize_error(self._data, ex))
+            # reset data to default
+            self._data = self._schema({})
 
     def save(self):
         """Store data to config file."""

hassio/validate.py

@@ -7,7 +7,8 @@ from .const import (
     ATTR_DEVICES, 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_HOMEASSISTANT, ATTR_HASSIO, ATTR_BOOT, ATTR_LAST_BOOT, ATTR_SSL,
+    ATTR_PORT, ATTR_WATCHDOG)
 
 
 NETWORK_PORT = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
@@ -55,11 +56,17 @@ DOCKER_PORTS = vol.Schema({
 })
 
 
+# pylint: disable=no-value-for-parameter
 SCHEMA_HASS_CONFIG = vol.Schema({
     vol.Optional(ATTR_DEVICES, default=[]): HASS_DEVICES,
+    vol.Optional(ATTR_BOOT, default=True): vol.Boolean(),
     vol.Inclusive(ATTR_IMAGE, 'custom_hass'): vol.Coerce(str),
     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(),
+}, extra=vol.REMOVE_EXTRA)
 
 
 # pylint: disable=no-value-for-parameter
@@ -67,12 +74,13 @@ SCHEMA_UPDATER_CONFIG = vol.Schema({
     vol.Optional(ATTR_BETA_CHANNEL, default=False): vol.Boolean(),
     vol.Optional(ATTR_HOMEASSISTANT): vol.Coerce(str),
     vol.Optional(ATTR_HASSIO): vol.Coerce(str),
-})
+}, extra=vol.REMOVE_EXTRA)
 
 
 # pylint: disable=no-value-for-parameter
 SCHEMA_HASSIO_CONFIG = vol.Schema({
     vol.Optional(ATTR_TIMEZONE, default='UTC'): validate_timezone,
+    vol.Optional(ATTR_LAST_BOOT): vol.Coerce(str),
     vol.Optional(ATTR_ADDONS_CUSTOM_LIST, default=[]): [vol.Url()],
     vol.Optional(ATTR_SECURITY, default=False): vol.Boolean(),
     vol.Optional(ATTR_TOTP): vol.Coerce(str),

setup.py

@@ -12,7 +12,7 @@ setup(
     url='https://home-assistant.io/',
     description=('Open-source private cloud os for Home-Assistant'
                  ' based on ResinOS'),
-    long_description=('A maintenainless private cloud operator system that'
+    long_description=('A maintainless private cloud operator system that'
                       'setup a Home-Assistant instance. Based on ResinOS'),
     classifiers=[
         'Intended Audience :: End Users/Desktop',
@@ -47,7 +47,6 @@ setup(
         'pyotp',
         'pyqrcode',
         'pytz',
-        'pyudev',
-        'deepmerge'
+        'pyudev'
     ]
 )

version.json

@@ -1,7 +1,7 @@
 {
-    "hassio": "0.58",
-    "homeassistant": "0.51.2",
-    "resinos": "1.0",
+    "hassio": "0.75",
+    "homeassistant": "0.57.3",
+    "resinos": "1.1",
     "resinhup": "0.3",
     "generic": "0.3",
     "cluster": "0.1"