Update Hass.io to version 0.78

* Bugfix SSL settings on proxy

* fix lint

API.md

@@ -331,6 +331,10 @@ Image with `null` and last_version with `null` reset this options.
 
 Proxy to real home-assistant instance.
 
+- GET `/homeassistant/websocket`
+
+Proxy to real websocket instance.
+
 ### RESTful for API addons
 
 - GET `/addons`
@@ -350,15 +354,8 @@ Get all available addons.
             "installed": "none|INSTALL_VERSION",
             "detached": "bool",
             "build": "bool",
-            "privileged": ["NET_ADMIN", "SYS_ADMIN"],
-            "devices": ["/dev/xy"],
             "url": "null|url",
-            "logo": "bool",
-            "audio": "bool",
-            "gpio": "bool",
-            "stdin": "bool",
-            "hassio_api": "bool",
-            "homeassistant_api": "bool"
+            "logo": "bool"
         }
     ],
     "repositories": [
@@ -380,6 +377,7 @@ Get all available addons.
 {
     "name": "xy bla",
     "description": "description",
+    "long_description": "null|markdown",
     "auto_update": "bool",
     "url": "null|url of addon",
     "detached": "bool",
@@ -392,9 +390,13 @@ Get all available addons.
     "options": "{}",
     "network": "{}|null",
     "host_network": "bool",
+    "host_ipc": "bool",
+    "host_dbus": "bool",
     "privileged": ["NET_ADMIN", "SYS_ADMIN"],
     "devices": ["/dev/xy"],
+    "auto_uart": "bool",
     "logo": "bool",
+    "changelog": "bool",
     "hassio_api": "bool",
     "homeassistant_api": "bool",
     "stdin": "bool",
@@ -408,6 +410,8 @@ Get all available addons.
 
 - GET `/addons/{addon}/logo`
 
+- GET `/addons/{addon}/changelog`
+
 - POST `/addons/{addon}/options`
 
 ```json

Dockerfile

@@ -1,21 +1,25 @@
 ARG BUILD_FROM
 FROM $BUILD_FROM
 
-# add env
+# 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
+# Setup base
+RUN apk add --no-cache \
+        python3 \
+        git \
+        socat \
+        libstdc++ \
+    && apk add --no-cache --virtual .build-dependencies \
+        make \
+        python3-dev \
+        g++ \
+    && pip3 install --no-cache-dir \
+        uvloop \
+        cchardet \
+    && apk del .build-dependencies
 
-# install HassIO
+# Install HassIO
 COPY . /usr/src/hassio
 RUN pip3 install --no-cache-dir /usr/src/hassio \
     && rm -rf /usr/src/hassio

hassio/__main__.py

@@ -10,9 +10,19 @@ import hassio.core as core
 _LOGGER = logging.getLogger(__name__)
 
 
+def attempt_use_uvloop():
+    """Attempt to use uvloop."""
+    try:
+        import uvloop
+        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    except ImportError:
+        pass
+
+
 # pylint: disable=invalid-name
 if __name__ == "__main__":
     bootstrap.initialize_logging()
+    attempt_use_uvloop()
     loop = asyncio.get_event_loop()
 
     if not bootstrap.check_environment():

hassio/addons/addon.py

@@ -21,7 +21,8 @@ from ..const import (
     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_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY)
+    ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY, ATTR_HOST_IPC,
+    ATTR_HOST_DBUS, ATTR_AUTO_UART)
 from .util import check_installed
 from ..dock.addon import DockerAddon
 from ..tools import write_json_file, read_json_file
@@ -136,6 +137,7 @@ class Addon(object):
         """Return if auto update is enable."""
         if ATTR_AUTO_UPDATE in self.data.user.get(self._id, {}):
             return self.data.user[self._id][ATTR_AUTO_UPDATE]
+        return None
 
     @auto_update.setter
     def auto_update(self, value):
@@ -158,12 +160,26 @@ class Addon(object):
         """Return a API token for this add-on."""
         if self.is_installed:
             return self.data.user[self._id][ATTR_UUID]
+        return None
 
     @property
     def description(self):
         """Return description of addon."""
         return self._mesh[ATTR_DESCRIPTON]
 
+    @property
+    def long_description(self):
+        """Return README.md as long_description."""
+        readme = Path(self.path_location, 'README.md')
+
+        # If readme not exists
+        if not readme.exists():
+            return None
+
+        # Return data
+        with readme.open('r') as readme_file:
+            return readme_file.read()
+
     @property
     def repository(self):
         """Return repository of addon."""
@@ -243,11 +259,26 @@ class Addon(object):
         """Return True if addon run on host network."""
         return self._mesh[ATTR_HOST_NETWORK]
 
+    @property
+    def host_ipc(self):
+        """Return True if addon run on host IPC namespace."""
+        return self._mesh[ATTR_HOST_IPC]
+
+    @property
+    def host_dbus(self):
+        """Return True if addon run on host DBUS."""
+        return self._mesh[ATTR_HOST_DBUS]
+
     @property
     def devices(self):
         """Return devices of addon."""
         return self._mesh.get(ATTR_DEVICES)
 
+    @property
+    def auto_uart(self):
+        """Return True if we should map all uart device."""
+        return self._mesh.get(ATTR_AUTO_UART)
+
     @property
     def tmpfs(self):
         """Return tmpfs of addon."""
@@ -317,7 +348,7 @@ class Addon(object):
     def audio_input(self):
         """Return ALSA config for input or None."""
         if not self.with_audio:
-            return
+            return None
 
         setting = self.config.audio_input
         if self.is_installed and ATTR_AUDIO_INPUT in self.data.user[self._id]:
@@ -343,6 +374,11 @@ class Addon(object):
         """Return True if a logo exists."""
         return self.path_logo.exists()
 
+    @property
+    def with_changelog(self):
+        """Return True if a changelog exists."""
+        return self.path_changelog.exists()
+
     @property
     def supported_arch(self):
         """Return list of supported arch."""
@@ -402,6 +438,11 @@ class Addon(object):
         """Return path to addon logo."""
         return Path(self.path_location, 'logo.png')
 
+    @property
+    def path_changelog(self):
+        """Return path to addon changelog."""
+        return Path(self.path_location, 'CHANGELOG.md')
+
     def write_options(self):
         """Return True if addon options is written to data."""
         schema = self.schema

hassio/addons/build.py

@@ -1,7 +1,7 @@
 """HassIO addons build environment."""
 from pathlib import Path
 
-from .validate import SCHEMA_BUILD_CONFIG
+from .validate import SCHEMA_BUILD_CONFIG, BASE_IMAGE
 from ..const import ATTR_SQUASH, ATTR_BUILD_FROM, ATTR_ARGS, META_ADDON
 from ..tools import JsonConfig
 
@@ -24,7 +24,8 @@ class AddonBuild(JsonConfig):
     @property
     def base_image(self):
         """Base images for this addon."""
-        return self._data[ATTR_BUILD_FROM][self.config.arch]
+        return self._data[ATTR_BUILD_FROM].get(
+            self.config.arch, BASE_IMAGE[self.config.arch])
 
     @property
     def squash(self):

hassio/addons/built-in.json

@@ -2,7 +2,7 @@
     "local": {
         "name": "Local Add-Ons",
         "url": "https://home-assistant.io/hassio",
-        "maintainer": "By our self"
+        "maintainer": "you"
     },
     "core": {
         "name": "Built-in Add-Ons",

hassio/addons/validate.py

@@ -14,9 +14,10 @@ from ..const import (
     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_UUID,
-    ATTR_AUTO_UPDATE, ATTR_WEBUI, ATTR_AUDIO, ATTR_AUDIO_INPUT,
+    ATTR_AUTO_UPDATE, ATTR_WEBUI, ATTR_AUDIO, ATTR_AUDIO_INPUT, ATTR_HOST_IPC,
     ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API, ATTR_BUILD_FROM, ATTR_SQUASH,
-    ATTR_ARGS, ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY)
+    ATTR_ARGS, ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY,
+    ATTR_HOST_DBUS, ATTR_AUTO_UART)
 from ..validate import NETWORK_PORT, DOCKER_PORTS, ALSA_CHANNEL
 
 _LOGGER = logging.getLogger(__name__)
@@ -92,7 +93,10 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Optional(ATTR_WEBUI):
         vol.Match(r"^(?:https?|\[PROTO:\w+\]):\/\/\[HOST\]:\[PORT:\d+\].*$"),
     vol.Optional(ATTR_HOST_NETWORK, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HOST_IPC, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HOST_DBUS, default=False): vol.Boolean(),
     vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
+    vol.Optional(ATTR_AUTO_UART, default=False): vol.Boolean(),
     vol.Optional(ATTR_TMPFS):
         vol.Match(r"^size=(\d)*[kmg](,uid=\d{1,4})?(,rw)?$"),
     vol.Optional(ATTR_MAP, default=[]): [vol.Match(RE_VOLUME)],
@@ -215,6 +219,7 @@ def validate_options(raw_schema):
 
 
 # pylint: disable=no-value-for-parameter
+# pylint: disable=inconsistent-return-statements
 def _single_validate(typ, value, key):
     """Validate a single element."""
     # if required argument

hassio/api/__init__.py

@@ -8,6 +8,7 @@ from .addons import APIAddons
 from .homeassistant import APIHomeAssistant
 from .host import APIHost
 from .network import APINetwork
+from .proxy import APIProxy
 from .supervisor import APISupervisor
 from .security import APISecurity
 from .snapshots import APISnapshots
@@ -63,9 +64,9 @@ class RestAPI(object):
             '/supervisor/options', api_supervisor.options)
         self.webapp.router.add_get('/supervisor/logs', api_supervisor.logs)
 
-    def register_homeassistant(self, dock_homeassistant):
+    def register_homeassistant(self, homeassistant):
         """Register homeassistant function."""
-        api_hass = APIHomeAssistant(self.config, self.loop, dock_homeassistant)
+        api_hass = APIHomeAssistant(self.config, self.loop, homeassistant)
 
         self.webapp.router.add_get('/homeassistant/info', api_hass.info)
         self.webapp.router.add_get('/homeassistant/logs', api_hass.logs)
@@ -75,10 +76,21 @@ 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)
+
+    def register_proxy(self, homeassistant):
+        """Register HomeAssistant API Proxy."""
+        api_proxy = APIProxy(self.loop, homeassistant)
+
         self.webapp.router.add_get(
-            '/homeassistant/api/{path:.+}', api_hass.api)
+            '/homeassistant/api/websocket', api_proxy.websocket)
+        self.webapp.router.add_get(
+            '/homeassistant/websocket', api_proxy.websocket)
+        self.webapp.router.add_post(
+            '/homeassistant/api/{path:.+}', api_proxy.api)
+        self.webapp.router.add_get(
+            '/homeassistant/api/{path:.+}', api_proxy.api)
+        self.webapp.router.add_get(
+            '/homeassistant/api', api_proxy.api)
 
     def register_addons(self, addons):
         """Register homeassistant function."""
@@ -104,6 +116,8 @@ 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_get(
+            '/addons/{addon}/changelog', api_addons.changelog)
         self.webapp.router.add_post('/addons/{addon}/stdin', api_addons.stdin)
 
     def register_security(self):

hassio/api/addons.py

@@ -14,7 +14,8 @@ from ..const import (
     ATTR_INSTALLED, ATTR_LOGO, ATTR_WEBUI, ATTR_DEVICES, ATTR_PRIVILEGED,
     ATTR_AUDIO, ATTR_AUDIO_INPUT, ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API,
     ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, BOOT_AUTO, BOOT_MANUAL,
-    CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY)
+    ATTR_CHANGELOG, ATTR_HOST_IPC, ATTR_HOST_DBUS, ATTR_LONG_DESCRIPTION,
+    CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY, CONTENT_TYPE_TEXT)
 from ..validate import DOCKER_PORTS
 
 _LOGGER = logging.getLogger(__name__)
@@ -56,7 +57,7 @@ class APIAddons(object):
         """Return a simplified device list."""
         dev_list = addon.devices
         if not dev_list:
-            return
+            return None
         return [row.split(':')[0] for row in dev_list]
 
     @api_process
@@ -74,15 +75,8 @@ class APIAddons(object):
                 ATTR_DETACHED: addon.is_detached,
                 ATTR_REPOSITORY: addon.repository,
                 ATTR_BUILD: addon.need_build,
-                ATTR_PRIVILEGED: addon.privileged,
-                ATTR_DEVICES: self._pretty_devices(addon),
                 ATTR_URL: addon.url,
                 ATTR_LOGO: addon.with_logo,
-                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 = []
@@ -114,6 +108,7 @@ class APIAddons(object):
         return {
             ATTR_NAME: addon.name,
             ATTR_DESCRIPTON: addon.description,
+            ATTR_LONG_DESCRIPTION: addon.long_description,
             ATTR_VERSION: addon.version_installed,
             ATTR_AUTO_UPDATE: addon.auto_update,
             ATTR_REPOSITORY: addon.repository,
@@ -126,9 +121,12 @@ class APIAddons(object):
             ATTR_BUILD: addon.need_build,
             ATTR_NETWORK: addon.ports,
             ATTR_HOST_NETWORK: addon.host_network,
+            ATTR_HOST_IPC: addon.host_ipc,
+            ATTR_HOST_DBUS: addon.host_dbus,
             ATTR_PRIVILEGED: addon.privileged,
             ATTR_DEVICES: self._pretty_devices(addon),
             ATTR_LOGO: addon.with_logo,
+            ATTR_CHANGELOG: addon.with_changelog,
             ATTR_WEBUI: addon.webui,
             ATTR_STDIN: addon.with_stdin,
             ATTR_HASSIO_API: addon.access_hassio_api,
@@ -238,6 +236,16 @@ class APIAddons(object):
         with addon.path_logo.open('rb') as png:
             return png.read()
 
+    @api_process_raw(CONTENT_TYPE_TEXT)
+    async def changelog(self, request):
+        """Return changelog from addon."""
+        addon = self._extract_addon(request, check_installed=False)
+        if not addon.with_changelog:
+            raise RuntimeError("No changelog found!")
+
+        with addon.path_changelog.open('r') as changelog:
+            return changelog.read()
+
     @api_process
     async def stdin(self, request):
         """Write to stdin of addon."""

hassio/api/homeassistant.py

@@ -2,18 +2,13 @@
 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, ATTR_PORT, ATTR_PASSWORD, ATTR_SSL, ATTR_WATCHDOG,
-    CONTENT_TYPE_BINARY, HEADER_HA_ACCESS)
+    CONTENT_TYPE_BINARY)
 from ..validate import HASS_DEVICES, NETWORK_PORT
 
 _LOGGER = logging.getLogger(__name__)
@@ -46,45 +41,6 @@ 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."""
@@ -169,14 +125,3 @@ 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/proxy.py

@@ -0,0 +1,197 @@
+"""Utils for HomeAssistant Proxy."""
+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
+
+from ..const import HEADER_HA_ACCESS
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIProxy(object):
+    """API Proxy for Home-Assistant."""
+
+    def __init__(self, loop, homeassistant):
+        """Initialize api proxy."""
+        self.loop = loop
+        self.homeassistant = homeassistant
+
+        # Use homeassistant websession to ignore SSL
+        self.websession = homeassistant.websession
+
+    async def _api_client(self, request, path, timeout=300):
+        """Return a client request with proxy origin for Home-Assistant."""
+        url = f"{self.homeassistant.api_url}/api/{path}"
+
+        try:
+            data = None
+            headers = {}
+            method = getattr(self.websession, request.method.lower())
+
+            # read data
+            with async_timeout.timeout(30, 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=timeout
+            )
+
+            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()
+
+    async def api(self, request):
+        """Proxy HomeAssistant API Requests."""
+        path = request.match_info.get('path', '')
+
+        # API stream
+        if path.startswith("stream"):
+            _LOGGER.info("Home-Assistant Event-Stream start")
+            client = await self._api_client(request, path, timeout=None)
+
+            response = web.StreamResponse()
+            response.content_type = request.headers.get(CONTENT_TYPE)
+            try:
+                await response.prepare(request)
+                while True:
+                    data = await client.content.read(10)
+                    if not data:
+                        await response.write_eof()
+                        break
+                    response.write(data)
+
+            except aiohttp.ClientError:
+                await response.write_eof()
+
+            except asyncio.CancelledError:
+                pass
+
+            finally:
+                client.close()
+
+            _LOGGER.info("Home-Assistant Event-Stream close")
+
+        # Normal request
+        else:
+            _LOGGER.info("Home-Assistant '/api/%s' request", path)
+            client = await self._api_client(request, path)
+
+            data = await client.read()
+            return web.Response(
+                body=data,
+                status=client.status,
+                content_type=client.content_type
+            )
+
+    async def _websocket_client(self):
+        """Initialize a websocket api connection."""
+        url = f"{self.homeassistant.api_url}/api/websocket"
+
+        try:
+            client = await self.websession.ws_connect(
+                url, heartbeat=60, verify_ssl=False)
+
+            # handle authentication
+            for _ in range(2):
+                data = await client.receive_json()
+                if data.get('type') == 'auth_ok':
+                    return client
+                elif data.get('type') == 'auth_required':
+                    await client.send_json({
+                        'type': 'auth',
+                        'api_password': self.homeassistant.api_password,
+                    })
+
+            _LOGGER.error("Authentication to Home-Assistant websocket")
+
+        except (aiohttp.ClientError, RuntimeError) as err:
+            _LOGGER.error("Client error on websocket API %s.", err)
+
+        raise HTTPBadGateway()
+
+    async def websocket(self, request):
+        """Initialize a websocket api connection."""
+        _LOGGER.info("Home-Assistant Websocket API request initialze")
+
+        # init server
+        server = web.WebSocketResponse(heartbeat=60)
+        await server.prepare(request)
+
+        # handle authentication
+        await server.send_json({'type': 'auth_required'})
+        await server.receive_json()  # get internal token
+        await server.send_json({'type': 'auth_ok'})
+
+        # init connection to hass
+        client = await self._websocket_client()
+
+        _LOGGER.info("Home-Assistant Websocket API request running")
+        try:
+            client_read = None
+            server_read = None
+            while not server.closed and not client.closed:
+                if not client_read:
+                    client_read = asyncio.ensure_future(
+                        client.receive_str(), loop=self.loop)
+                if not server_read:
+                    server_read = asyncio.ensure_future(
+                        server.receive_str(), loop=self.loop)
+
+                # wait until data need to be processed
+                await asyncio.wait(
+                    [client_read, server_read],
+                    loop=self.loop, return_when=asyncio.FIRST_COMPLETED
+                )
+
+                # server
+                if server_read.done() and not client.closed:
+                    server_read.exception()
+                    await client.send_str(server_read.result())
+                    server_read = None
+
+                # client
+                if client_read.done() and not server.closed:
+                    client_read.exception()
+                    await server.send_str(client_read.result())
+                    client_read = None
+
+        except asyncio.CancelledError:
+            pass
+
+        except RuntimeError as err:
+            _LOGGER.info("Home-Assistant Websocket API error: %s", err)
+
+        finally:
+            if client_read:
+                client_read.cancel()
+            if server_read:
+                server_read.cancel()
+
+            # close connections
+            await client.close()
+            await server.close()
+
+        _LOGGER.info("Home-Assistant Websocket API connection is closed")
+        return server

hassio/api/util.py

@@ -17,10 +17,12 @@ _LOGGER = logging.getLogger(__name__)
 
 def json_loads(data):
     """Extract json from string with support for '' and None."""
+    if not data:
+        return {}
     try:
         return json.loads(data)
     except json.JSONDecodeError:
-        return {}
+        raise RuntimeError("Invalid json")
 
 
 def api_process(method):

hassio/const.py

@@ -2,7 +2,7 @@
 from pathlib import Path
 from ipaddress import ip_network
 
-HASSIO_VERSION = '0.75'
+HASSIO_VERSION = '0.78'
 
 URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
                       'hassio/{}/version.json')
@@ -50,11 +50,14 @@ RESULT_OK = 'ok'
 CONTENT_TYPE_BINARY = 'application/octet-stream'
 CONTENT_TYPE_PNG = 'image/png'
 CONTENT_TYPE_JSON = 'application/json'
+CONTENT_TYPE_TEXT = 'text/plain'
 HEADER_HA_ACCESS = 'x-ha-access'
 
 ATTR_WATCHDOG = 'watchdog'
+ATTR_CHANGELOG = 'changelog'
 ATTR_DATE = 'date'
 ATTR_ARCH = 'arch'
+ATTR_LONG_DESCRIPTION = 'long_description'
 ATTR_HOSTNAME = 'hostname'
 ATTR_TIMEZONE = 'timezone'
 ATTR_ARGS = 'args'
@@ -64,6 +67,7 @@ ATTR_SOURCE = 'source'
 ATTR_FEATURES = 'features'
 ATTR_ADDONS = 'addons'
 ATTR_VERSION = 'version'
+ATTR_AUTO_UART = 'auto_uart'
 ATTR_LAST_BOOT = 'last_boot'
 ATTR_LAST_VERSION = 'last_version'
 ATTR_BETA_CHANNEL = 'beta_channel'
@@ -100,6 +104,8 @@ ATTR_BUILD = 'build'
 ATTR_DEVICES = 'devices'
 ATTR_ENVIRONMENT = 'environment'
 ATTR_HOST_NETWORK = 'host_network'
+ATTR_HOST_IPC = 'host_ipc'
+ATTR_HOST_DBUS = 'host_dbus'
 ATTR_NETWORK = 'network'
 ATTR_TMPFS = 'tmpfs'
 ATTR_PRIVILEGED = 'privileged'

hassio/core.py

@@ -42,8 +42,8 @@ class HassIO(object):
         self.scheduler = Scheduler(loop)
         self.api = RestAPI(config, loop)
         self.hardware = Hardware()
-        self.docker = DockerAPI()
-        self.dns = DNSForward()
+        self.docker = DockerAPI(self.hardware)
+        self.dns = DNSForward(loop)
 
         # init basic docker container
         self.supervisor = DockerSupervisor(
@@ -91,6 +91,7 @@ class HassIO(object):
             self.supervisor, self.snapshots, self.addons, self.host_control,
             self.updater)
         self.api.register_homeassistant(self.homeassistant)
+        self.api.register_proxy(self.homeassistant)
         self.api.register_addons(self.addons)
         self.api.register_security()
         self.api.register_snapshots(self.snapshots)

hassio/dns.py

@@ -11,8 +11,9 @@ COMMAND = "socat UDP-RECVFROM:53,fork UDP-SENDTO:127.0.0.11:53"
 class DNSForward(object):
     """Manage DNS forwarding to internal DNS."""
 
-    def __init__(self):
+    def __init__(self, loop):
         """Initialize DNS forwarding."""
+        self.loop = loop
         self.proc = None
 
     async def start(self):
@@ -23,6 +24,7 @@ class DNSForward(object):
                 stdin=asyncio.subprocess.DEVNULL,
                 stdout=asyncio.subprocess.DEVNULL,
                 stderr=asyncio.subprocess.DEVNULL,
+                loop=self.loop
             )
         except OSError as err:
             _LOGGER.error("Can't start DNS forwarding -> %s", err)

hassio/dock/__init__.py

@@ -16,11 +16,12 @@ class DockerAPI(object):
     This class is not AsyncIO safe!
     """
 
-    def __init__(self):
+    def __init__(self, hardware):
         """Initialize docker base wrapper."""
         self.docker = docker.DockerClient(
             base_url="unix:/{}".format(str(SOCKET_DOCKER)), version='auto')
         self.network = DockerNetwork(self.docker)
+        self.hardware = hardware
 
     @property
     def images(self):

hassio/dock/addon.py

@@ -25,6 +25,7 @@ class DockerAddon(DockerInterface):
             config, loop, api, image=addon.image, timeout=addon.timeout)
         self.addon = addon
 
+    # pylint: disable=inconsistent-return-statements
     def process_metadata(self, metadata, force=False):
         """Use addon data instead meta data with legacy."""
         if not self.addon.legacy:
@@ -45,6 +46,13 @@ class DockerAddon(DockerInterface):
         """Return name of docker container."""
         return "addon_{}".format(self.addon.slug)
 
+    @property
+    def ipc(self):
+        """Return the IPC namespace."""
+        if self.addon.host_ipc:
+            return 'host'
+        return None
+
     @property
     def hostname(self):
         """Return slug/id of addon."""
@@ -74,14 +82,17 @@ class DockerAddon(DockerInterface):
         """Return needed devices."""
         devices = self.addon.devices or []
 
-        # use audio devices
+        # Use audio devices
         if self.addon.with_audio and AUDIO_DEVICE not in devices:
             devices.append(AUDIO_DEVICE)
 
+        # Auto mapping UART devices
+        if self.addon.auto_uart:
+            for uart_dev in self.docker.hardware.serial_devices:
+                devices.append("{0}:{0}:rwm".format(uart_dev))
+
         # Return None if no devices is present
-        if devices:
-            return devices
-        return None
+        return devices or None
 
     @property
     def ports(self):
@@ -95,6 +106,18 @@ class DockerAddon(DockerInterface):
             if host_port
         }
 
+    @property
+    def security_opt(self):
+        """Controlling security opt."""
+        privileged = self.addon.privileged or []
+
+        # Disable AppArmor sinse it make troubles wit SYS_ADMIN
+        if 'SYS_ADMIN' in privileged:
+            return [
+                "apparmor:unconfined",
+            ]
+        return None
+
     @property
     def tmpfs(self):
         """Return tmpfs for docker add-on."""
@@ -123,7 +146,7 @@ class DockerAddon(DockerInterface):
         """Generate volumes for mappings."""
         volumes = {
             str(self.addon.path_extern_data): {
-                'bind': '/data', 'mode': 'rw'
+                'bind': "/data", 'mode': 'rw'
             }}
 
         addon_mapping = self.addon.map_volumes
@@ -132,44 +155,51 @@ class DockerAddon(DockerInterface):
         if MAP_CONFIG in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_config): {
-                    'bind': '/config', 'mode': addon_mapping[MAP_CONFIG]
+                    'bind': "/config", 'mode': addon_mapping[MAP_CONFIG]
                 }})
 
         if MAP_SSL in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_ssl): {
-                    'bind': '/ssl', 'mode': addon_mapping[MAP_SSL]
+                    'bind': "/ssl", 'mode': addon_mapping[MAP_SSL]
                 }})
 
         if MAP_ADDONS in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_addons_local): {
-                    'bind': '/addons', 'mode': addon_mapping[MAP_ADDONS]
+                    'bind': "/addons", 'mode': addon_mapping[MAP_ADDONS]
                 }})
 
         if MAP_BACKUP in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_backup): {
-                    'bind': '/backup', 'mode': addon_mapping[MAP_BACKUP]
+                    'bind': "/backup", 'mode': addon_mapping[MAP_BACKUP]
                 }})
 
         if MAP_SHARE in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_share): {
-                    'bind': '/share', 'mode': addon_mapping[MAP_SHARE]
+                    '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/class/gpio": {
+                    'bind': "/sys/class/gpio", 'mode': 'rw'
                 },
-                '/sys/devices/platform/soc': {
-                    'bind': '/sys/devices/platform/soc', 'mode': "rw"
+                "/sys/devices/platform/soc": {
+                    'bind': "/sys/devices/platform/soc", 'mode': 'rw'
                 },
             })
 
+        # host dbus system
+        if self.addon.host_dbus:
+            volumes.update({
+                "/var/run/dbus": {
+                    'bind': "/var/run/dbus", 'mode': 'rw'
+                }})
+
         return volumes
 
     def _run(self):
@@ -193,12 +223,14 @@ class DockerAddon(DockerInterface):
             hostname=self.hostname,
             detach=True,
             init=True,
+            ipc_mode=self.ipc,
             stdin_open=self.addon.with_stdin,
             network_mode=self.network_mode,
             ports=self.ports,
             extra_hosts=self.network_mapping,
             devices=self.devices,
             cap_add=self.addon.privileged,
+            security_opt=self.security_opt,
             environment=self.environment,
             volumes=self.volumes,
             tmpfs=self.tmpfs

hassio/dock/homeassistant.py

@@ -27,7 +27,7 @@ class DockerHomeAssistant(DockerInterface):
     def devices(self):
         """Create list of special device to map into docker."""
         if not self.data.devices:
-            return
+            return None
 
         devices = []
         for device in self.data.devices:
@@ -41,7 +41,7 @@ class DockerHomeAssistant(DockerInterface):
         Need run inside executor.
         """
         if self._is_running():
-            return
+            return False
 
         # cleanup
         self._stop()

hassio/hardware.py

@@ -20,6 +20,7 @@ PROC_STAT = Path("/proc/stat")
 RE_BOOT_TIME = re.compile(r"btime (\d+)")
 
 GPIO_DEVICES = Path("/sys/class/gpio")
+RE_TTY = re.compile(r"tty[A-Z]+")
 
 
 class Hardware(object):
@@ -34,7 +35,7 @@ class Hardware(object):
         """Return all serial and connected devices."""
         dev_list = set()
         for device in self.context.list_devices(subsystem='tty'):
-            if 'ID_VENDOR' in device:
+            if 'ID_VENDOR' in device or RE_TTY.search(device.device_node):
                 dev_list.add(device.device_node)
 
         return dev_list
@@ -69,7 +70,7 @@ class Hardware(object):
                 devices = devices_file.read()
         except OSError as err:
             _LOGGER.error("Can't read asound data -> %s", err)
-            return
+            return None
 
         audio_list = {}
 
@@ -109,12 +110,12 @@ class Hardware(object):
                 stats = stat_file.read()
         except OSError as err:
             _LOGGER.error("Can't read stat data -> %s", err)
-            return
+            return None
 
         # parse stat file
         found = RE_BOOT_TIME.search(stats)
         if not found:
             _LOGGER.error("Can't found last boot time!")
-            return
+            return None
 
         return datetime.utcfromtimestamp(int(found.group(1)))

hassio/validate.py

@@ -29,11 +29,12 @@ def validate_timezone(timezone):
     return timezone
 
 
+# pylint: disable=inconsistent-return-statements
 def convert_to_docker_ports(data):
     """Convert data into docker port list."""
     # dynamic ports
     if data is None:
-        return
+        return None
 
     # single port
     if isinstance(data, int):

setup.py

@@ -24,7 +24,7 @@ setup(
         'Topic :: Scientific/Engineering :: Atmospheric Science',
         'Development Status :: 5 - Production/Stable',
         'Intended Audience :: Developers',
-        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
     ],
     keywords=['docker', 'home-assistant', 'api'],
     zip_safe=False,

version.json

@@ -1,6 +1,6 @@
 {
-    "hassio": "0.75",
-    "homeassistant": "0.57.3",
+    "hassio": "0.78",
+    "homeassistant": "0.60",
     "resinos": "1.1",
     "resinhup": "0.3",
     "generic": "0.3",