Update hass.io to 0.67

* Add initial for hass interface

* For better compatibility, remove extra options for cleanup old stuff

* Add new functions to api

* Add api proxy to home-assistant

* use const

* fix lint

* fix lint

* Add check_api_state function

* Add api watchdog

* Fix lint

* update output

* fix url

* Fix API call

* fix API documentation

* remove password

* fix api call to hass api only

* fix problem with config missmatch

* test

* Detect wrong ssl settings

* disable watchdog & add options

* Update API

.dockerignore

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

API.md

@@ -284,7 +284,10 @@ Optional:
     "devices": [""],
     "image": "str",
     "custom": "bool -> if custom image",
-    "boot": "bool"
+    "boot": "bool",
+    "port": 8123,
+    "ssl": "bool",
+    "watchdog": "bool"
 }
 ```
 
@@ -303,21 +306,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`
@@ -342,6 +354,7 @@ Get all available addons.
             "url": "null|url",
             "logo": "bool",
             "audio": "bool",
+            "gpio": "bool",
             "hassio_api": "bool"
         }
     ],
@@ -381,6 +394,7 @@ Get all available addons.
     "logo": "bool",
     "hassio_api": "bool",
     "webui": "null|http(s)://[HOST]:port/xy/zx",
+    "gpio": "bool",
     "audio": "bool",
     "audio_input": "null|0,0",
     "audio_output": "null|0,0"

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/addons/addon.py

@@ -21,14 +21,17 @@ from ..const import (
     ATTR_HOST_NETWORK, ATTR_TMPFS, ATTR_PRIVILEGED, ATTR_STARTUP,
     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)
 from .util import check_installed
 from ..dock.addon import DockerAddon
 from ..tools import write_json_file, read_json_file
 
 _LOGGER = logging.getLogger(__name__)
 
-RE_WEBUI = re.compile(r"^(.*\[HOST\]:)\[PORT:(\d+)\](.*)$")
+RE_WEBUI = re.compile(
+    r"^(?:(?P<s_prefix>https?)|\[PROTO:(?P<t_proto>\w+)\])"
+    r":\/\/\[HOST\]:\[PORT:(?P<t_port>\d+)\](?P<s_suffix>.*)$")
 
 MERGE_OPT = Merger([(dict, ['merge'])], ['override'], ['override'])
 
@@ -206,19 +209,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 = self.ports.get("{}/tcp".format(t_port), t_port)
         else:
-            real_port = self.ports.get("{}/tcp".format(dock_port), dock_port)
+            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):
@@ -250,6 +265,11 @@ class Addon(object):
         """Return True if the add-on access to hassio api."""
         return self._mesh[ATTR_HASSIO_API]
 
+    @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."""

hassio/addons/build.py

@@ -38,11 +38,9 @@ class AddonBuild(JsonConfig):
 
     def get_docker_args(self, version):
         """Create a dict with docker build arguments."""
-        build_tag = "{}:{}".format(self.addon.image, version)
-
-        return {
+        args = {
             'path': str(self.addon.path_location),
-            'tag': build_tag,
+            'tag': "{}:{}".format(self.addon.image, version),
             'pull': True,
             'forcerm': True,
             'squash': self.squash,
@@ -50,6 +48,8 @@ class AddonBuild(JsonConfig):
                 '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,
@@ -58,3 +58,8 @@ class AddonBuild(JsonConfig):
                 **self.additional_args,
             }
         }
+
+        if self.addon.url:
+            args['labels']['io.hass.url'] = self.addon.url
+
+        return args

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

@@ -14,7 +14,7 @@ from ..const import (
     ATTR_LOCATON, ATTR_REPOSITORY, ATTR_TIMEOUT, ATTR_NETWORK,
     ATTR_AUTO_UPDATE, ATTR_WEBUI, ATTR_AUDIO, ATTR_AUDIO_INPUT,
     ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API, ATTR_BUILD_FROM, ATTR_SQUASH,
-    ATTR_ARGS)
+    ATTR_ARGS, ATTR_GPIO)
 from ..validate import NETWORK_PORT, DOCKER_PORTS, ALSA_CHANNEL
 
 
@@ -86,7 +86,7 @@ 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):
@@ -95,6 +95,7 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     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.Required(ATTR_OPTIONS): dict,
     vol.Required(ATTR_SCHEMA): vol.Any(vol.Schema({
@@ -105,7 +106,7 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     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.REMOVE_EXTRA)
 
 
 # pylint: disable=no-value-for-parameter
@@ -113,7 +114,7 @@ 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.REMOVE_EXTRA)
 
 
 # pylint: disable=no-value-for-parameter

hassio/api/__init__.py

@@ -75,6 +75,10 @@ class RestAPI(object):
         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."""

