Change handling of addon config (#12)

Add an optional extended description…

API.md

@@ -37,6 +37,7 @@ On success
             "slug": "xy",
             "version": "CURRENT_VERSION",
             "installed": "none|INSTALL_VERSION",
+            "dedicated": "bool",
             "description": "description"
         }
     ]
@@ -62,6 +63,10 @@ Optional:
 
 Reload addons/version.
 
+- `/supervisor/logs`
+
+Output the raw docker log
+
 ### Host
 
 - `/host/shutdown`
@@ -123,6 +128,10 @@ Optional:
 }
 ```
 
+- `/homeassistant/logs`
+
+Output the raw docker log
+
 ### REST API addons
 
 - `/addons/{addon}/info`
@@ -138,7 +147,10 @@ Optional:
 
 - `/addons/{addon}/options`
 ```json
-{ }
+{
+    "boot": "auto|manual",
+    "options": {}, 
+}
 ```
 
 - `/addons/{addon}/start`
@@ -163,6 +175,10 @@ Optional:
 }
 ```
 
+- `/addons/{addon}/logs`
+
+Output the raw docker log
+
 ## Host Controll
 
 Communicate over unix socket with a host daemon.

README.md

@@ -5,9 +5,10 @@ It is a docker image (supervisor) they manage HomeAssistant docker and give a in
 
 [HassIO-Addons](https://github.com/pvizeli/hassio-addons) | [HassIO-Build](https://github.com/pvizeli/hassio-build)
 
+**HassIO is at the moment on development and not ready to use productive!**
+
 ## Feature in progress
 - Backup/Restore
-- Read docker logs and extend to api
 - MQTT addon
 - DHCP-Server addon
 
@@ -48,3 +49,8 @@ Read logoutput from supervisor:
 journalctl -f -u resin-supervisor.service
 docker logs homeassistant
 ```
+
+## Install on a own System
+
+We have a installer to install HassIO on own linux device without our hardware image:
+https://github.com/pvizeli/hassio-build/tree/master/install

hassio/addons/__init__.py

@@ -36,6 +36,7 @@ class AddonManager(AddonsData):
         for addon in self.list_installed:
             self.dockers[addon] = DockerAddon(
                 self.config, self.loop, self.dock, self, addon)
+            await self.dockers[addon].attach()
 
     async def reload(self):
         """Update addons from repo and reload list."""
@@ -44,13 +45,8 @@ class AddonManager(AddonsData):
         self.read_addons_repo()
 
         # remove stalled addons
-        tasks = []
         for addon in self.list_removed:
-            _LOGGER.info("Old addon %s found")
-            tasks.append(self.loop.create_task(self.uninstall(addon)))
-
-        if tasks:
-            await asyncio.wait(tasks, loop=self.loop)
+            _LOGGER.warning("Dedicated addon '%s' found!", addon)
 
     async def auto_boot(self, start_type):
         """Boot addons with mode auto."""
@@ -87,7 +83,7 @@ class AddonManager(AddonsData):
             return False
 
         self.dockers[addon] = addon_docker
-        self.set_install_addon(addon, version)
+        self.set_addon_install(addon, version)
         return True
 
     async def uninstall(self, addon):
@@ -109,7 +105,7 @@ class AddonManager(AddonsData):
             shutil.rmtree(self.path_data(addon))
 
         self.dockers.pop(addon)
-        self.set_uninstall_addon(addon)
+        self.set_addon_uninstall(addon)
         return True
 
     async def state(self, addon):
@@ -144,16 +140,25 @@ class AddonManager(AddonsData):
 
     async def update(self, addon, version=None):
         """Update addon."""
-        if not self.is_installed(addon):
-            _LOGGER.error("Addon %s is not installed", addon)
-            return False
-
         if addon not in self.dockers:
             _LOGGER.error("No docker found for addon %s", addon)
             return False
 
         version = version or self.get_version(addon)
+        is_running = self.dockers[addon].is_running()
+
+        # update
         if await self.dockers[addon].update(version):
-            self.set_version(addon, version)
+            self.set_addon_update(addon, version)
+            if is_running:
+                await self.start(addon)
             return True
         return False
+
+    async def logs(self, addon):
+        """Return addons log output."""
+        if addon not in self.dockers:
+            _LOGGER.error("No docker found for addon %s", addon)
+            return False
+
+        return await self.dockers[addon].logs()

hassio/addons/data.py

@@ -10,13 +10,15 @@ from ..const import (
     FILE_HASSIO_ADDONS, ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON,
     ATTR_STARTUP, ATTR_BOOT, ATTR_MAP_SSL, ATTR_MAP_CONFIG, ATTR_OPTIONS,
     ATTR_PORTS, BOOT_AUTO, DOCKER_REPO, ATTR_INSTALLED, ATTR_SCHEMA,
-    ATTR_IMAGE)
+    ATTR_IMAGE, ATTR_DEDICATED)
 from ..config import Config
 from ..tools import read_json_file, write_json_file
 
 _LOGGER = logging.getLogger(__name__)
 
 ADDONS_REPO_PATTERN = "{}/*/config.json"
+SYSTEM = "system"
+USER = "user"
 
 
 class AddonsData(Config):
@@ -26,12 +28,22 @@ class AddonsData(Config):
         """Initialize data holder."""
         super().__init__(FILE_HASSIO_ADDONS)
         self.config = config
-        self._addons_data = {}
+        self._addons_data = self._data.get(SYSTEM, {})
+        self._user_data = self._data.get(USER, {})
+        self._current_data = {}
         self.arch = None
 
+    def save(self):
+        """Store data to config file."""
+        self._data = {
+            USER: self._user_data,
+            SYSTEM: self._addons_data,
+        }
+        super().save()
+
     def read_addons_repo(self):
         """Read data from addons repository."""
-        self._addons_data = {}
+        self._current_data = {}
 
         self._read_addons_folder(self.config.path_addons_repo)
         self._read_addons_folder(self.config.path_addons_custom)
@@ -45,7 +57,7 @@ class AddonsData(Config):
                 addon_config = read_json_file(addon)
 
                 addon_config = SCHEMA_ADDON_CONFIG(addon_config)
-                self._addons_data[addon_config[ATTR_SLUG]] = addon_config
+                self._current_data[addon_config[ATTR_SLUG]] = addon_config
 
             except (OSError, KeyError):
                 _LOGGER.warning("Can't read %s", addon)
@@ -57,24 +69,25 @@ class AddonsData(Config):
     @property
     def list_installed(self):
         """Return a list of installed addons."""
-        return set(self._data.keys())
-
-    @property
-    def list_all(self):
-        """Return a list of available addons."""
         return set(self._addons_data.keys())
 
     @property
     def list(self):
         """Return a list of available addons."""
         data = []
-        for addon, values in self._addons_data.items():
+        all_addons = {**self._addons_data, **self._current_data}
+        dedicated = self.list_removed
+
+        for addon, values in all_addons.items():
+            i_version = self._addons_data.get(addon, {}).get(ATTR_VERSION)
+
             data.append({
                 ATTR_NAME: values[ATTR_NAME],
                 ATTR_SLUG: values[ATTR_SLUG],
                 ATTR_DESCRIPTON: values[ATTR_DESCRIPTON],
                 ATTR_VERSION: values[ATTR_VERSION],
-                ATTR_INSTALLED: self._data.get(addon, {}).get(ATTR_VERSION),
+                ATTR_INSTALLED: i_version,
+                ATTR_DEDICATED: addon in dedicated,
             })
 
         return data
@@ -82,7 +95,7 @@ class AddonsData(Config):
     def list_startup(self, start_type):
         """Get list of installed addon with need start by type."""
         addon_list = set()
-        for addon in self._data.keys():
+        for addon in self._addons_data.keys():
             if self.get_boot(addon) != BOOT_AUTO:
                 continue
 
@@ -99,58 +112,64 @@ class AddonsData(Config):
     def list_removed(self):
         """Return local addons they not support from repo."""
         addon_list = set()
-        for addon in self._data.keys():
-            if addon not in self._addons_data:
+        for addon in self._addons_data.keys():
+            if addon not in self._current_data:
                 addon_list.add(addon)
 
         return addon_list
 
     def exists_addon(self, addon):
         """Return True if a addon exists."""
-        return addon in self._addons_data
+        return addon in self._current_data or addon in self._addons_data
 
     def is_installed(self, addon):
         """Return True if a addon is installed."""
-        return addon in self._data
+        return addon in self._addons_data
 
     def version_installed(self, addon):
         """Return installed version."""
-        return self._data[addon][ATTR_VERSION]
+        return self._addons_data[addon][ATTR_VERSION]
 
-    def set_install_addon(self, addon, version):
+    def set_addon_install(self, addon, version):
         """Set addon as installed."""
-        self._data[addon] = {
-            ATTR_VERSION: version,
-            ATTR_OPTIONS: {}
+        self._addons_data[addon] = self._current_data[addon]
+        self._user_data[addon] = {
+            ATTR_OPTIONS: {},
         }
         self.save()
 
-    def set_uninstall_addon(self, addon):
+    def set_addon_uninstall(self, addon):
         """Set addon as uninstalled."""
-        self._data.pop(addon, None)
+        self._addons_data.pop(addon, None)
+        self._user_data.pop(addon, None)
+        self.save()
+
+    def set_addon_update(self, addon, version):
+        """Update version of addon."""
+        self._addons_data[addon] = self._current_data[addon]
         self.save()
 
     def set_options(self, addon, options):
         """Store user addon options."""
-        self._data[addon][ATTR_OPTIONS] = options
+        self._user_data[addon][ATTR_OPTIONS] = options
         self.save()
 
-    def set_version(self, addon, version):
-        """Update version of addon."""
-        self._data[addon][ATTR_VERSION] = version
+    def set_boot(self, addon, boot):
+        """Store user boot options."""
+        self._user_data[addon][ATTR_BOOT] = boot
         self.save()
 
     def get_options(self, addon):
         """Return options with local changes."""
-        opt = self._addons_data[addon][ATTR_OPTIONS]
-        if addon in self._data:
-            opt.update(self._data[addon][ATTR_OPTIONS])
-        return opt
+        return {
+            **self._addons_data[addon][ATTR_OPTIONS],
+            **self._user_data[addon][ATTR_OPTIONS],
+        }
 
     def get_boot(self, addon):
         """Return boot config with prio local settings."""
-        if ATTR_BOOT in self._data[addon]:
-            return self._data[addon][ATTR_BOOT]
+        if ATTR_BOOT in self._user_data[addon]:
+            return self._user_data[addon][ATTR_BOOT]
 
         return self._addons_data[addon][ATTR_BOOT]
 
@@ -164,11 +183,9 @@ class AddonsData(Config):
 
     def get_version(self, addon):
         """Return version of addon."""
-        return self._addons_data[addon][ATTR_VERSION]
-
-    def get_slug(self, addon):
-        """Return slug of addon."""
-        return self._addons_data[addon][ATTR_SLUG]
+        if addon not in self._current_data:
+            return self.version_installed(addon)
+        return self._current_data[addon][ATTR_VERSION]
 
     def get_ports(self, addon):
         """Return ports of addon."""
@@ -176,11 +193,12 @@ class AddonsData(Config):
 
     def get_image(self, addon):
         """Return image name of addon."""
-        if ATTR_IMAGE not in self._addons_data[addon]:
-            return "{}/{}-addon-{}".format(
-                DOCKER_REPO, self.arch, self.get_slug(addon))
+        addon_data = self._addons_data.get(addon, self._current_data[addon])
 
-        return self._addons_data[addon][ATTR_IMAGE]
+        if ATTR_IMAGE not in addon_data:
+            return "{}/{}-addon-{}".format(DOCKER_REPO, self.arch, addon)
+
+        return addon_data[ATTR_IMAGE]
 
     def need_config(self, addon):
         """Return True if config map is needed."""
@@ -192,13 +210,11 @@ class AddonsData(Config):
 
     def path_data(self, addon):
         """Return addon data path inside supervisor."""
-        return "{}/{}".format(
-            self.config.path_addons_data, self._addons_data[addon][ATTR_SLUG])
+        return "{}/{}".format(self.config.path_addons_data, addon)
 
     def path_data_docker(self, addon):
         """Return addon data path external for docker."""
-        return "{}/{}".format(self.config.path_addons_data_docker,
-                              self._addons_data[addon][ATTR_SLUG])
+        return "{}/{}".format(self.config.path_addons_data_docker, addon)
 
     def path_addon_options(self, addon):
         """Return path to addons options."""

hassio/api/__init__.py

@@ -52,6 +52,7 @@ class RestAPI(object):
         self.webapp.router.add_get('/supervisor/reload', api_supervisor.reload)
         self.webapp.router.add_get(
             '/supervisor/options', api_supervisor.options)
+        self.webapp.router.add_get('/supervisor/logs', api_supervisor.logs)
 
     def register_homeassistant(self, dock_homeassistant):
         """Register homeassistant function."""
@@ -59,6 +60,7 @@ class RestAPI(object):
 
         self.webapp.router.add_get('/homeassistant/info', api_hass.info)
         self.webapp.router.add_get('/homeassistant/update', api_hass.update)
+        self.webapp.router.add_get('/homeassistant/logs', api_hass.logs)
 
     def register_addons(self, addons):
         """Register homeassistant function."""
@@ -74,6 +76,7 @@ class RestAPI(object):
         self.webapp.router.add_get('/addons/{addon}/update', api_addons.update)
         self.webapp.router.add_get(
             '/addons/{addon}/options', api_addons.options)
+        self.webapp.router.add_get('/addons/{addon}/logs', api_addons.logs)
 
     async def start(self):
         """Run rest api webserver."""

hassio/api/addons.py

@@ -5,10 +5,10 @@ import logging
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
-from .util import api_process, api_validate
+from .util import api_process, api_process_raw, api_validate
 from ..const import (
     ATTR_VERSION, ATTR_CURRENT, ATTR_STATE, ATTR_BOOT, ATTR_OPTIONS,
-    STATE_STOPPED, STATE_STARTED)
+    STATE_STOPPED, STATE_STARTED, BOOT_AUTO, BOOT_MANUAL)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -16,6 +16,10 @@ SCHEMA_VERSION = vol.Schema({
     vol.Optional(ATTR_VERSION): vol.Coerce(str),
 })
 
+SCHEMA_OPTIONS = vol.Schema({
+    vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL])
+})
+
 
 class APIAddons(object):
     """Handle rest api for addons functions."""
@@ -56,10 +60,19 @@ class APIAddons(object):
     async def options(self, request):
         """Store user options for addon."""
         addon = self._extract_addon(request)
-        schema = self.addons.get_schema(addon)
+        options_schema = self.addons.get_schema(addon)
+
+        addon_schema = SCHEMA_OPTIONS.extend({
+            vol.Optional(ATTR_OPTIONS): options_schema,
+        })
+
+        addon_config = await api_validate(addon_schema, request)
+
+        if ATTR_OPTIONS in addon_config:
+            self.addons.set_options(addon, addon_config[ATTR_OPTIONS])
+        if ATTR_BOOT in addon_config:
+            self.addons.set_options(addon, addon_config[ATTR_BOOT])
 
-        options = await api_validate(schema, request)
-        self.addons.set_options(addon, options)
         return True
 
     @api_process
@@ -124,3 +137,9 @@ class APIAddons(object):
 
         return await asyncio.shield(
             self.addons.update(addon, version), loop=self.loop)
+
+    @api_process_raw
+    def logs(self, request):
+        """Return logs from addon."""
+        addon = self._extract_addon(request)
+        return self.addons.logs(addon)

hassio/api/homeassistant.py

@@ -4,7 +4,7 @@ import logging
 
 import voluptuous as vol
 
-from .util import api_process, api_validate
+from .util import api_process, api_process_raw, api_validate
 from ..const import ATTR_VERSION, ATTR_CURRENT
 
 _LOGGER = logging.getLogger(__name__)
@@ -17,17 +17,17 @@ SCHEMA_VERSION = vol.Schema({
 class APIHomeAssistant(object):
     """Handle rest api for homeassistant functions."""
 
-    def __init__(self, config, loop, dock_hass):
+    def __init__(self, config, loop, homeassistant):
         """Initialize homeassistant rest api part."""
         self.config = config
         self.loop = loop
-        self.dock_hass = dock_hass
+        self.homeassistant = homeassistant
 
     @api_process
     async def info(self, request):
         """Return host information."""
         info = {
-            ATTR_VERSION: self.dock_hass.version,
+            ATTR_VERSION: self.homeassistant.version,
             ATTR_CURRENT: self.config.current_homeassistant,
         }
 
@@ -39,11 +39,19 @@ class APIHomeAssistant(object):
         body = await api_validate(SCHEMA_VERSION, request)
         version = body.get(ATTR_VERSION, self.config.current_homeassistant)
 
-        if self.dock_hass.in_progress:
+        if self.homeassistant.in_progress:
             raise RuntimeError("Other task is in progress")
 
-        if version == self.dock_hass.version:
+        if version == self.homeassistant.version:
             raise RuntimeError("Version is already in use")
 
         return await asyncio.shield(
-            self.dock_hass.update(version), loop=self.loop)
+            self.homeassistant.update(version), loop=self.loop)
+
+    @api_process_raw
+    def logs(self, request):
+        """Return homeassistant docker logs.
+
+        Return a coroutine.
+        """
+        return self.homeassistant.logs()

hassio/api/supervisor.py

@@ -4,7 +4,7 @@ import logging
 
 import voluptuous as vol
 
-from .util import api_process, api_validate
+from .util import api_process, api_process_raw, api_validate
 from ..const import (
     ATTR_ADDONS, ATTR_VERSION, ATTR_CURRENT, ATTR_BETA, HASSIO_VERSION)
 
@@ -80,3 +80,11 @@ class APISupervisor(object):
                 raise RuntimeError("Some reload task fails!")
 
         return True
+
+    @api_process_raw
+    def logs(self, request):
+        """Return supervisor docker logs.
+
+        Return a coroutine.
+        """
+        return self.supervisor.logs()

hassio/api/util.py

@@ -62,6 +62,20 @@ def api_process_hostcontroll(method):
     return wrap_hostcontroll
 
 
+def api_process_raw(method):
+    """Wrap function with raw output to rest api."""
+    async def wrap_api(api, *args, **kwargs):
+        """Return api information."""
+        try:
+            message = await method(api, *args, **kwargs)
+        except RuntimeError as err:
+            message = str(err).encode()
+
+        return web.Response(body=message)
+
+    return wrap_api
+
+
 def api_return_error(message=None):
     """Return a API error message."""
     return web.json_response({

hassio/const.py

@@ -1,5 +1,5 @@
 """Const file for HassIO."""
-HASSIO_VERSION = '0.11'
+HASSIO_VERSION = '0.13'
 
 URL_HASSIO_VERSION = \
     'https://raw.githubusercontent.com/pvizeli/hassio/master/version.json'
@@ -45,6 +45,7 @@ ATTR_MAP_CONFIG = 'map_config'
 ATTR_MAP_SSL = 'map_ssl'
 ATTR_OPTIONS = 'options'
 ATTR_INSTALLED = 'installed'
+ATTR_DEDICATED = 'dedicated'
 ATTR_STATE = 'state'
 ATTR_SCHEMA = 'schema'
 ATTR_IMAGE = 'image'

hassio/dock/__init__.py

@@ -99,8 +99,9 @@ class DockerBase(object):
                     self.container.attrs['Config']['Env'])
             except docker.errors.DockerException:
                 return False
+        else:
+            self.container.reload()
 
-        self.container.reload()
         return self.container.status == 'running'
 
     async def attach(self):
@@ -222,7 +223,6 @@ class DockerBase(object):
 
         Need run inside executor.
         """
-        old_run = self._is_running()
         old_image = "{}:{}".format(self.image, self.version)
 
         _LOGGER.info("Update docker %s with %s:%s",
@@ -237,9 +237,28 @@ class DockerBase(object):
             except docker.errors.DockerException as err:
                 _LOGGER.warning(
                     "Can't remove old image %s -> %s", old_image, err)
-            # restore
-            if old_run:
-                self._run()
             return True
 
         return False
+
+    async def logs(self):
+        """Return docker logs of container."""
+        if self._lock.locked():
+            _LOGGER.error("Can't excute logs while a task is in progress")
+            return False
+
+        async with self._lock:
+            return await self.loop.run_in_executor(None, self._logs)
+
+    def _logs(self):
+        """Return docker logs of container.
+
+        Need run inside executor.
+        """
+        if not self.container:
+            return
+
+        try:
+            return self.container.logs(tail=100, stdout=True, stderr=True)
+        except docker.errors.DockerException as err:
+            _LOGGER.warning("Can't grap logs from %s -> %s", self.image, err)

hassio/dock/addon.py

@@ -24,7 +24,7 @@ class DockerAddon(DockerBase):
     @property
     def docker_name(self):
         """Return name of docker container."""
-        return "addon_{}".format(self.addons_data.get_slug(self.addon))
+        return "addon_{}".format(self.addon)
 
     def _run(self):
         """Run docker image.
@@ -74,3 +74,17 @@ class DockerAddon(DockerBase):
             return False
 
         return True
+
+    def _attach(self):
+        """Attach to running docker container.
+
+        Need run inside executor.
+        """
+        try:
+            self.container = self.dock.containers.get(self.docker_name)
+            self.version = get_version_from_env(
+                self.container.attrs['Config']['Env'])
+            _LOGGER.info("Attach to image %s with version %s",
+                         self.image, self.version)
+        except (docker.errors.DockerException, KeyError):
+            pass

hassio/dock/homeassistant.py

@@ -62,3 +62,16 @@ class DockerHomeAssistant(DockerBase):
             return False
 
         return True
+
+    async def update(self, tag):
+        """Update homeassistant docker image."""
+        if self._lock.locked():
+            _LOGGER.error("Can't excute update while a task is in progress")
+            return False
+
+        async with self._lock:
+            if await self.loop.run_in_executor(None, self._update, tag):
+                await self.loop.run_in_executor(None, self._run)
+                return True
+
+            return False

version.json

@@ -1,6 +1,7 @@
 {
-    "hassio_tag": "0.11",
+    "hassio_tag": "0.12",
     "homeassistant_tag": "0.43",
     "resinos_version": "0.4",
-    "resinhup_version": "0.1"
+    "resinhup_version": "0.1",
+    "generic_hc_version": "0.1"
 }

version_beta.json

@@ -1,6 +1,7 @@
 {
-    "hassio_tag": "0.11",
+    "hassio_tag": "0.13",
     "homeassistant_tag": "0.43",
     "resinos_version": "0.4",
-    "resinhup_version": "0.1"
+    "resinhup_version": "0.1",
+    "generic_hc_version": "0.1"
 }