Merge pull request #59 from home-assistant/dev

Release 0.29

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "home-assistant-polymer"]
+	path = home-assistant-polymer
+	url = https://github.com/home-assistant/home-assistant-polymer

API.md

@@ -43,7 +43,9 @@ The addons from `addons` are only installed one.
             "repository": "12345678|null",
             "version": "LAST_VERSION",
             "installed": "INSTALL_VERSION",
-            "detached": "bool"
+            "detached": "bool",
+            "build": "bool",
+            "url": "null|url"
         }
     ],
     "addons_repositories": [
@@ -67,7 +69,9 @@ Get all available addons
             "repository": "core|local|REP_ID",
             "version": "LAST_VERSION",
             "installed": "none|INSTALL_VERSION",
-            "detached": "bool"
+            "detached": "bool",
+            "build": "bool",
+            "url": "null|url"
         }
     ],
     "repositories": [
@@ -224,6 +228,7 @@ Output the raw docker log
     "last_version": "LAST_VERSION",
     "state": "started|stopped",
     "boot": "auto|manual",
+    "build": "bool",
     "options": {},
 }
 ```

hassio/addons/__init__.py

@@ -191,7 +191,7 @@ class AddonManager(AddonsData):
             return False
 
         version = version or self.get_last_version(addon)
-        is_running = self.dockers[addon].is_running()
+        is_running = await self.dockers[addon].is_running()
 
         # update
         if await self.dockers[addon].update(version):

hassio/addons/data.py

@@ -3,18 +3,20 @@ import copy
 import logging
 import json
 from pathlib import Path, PurePath
+import re
 
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
 from .util import extract_hash_from_path
 from .validate import (
-    validate_options, SCHEMA_ADDON_CONFIG, SCHEMA_REPOSITORY_CONFIG)
+    validate_options, SCHEMA_ADDON_CONFIG, SCHEMA_REPOSITORY_CONFIG,
+    MAP_VOLUME)
 from ..const import (
     FILE_HASSIO_ADDONS, ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON,
     ATTR_STARTUP, ATTR_BOOT, ATTR_MAP, ATTR_OPTIONS, ATTR_PORTS, BOOT_AUTO,
-    DOCKER_REPO, ATTR_SCHEMA, ATTR_IMAGE, MAP_CONFIG, MAP_SSL, MAP_ADDONS,
-    MAP_BACKUP, ATTR_REPOSITORY, ATTR_URL, ATTR_ARCH, ATTR_LOCATON)
+    ATTR_SCHEMA, ATTR_IMAGE, ATTR_REPOSITORY, ATTR_URL, ATTR_ARCH,
+    ATTR_LOCATON, ATTR_DEVICES, ATTR_ENVIRONMENT)
 from ..config import Config
 from ..tools import read_json_file, write_json_file
 
@@ -26,6 +28,8 @@ USER = 'user'
 REPOSITORY_CORE = 'core'
 REPOSITORY_LOCAL = 'local'
 
+RE_VOLUME = re.compile(MAP_VOLUME)
+
 
 class AddonsData(Config):
     """Hold data for addons inside HassIO."""
@@ -149,12 +153,13 @@ class AddonsData(Config):
         """
         have_change = False
 
-        for addon, data in self._system_data.items():
+        for addon in self.list_installed:
             # detached
             if addon not in self._addons_cache:
                 continue
 
             cache = self._addons_cache[addon]
+            data = self._system_data[addon]
             if data[ATTR_VERSION] == cache[ATTR_VERSION]:
                 if data != cache:
                     self._system_data[addon] = copy.deepcopy(cache)
@@ -166,20 +171,12 @@ class AddonsData(Config):
     @property
     def list_installed(self):
         """Return a list of installed addons."""
-        return set(self._system_data.keys())
+        return set(self._system_data)
 
     @property
-    def data_all(self):
+    def list_all(self):
         """Return a dict of all addons."""
-        return {
-            **self._system_data,
-            **self._addons_cache
-        }
-
-    @property
-    def data_installed(self):
-        """Return a dict of installed addons."""
-        return self._system_data.copy()
+        return set(self._system_data) | set(self._addons_cache)
 
     def list_startup(self, start_type):
         """Get list of installed addon with need start by type."""
@@ -271,35 +268,51 @@ class AddonsData(Config):
 
     def get_name(self, addon):
         """Return name of addon."""
+        if addon in self._addons_cache:
+            return self._addons_cache[addon][ATTR_NAME]
         return self._system_data[addon][ATTR_NAME]
 
     def get_description(self, addon):
         """Return description of addon."""
+        if addon in self._addons_cache:
+            return self._addons_cache[addon][ATTR_DESCRIPTON]
         return self._system_data[addon][ATTR_DESCRIPTON]
 
     def get_repository(self, addon):
         """Return repository of addon."""
+        if addon in self._addons_cache:
+            return self._addons_cache[addon][ATTR_REPOSITORY]
         return self._system_data[addon][ATTR_REPOSITORY]
 
     def get_last_version(self, addon):
         """Return version of addon."""
-        if addon not in self._addons_cache:
-            return self.version_installed(addon)
-        return self._addons_cache[addon][ATTR_VERSION]
+        if addon in self._addons_cache:
+            return self._addons_cache[addon][ATTR_VERSION]
+        return self.version_installed(addon)
 
     def get_ports(self, addon):
         """Return ports of addon."""
         return self._system_data[addon].get(ATTR_PORTS)
 
+    def get_devices(self, addon):
+        """Return devices of addon."""
+        return self._system_data[addon].get(ATTR_DEVICES)
+
+    def get_environment(self, addon):
+        """Return environment of addon."""
+        return self._system_data[addon].get(ATTR_ENVIRONMENT)
+
     def get_url(self, addon):
         """Return url of addon."""
+        if addon in self._addons_cache:
+            return self._addons_cache[addon].get(ATTR_URL)
         return self._system_data[addon].get(ATTR_URL)
 
     def get_arch(self, addon):
         """Return list of supported arch."""
-        if addon not in self._addons_cache:
-            return self._system_data[addon][ATTR_ARCH]
-        return self._addons_cache[addon][ATTR_ARCH]
+        if addon in self._addons_cache:
+            return self._addons_cache[addon][ATTR_ARCH]
+        return self._system_data[addon][ATTR_ARCH]
 
     def get_image(self, addon):
         """Return image name of addon."""
@@ -307,44 +320,29 @@ class AddonsData(Config):
             addon, self._addons_cache.get(addon)
         )
 
-        # core repository
-        if addon_data[ATTR_REPOSITORY] == REPOSITORY_CORE:
-            return "{}/{}-addon-{}".format(
-                DOCKER_REPO, self.arch, addon_data[ATTR_SLUG])
-
         # Repository with dockerhub images
         if ATTR_IMAGE in addon_data:
             return addon_data[ATTR_IMAGE].format(arch=self.arch)
 
-        # Local build addon
-        if addon_data[ATTR_REPOSITORY] == REPOSITORY_LOCAL:
-            return "local/{}-addon-{}".format(self.arch, addon_data[ATTR_SLUG])
-
-        _LOGGER.error("No image for %s", addon)
+        # local build
+        return "{}/{}-addon-{}".format(
+            addon_data[ATTR_REPOSITORY], self.arch, addon_data[ATTR_SLUG])
 
     def need_build(self, addon):
-        """Return True if this addon need a local build."""
+        """Return True if this  addon need a local build."""
         addon_data = self._system_data.get(
             addon, self._addons_cache.get(addon)
         )
-        return addon_data[ATTR_REPOSITORY] == REPOSITORY_LOCAL \
-            and not addon_data.get(ATTR_IMAGE)
+        return ATTR_IMAGE not in addon_data
 
-    def map_config(self, addon):
-        """Return True if config map is needed."""
-        return MAP_CONFIG in self._system_data[addon][ATTR_MAP]
+    def map_volumes(self, addon):
+        """Return a dict of {volume: policy} from addon."""
+        volumes = {}
+        for volume in self._system_data[addon][ATTR_MAP]:
+            result = RE_VOLUME.match(volume)
+            volumes[result.group(1)] = result.group(2) or 'ro'
 
-    def map_ssl(self, addon):
-        """Return True if ssl map is needed."""
-        return MAP_SSL in self._system_data[addon][ATTR_MAP]
-
-    def map_addons(self, addon):
-        """Return True if addons map is needed."""
-        return MAP_ADDONS in self._system_data[addon][ATTR_MAP]
-
-    def map_backup(self, addon):
-        """Return True if backup map is needed."""
-        return MAP_BACKUP in self._system_data[addon][ATTR_MAP]
+        return volumes
 
     def path_data(self, addon):
         """Return addon data path inside supervisor."""

hassio/addons/validate.py

@@ -4,10 +4,13 @@ import voluptuous as vol
 from ..const import (
     ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON, ATTR_STARTUP,
     ATTR_BOOT, ATTR_MAP, ATTR_OPTIONS, ATTR_PORTS, STARTUP_ONCE, STARTUP_AFTER,
-    STARTUP_BEFORE, BOOT_AUTO, BOOT_MANUAL, ATTR_SCHEMA, ATTR_IMAGE, MAP_SSL,
-    MAP_CONFIG, MAP_ADDONS, MAP_BACKUP, ATTR_URL, ATTR_MAINTAINER, ATTR_ARCH,
+    STARTUP_BEFORE, BOOT_AUTO, BOOT_MANUAL, ATTR_SCHEMA, ATTR_IMAGE,
+    ATTR_URL, ATTR_MAINTAINER, ATTR_ARCH, ATTR_DEVICES, ATTR_ENVIRONMENT,
     ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386)
 
+
+MAP_VOLUME = r"^(config|ssl|addons|backup|share|mnt)(?::(rw|:ro))?$"
+
 V_STR = 'str'
 V_INT = 'int'
 V_FLOAT = 'float'
@@ -34,9 +37,9 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Required(ATTR_BOOT):
         vol.In([BOOT_AUTO, BOOT_MANUAL]),
     vol.Optional(ATTR_PORTS): dict,
-    vol.Optional(ATTR_MAP, default=[]): [
-        vol.In([MAP_CONFIG, MAP_SSL, MAP_ADDONS, MAP_BACKUP])
-    ],
+    vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
+    vol.Optional(ATTR_MAP, default=[]): [vol.Match(MAP_VOLUME)],
+    vol.Optional(ATTR_ENVIRONMENT): {vol.Match(r"\w*"): vol.Coerce(str)},
     vol.Required(ATTR_OPTIONS): dict,
     vol.Required(ATTR_SCHEMA): {
         vol.Coerce(str): vol.Any(ADDON_ELEMENT, [
@@ -70,10 +73,10 @@ def validate_options(raw_schema):
             try:
                 if isinstance(typ, list):
                     # nested value
-                    options[key] = _nested_validate(typ[0], value)
+                    options[key] = _nested_validate(typ[0], value, key)
                 else:
                     # normal value
-                    options[key] = _single_validate(typ, value)
+                    options[key] = _single_validate(typ, value, key)
             except (IndexError, KeyError):
                 raise vol.Invalid(
                     "Type error for {}.".format(key)) from None
@@ -84,12 +87,12 @@ def validate_options(raw_schema):
 
 
 # pylint: disable=no-value-for-parameter
-def _single_validate(typ, value):
+def _single_validate(typ, value, key):
     """Validate a single element."""
     try:
         # if required argument
         if value is None:
-            raise vol.Invalid("A required argument is not set!")
+            raise vol.Invalid("Missing required option '{}'.".format(key))
 
         if typ == V_STR:
             return str(value)
@@ -104,13 +107,13 @@ def _single_validate(typ, value):
         elif typ == V_URL:
             return vol.Url()(value)
 
-        raise vol.Invalid("Fatal error for {}.".format(value))
+        raise vol.Invalid("Fatal error for {} type {}.".format(key, typ))
     except ValueError:
         raise vol.Invalid(
-            "Type {} error for {}.".format(typ, value)) from None
+            "Type {} error for '{}' on {}.".format(typ, value, key)) from None
 
 
-def _nested_validate(typ, data_list):
+def _nested_validate(typ, data_list, key):
     """Validate nested items."""
     options = []
 
@@ -123,10 +126,10 @@ def _nested_validate(typ, data_list):
                     raise vol.Invalid(
                         "Unknown nested options {}.".format(c_key))
 
-                c_options[c_key] = _single_validate(typ[c_key], c_value)
+                c_options[c_key] = _single_validate(typ[c_key], c_value, c_key)
             options.append(c_options)
         # normal list
         else:
-            options.append(_single_validate(typ, element))
+            options.append(_single_validate(typ, element, key))
 
     return options

hassio/api/__init__.py

@@ -1,5 +1,6 @@
 """Init file for HassIO rest api."""
 import logging
+from pathlib import Path
 
 from aiohttp import web
 
@@ -96,6 +97,13 @@ class RestAPI(object):
         self.webapp.router.add_post('/security/totp', api_security.totp)
         self.webapp.router.add_post('/security/session', api_security.session)
 
+    def register_panel(self):
+        """Register panel for homeassistant."""
+        panel_dir = Path(__file__).parents[1].joinpath('panel')
+
+        self.webapp.router.register_resource(
+            web.StaticResource('/panel', str(panel_dir)))
+
     async def start(self):
         """Run rest api webserver."""
         self._handler = self.webapp.make_handler(loop=self.loop)

hassio/api/addons.py

@@ -9,7 +9,7 @@ from .util import api_process, api_process_raw, api_validate
 from ..const import (
     ATTR_VERSION, ATTR_LAST_VERSION, ATTR_STATE, ATTR_BOOT, ATTR_OPTIONS,
     ATTR_URL, ATTR_DESCRIPTON, ATTR_DETACHED, ATTR_NAME, ATTR_REPOSITORY,
-    STATE_STOPPED, STATE_STARTED, BOOT_AUTO, BOOT_MANUAL)
+    ATTR_BUILD, STATE_STOPPED, STATE_STARTED, BOOT_AUTO, BOOT_MANUAL)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -59,6 +59,7 @@ class APIAddons(object):
             ATTR_OPTIONS: self.addons.get_options(addon),
             ATTR_URL: self.addons.get_url(addon),
             ATTR_DETACHED: addon in self.addons.list_detached,
+            ATTR_BUILD: self.addons.need_build(addon),
         }
 
     @api_process

hassio/api/supervisor.py

@@ -10,7 +10,8 @@ from ..const import (
     ATTR_ADDONS, ATTR_VERSION, ATTR_LAST_VERSION, ATTR_BETA_CHANNEL,
     HASSIO_VERSION, ATTR_ADDONS_REPOSITORIES, ATTR_REPOSITORIES,
     ATTR_REPOSITORY, ATTR_DESCRIPTON, ATTR_NAME, ATTR_SLUG, ATTR_INSTALLED,
-    ATTR_DETACHED, ATTR_SOURCE, ATTR_MAINTAINER, ATTR_URL, ATTR_ARCH)
+    ATTR_DETACHED, ATTR_SOURCE, ATTR_MAINTAINER, ATTR_URL, ATTR_ARCH,
+    ATTR_BUILD)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,23 +42,23 @@ class APISupervisor(object):
         detached = self.addons.list_detached
 
         if only_installed:
-            addons = self.addons.data_installed
+            addons = self.addons.list_installed
         else:
-            addons = self.addons.data_all
+            addons = self.addons.list_all
 
         data = []
-        for addon, values in addons.items():
-            i_version = self.addons.version_installed(addon)
-
+        for addon in addons:
             data.append({
-                ATTR_NAME: values[ATTR_NAME],
+                ATTR_NAME: self.addons.get_name(addon),
                 ATTR_SLUG: addon,
-                ATTR_DESCRIPTON: values[ATTR_DESCRIPTON],
-                ATTR_VERSION: values[ATTR_VERSION],
-                ATTR_INSTALLED: i_version,
-                ATTR_ARCH: values[ATTR_ARCH],
+                ATTR_DESCRIPTON: self.addons.get_description(addon),
+                ATTR_VERSION: self.addons.get_last_version(addon),
+                ATTR_INSTALLED: self.addons.version_installed(addon),
+                ATTR_ARCH: self.addons.get_arch(addon),
                 ATTR_DETACHED: addon in detached,
-                ATTR_REPOSITORY: values[ATTR_REPOSITORY],
+                ATTR_REPOSITORY: self.addons.get_repository(addon),
+                ATTR_BUILD: self.addons.need_build(addon),
+                ATTR_URL: self.addons.get_url(addon),
             })
 
         return data

hassio/bootstrap.py

@@ -21,24 +21,24 @@ def initialize_system_data(websession):
             "Create Home-Assistant config folder %s", config.path_config)
         config.path_config.mkdir()
 
-    # homeassistant ssl folder
+    # hassio ssl folder
     if not config.path_ssl.is_dir():
-        _LOGGER.info("Create Home-Assistant ssl folder %s", config.path_ssl)
+        _LOGGER.info("Create hassio ssl folder %s", config.path_ssl)
         config.path_ssl.mkdir()
 
-    # homeassistant addon data folder
+    # hassio addon data folder
     if not config.path_addons_data.is_dir():
-        _LOGGER.info("Create Home-Assistant addon data folder %s",
-                     config.path_addons_data)
+        _LOGGER.info(
+            "Create hassio addon data folder %s", config.path_addons_data)
         config.path_addons_data.mkdir(parents=True)
 
     if not config.path_addons_local.is_dir():
-        _LOGGER.info("Create Home-Assistant addon local repository folder %s",
+        _LOGGER.info("Create hassio addon local repository folder %s",
                      config.path_addons_local)
         config.path_addons_local.mkdir(parents=True)
 
     if not config.path_addons_git.is_dir():
-        _LOGGER.info("Create Home-Assistant addon git repositories folder %s",
+        _LOGGER.info("Create hassio addon git repositories folder %s",
                      config.path_addons_git)
         config.path_addons_git.mkdir(parents=True)
 
@@ -47,12 +47,16 @@ def initialize_system_data(websession):
                      config.path_addons_build)
         config.path_addons_build.mkdir(parents=True)
 
-    # homeassistant backup folder
+    # hassio backup folder
     if not config.path_backup.is_dir():
-        _LOGGER.info("Create Home-Assistant backup folder %s",
-                     config.path_backup)
+        _LOGGER.info("Create hassio backup folder %s", config.path_backup)
         config.path_backup.mkdir()
 
+    # share folder
+    if not config.path_share.is_dir():
+        _LOGGER.info("Create hassio share folder %s", config.path_share)
+        config.path_share.mkdir()
+
     return config
 
 

hassio/config.py

@@ -32,6 +32,8 @@ ADDONS_CUSTOM_LIST = 'addons_custom_list'
 
 BACKUP_DATA = PurePath("backup")
 
+SHARE_DATA = PurePath("share")
+
 UPSTREAM_BETA = 'upstream_beta'
 
 API_ENDPOINT = 'api_endpoint'
@@ -233,6 +235,16 @@ class CoreConfig(Config):
         """Return root backup data folder extern for docker."""
         return PurePath(self.path_extern_hassio, BACKUP_DATA)
 
+    @property
+    def path_share(self):
+        """Return root share data folder."""
+        return Path(HASSIO_SHARE, SHARE_DATA)
+
+    @property
+    def path_extern_share(self):
+        """Return root share data folder extern for docker."""
+        return PurePath(self.path_extern_hassio, SHARE_DATA)
+
     @property
     def addons_repositories(self):
         """Return list of addons custom repositories."""

hassio/const.py

@@ -1,7 +1,7 @@
 """Const file for HassIO."""
 from pathlib import Path
 
-HASSIO_VERSION = '0.24'
+HASSIO_VERSION = '0.29'
 
 URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
                       'hassio/master/version.json')
@@ -10,8 +10,6 @@ URL_HASSIO_VERSION_BETA = ('https://raw.githubusercontent.com/home-assistant/'
 
 URL_HASSIO_ADDONS = 'https://github.com/home-assistant/hassio-addons'
 
-DOCKER_REPO = "homeassistant"
-
 HASSIO_SHARE = Path("/data")
 
 RUN_UPDATE_INFO_TASKS = 28800
@@ -28,6 +26,14 @@ FILE_HASSIO_CONFIG = Path(HASSIO_SHARE, "config.json")
 SOCKET_DOCKER = Path("/var/run/docker.sock")
 SOCKET_HC = Path("/var/run/hassio-hc.sock")
 
+LABEL_VERSION = 'io.hass.version'
+LABEL_ARCH = 'io.hass.arch'
+LABEL_TYPE = 'io.hass.type'
+
+META_ADDON = 'addon'
+META_SUPERVISOR = 'supervisor'
+META_HOMEASSISTANT = 'homeassistant'
+
 JSON_RESULT = 'result'
 JSON_DATA = 'data'
 JSON_MESSAGE = 'message'
@@ -68,6 +74,9 @@ ATTR_TOTP = 'totp'
 ATTR_INITIALIZE = 'initialize'
 ATTR_SESSION = 'session'
 ATTR_LOCATON = 'location'
+ATTR_BUILD = 'build'
+ATTR_DEVICES = 'devices'
+ATTR_ENVIRONMENT = 'environment'
 
 STARTUP_BEFORE = 'before'
 STARTUP_AFTER = 'after'
@@ -83,6 +92,8 @@ MAP_CONFIG = 'config'
 MAP_SSL = 'ssl'
 MAP_ADDONS = 'addons'
 MAP_BACKUP = 'backup'
+MAP_SHARE = 'share'
+MAP_MNT = 'mnt'
 
 ARCH_ARMHF = 'armhf'
 ARCH_AARCH64 = 'aarch64'

hassio/core.py

@@ -74,6 +74,7 @@ class HassIO(object):
         self.api.register_homeassistant(self.homeassistant)
         self.api.register_addons(self.addons)
         self.api.register_security()
+        self.api.register_panel()
 
         # schedule api session cleanup
         self.scheduler.register_task(

hassio/dock/__init__.py

@@ -5,6 +5,7 @@ import logging
 
 import docker
 
+from ..const import LABEL_VERSION
 from ..tools import get_version_from_env
 
 _LOGGER = logging.getLogger(__name__)
@@ -33,6 +34,19 @@ class DockerBase(object):
         """Return True if a task is in progress."""
         return self._lock.locked()
 
+    def process_metadata(self, metadata=None, force=False):
+        """Read metadata and set it to object."""
+        if not force and self.version:
+            return
+
+        # read metadata
+        metadata = metadata or self.container.attrs
+        if LABEL_VERSION in metadata['Config']['Labels']:
+            self.version = metadata['Config']['Labels'][LABEL_VERSION]
+        else:
+            # dedicated
+            self.version = get_version_from_env(metadata['Config']['Env'])
+
     async def install(self, tag):
         """Pull docker image."""
         if self._lock.locked():
@@ -52,12 +66,12 @@ class DockerBase(object):
             image = self.dock.images.pull("{}:{}".format(self.image, tag))
 
             image.tag(self.image, tag='latest')
-            self.version = get_version_from_env(image.attrs['Config']['Env'])
-            _LOGGER.info("Tag image %s with version %s as latest",
-                         self.image, self.version)
+            self.process_metadata(metadata=image.attrs, force=True)
         except docker.errors.APIError as err:
             _LOGGER.error("Can't install %s:%s -> %s.", self.image, tag, err)
             return False
+
+        _LOGGER.info("Tag image %s with version %s as latest", self.image, tag)
         return True
 
     def exists(self):
@@ -74,7 +88,7 @@ class DockerBase(object):
         """
         try:
             image = self.dock.images.get(self.image)
-            self.version = get_version_from_env(image.attrs['Config']['Env'])
+            self.process_metadata(metadata=image.attrs)
         except docker.errors.DockerException:
             return False
 
@@ -95,8 +109,7 @@ class DockerBase(object):
         if not self.container:
             try:
                 self.container = self.dock.containers.get(self.docker_name)
-                self.version = get_version_from_env(
-                    self.container.attrs['Config']['Env'])
+                self.process_metadata()
             except docker.errors.DockerException:
                 return False
         else:
@@ -121,8 +134,7 @@ class DockerBase(object):
         try:
             self.container = self.dock.containers.get(self.docker_name)
             self.image = self.container.attrs['Config']['Image']
-            self.version = get_version_from_env(
-                self.container.attrs['Config']['Env'])
+            self.process_metadata()
             _LOGGER.info("Attach to image %s with version %s",
                          self.image, self.version)
         except (docker.errors.DockerException, KeyError):
@@ -199,12 +211,14 @@ class DockerBase(object):
                      self.image, self.version)
 
         try:
-            self.dock.images.remove(
-                image="{}:latest".format(self.image), force=True)
-            self.dock.images.remove(
-                image="{}:{}".format(self.image, self.version), force=True)
-        except docker.errors.ImageNotFound:
-            return True
+            with suppress(docker.errors.ImageNotFound):
+                self.dock.images.remove(
+                    image="{}:latest".format(self.image), force=True)
+
+            with suppress(docker.errors.ImageNotFound):
+                self.dock.images.remove(
+                    image="{}:{}".format(self.image, self.version), force=True)
+
         except docker.errors.DockerException as err:
             _LOGGER.warning("Can't remove image %s -> %s", self.image, err)
             return False

hassio/dock/addon.py

@@ -7,7 +7,9 @@ import docker
 
 from . import DockerBase
 from .util import dockerfile_template
-from ..tools import get_version_from_env
+from ..const import (
+    META_ADDON, MAP_CONFIG, MAP_SSL, MAP_ADDONS, MAP_BACKUP, MAP_SHARE,
+    MAP_MNT)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -35,28 +37,42 @@ class DockerAddon(DockerBase):
                 'bind': '/data', 'mode': 'rw'
             }}
 
-        if self.addons_data.map_config(self.addon):
+        addon_mapping = self.addons_data.map_volumes(self.addon)
+
+        if MAP_CONFIG in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_config): {
-                    'bind': '/config', 'mode': 'rw'
+                    'bind': '/config', 'mode': addon_mapping[MAP_CONFIG]
                 }})
 
-        if self.addons_data.map_ssl(self.addon):
+        if MAP_SSL in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_ssl): {
-                    'bind': '/ssl', 'mode': 'rw'
+                    'bind': '/ssl', 'mode': addon_mapping[MAP_SSL]
                 }})
 
-        if self.addons_data.map_addons(self.addon):
+        if MAP_ADDONS in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_addons_local): {
-                    'bind': '/addons', 'mode': 'rw'
+                    'bind': '/addons', 'mode': addon_mapping[MAP_ADDONS]
                 }})
 
-        if self.addons_data.map_backup(self.addon):
+        if MAP_BACKUP in addon_mapping:
             volumes.update({
                 str(self.config.path_extern_backup): {
-                    'bind': '/backup', 'mode': 'rw'
+                    '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]
+                }})
+
+        if MAP_MNT in addon_mapping:
+            volumes.update({
+                '/mnt': {
+                    'bind': '/mnt', 'mode': addon_mapping[MAP_MNT]
                 }})
 
         return volumes
@@ -79,12 +95,12 @@ class DockerAddon(DockerBase):
                 detach=True,
                 network_mode='bridge',
                 ports=self.addons_data.get_ports(self.addon),
+                devices=self.addons_data.get_devices(self.addon),
+                environment=self.addons_data.get_environment(self.addon),
                 volumes=self.volumes,
             )
 
-            self.version = get_version_from_env(
-                self.container.attrs['Config']['Env'])
-
+            self.process_metadata()
             _LOGGER.info("Start docker addon %s with version %s",
                          self.image, self.version)
 
@@ -99,16 +115,27 @@ class DockerAddon(DockerBase):
 
         Need run inside executor.
         """
+        # read container
         try:
             self.container = self.dock.containers.get(self.docker_name)
-            self.version = get_version_from_env(
-                self.container.attrs['Config']['Env'])
+            self.process_metadata()
 
-            _LOGGER.info(
-                "Attach to image %s with version %s", self.image, self.version)
+            _LOGGER.info("Attach to container %s with version %s",
+                         self.image, self.version)
+            return
         except (docker.errors.DockerException, KeyError):
             pass
 
+        # read image
+        try:
+            image = self.dock.images.get(self.image)
+            self.process_metadata(metadata=image.attrs)
+
+            _LOGGER.info("Attach to image %s with version %s",
+                         self.image, self.version)
+        except (docker.errors.DockerException, KeyError):
+            _LOGGER.error("No container/image found for %s", self.image)
+
     def _install(self, tag):
         """Pull docker image or build it.
 
@@ -147,7 +174,8 @@ class DockerAddon(DockerBase):
             # prepare Dockerfile
             try:
                 dockerfile_template(
-                    Path(build_dir, 'Dockerfile'), self.addons_data.arch, tag)
+                    Path(build_dir, 'Dockerfile'), self.addons_data.arch,
+                    tag, META_ADDON)
             except OSError as err:
                 _LOGGER.error("Can't prepare dockerfile -> %s", err)
 
@@ -159,12 +187,14 @@ class DockerAddon(DockerBase):
                 image = self.dock.images.build(
                     path=str(build_dir), tag=build_tag, pull=True)
 
-                _LOGGER.info("Build %s done", build_tag)
                 image.tag(self.image, tag='latest')
+                self.process_metadata(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:

hassio/dock/homeassistant.py

@@ -4,7 +4,6 @@ import logging
 import docker
 
 from . import DockerBase
-from ..tools import get_version_from_env
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -48,11 +47,12 @@ class DockerHomeAssistant(DockerBase):
                     str(self.config.path_extern_config):
                         {'bind': '/config', 'mode': 'rw'},
                     str(self.config.path_extern_ssl):
-                        {'bind': '/ssl', 'mode': 'rw'},
+                        {'bind': '/ssl', 'mode': 'ro'},
+                    str(self.config.path_extern_share):
+                        {'bind': '/share', 'mode': 'rw'},
                 })
 
-            self.version = get_version_from_env(
-                self.container.attrs['Config']['Env'])
+            self.process_metadata()
 
             _LOGGER.info("Start docker addon %s with version %s",
                          self.image, self.version)

hassio/dock/util.py

@@ -11,11 +11,10 @@ RESIN_BASE_IMAGE = {
     ARCH_AMD64: "resin/amd64-alpine:3.5",
 }
 
-TMPL_VERSION = re.compile(r"%%VERSION%%")
 TMPL_IMAGE = re.compile(r"%%BASE_IMAGE%%")
 
 
-def dockerfile_template(dockerfile, arch, version):
+def dockerfile_template(dockerfile, arch, version, meta_type):
     """Prepare a Hass.IO dockerfile."""
     buff = []
     resin_image = RESIN_BASE_IMAGE[arch]
@@ -23,10 +22,19 @@ def dockerfile_template(dockerfile, arch, version):
     # read docker
     with dockerfile.open('r') as dock_input:
         for line in dock_input:
-            line = TMPL_VERSION.sub(version, line)
             line = TMPL_IMAGE.sub(resin_image, 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)

version.json

@@ -1,5 +1,5 @@
 {
-    "hassio": "0.24",
+    "hassio": "0.29",
     "homeassistant": "0.44.2",
     "resinos": "0.7",
     "resinhup": "0.1",