hassio/api/addons.py

@@ -13,7 +13,7 @@ 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, BOOT_AUTO, BOOT_MANUAL, CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY)
 from ..validate import DOCKER_PORTS
 
 _LOGGER = logging.getLogger(__name__)
@@ -79,6 +79,7 @@ class APIAddons(object):
                 ATTR_LOGO: addon.with_logo,
                 ATTR_HASSIO_API: addon.use_hassio_api,
                 ATTR_AUDIO: addon.with_audio,
+                ATTR_GPIO: addon.with_gpio,
             })
 
         data_repositories = []
@@ -127,6 +128,7 @@ class APIAddons(object):
             ATTR_LOGO: addon.with_logo,
             ATTR_WEBUI: addon.webui,
             ATTR_HASSIO_API: addon.use_hassio_api,
+            ATTR_GPIO: addon.with_gpio,
             ATTR_AUDIO: addon.with_audio,
             ATTR_AUDIO_INPUT: addon.audio_input,
             ATTR_AUDIO_OUTPUT: addon.audio_output,

hassio/api/homeassistant.py

@@ -2,13 +2,19 @@
 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,
-    ATTR_BOOT, 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__)
 
@@ -20,6 +26,10 @@ 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.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({
@@ -36,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."""
@@ -46,6 +95,9 @@ class APIHomeAssistant(object):
             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
@@ -63,6 +115,18 @@ class APIHomeAssistant(object):
         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
@@ -105,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/const.py

@@ -2,7 +2,7 @@
 from pathlib import Path
 from ipaddress import ip_network
 
-HASSIO_VERSION = '0.64'
+HASSIO_VERSION = '0.67'
 
 URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
                       'hassio/{}/version.json')
@@ -16,7 +16,8 @@ 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
@@ -50,7 +51,10 @@ 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'
@@ -71,6 +75,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'
@@ -120,6 +126,7 @@ ATTR_SERIAL = 'serial'
 ATTR_SECURITY = 'security'
 ATTR_BUILD_FROM = 'build_from'
 ATTR_SQUASH = 'squash'
+ATTR_GPIO = 'gpio'
 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__)
@@ -165,8 +166,12 @@ class HassIO(object):
         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':
@@ -179,6 +184,7 @@ class HassIO(object):
 
         # process stop tasks
         self.websession.close()
+        self.homeassistant.websession.close()
         await asyncio.wait([self.api.stop(), self.dns.stop()], loop=self.loop)
 
         self.exit_code = exit_code

hassio/dock/addon.py

@@ -107,6 +107,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): {
@@ -137,6 +138,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):

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_BOOT)
+    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._data.save()
+
     @property
     def version(self):
         """Return version of running homeassistant."""
@@ -209,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/tasks.py

@@ -62,18 +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():
+        if not await homeassistant.is_initialize() or \
+                not homeassistant.watchdog:
             return
 
-        # If Home-Assistant is running
+        # 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/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_BOOT, ATTR_LAST_BOOT)
+    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))
@@ -61,7 +62,11 @@ SCHEMA_HASS_CONFIG = vol.Schema({
     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
@@ -69,7 +74,7 @@ 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

version.json

@@ -1,5 +1,5 @@
 {
-    "hassio": "0.64",
+    "hassio": "0.67",
     "homeassistant": "0.54",
     "resinos": "1.1",
     "resinhup": "0.3",