Merge pull request #21 from home-assistant/dev

Release 0.18

Author: pvizeli

API.md

@@ -40,6 +40,9 @@ On success
             "dedicated": "bool",
             "description": "description"
         }
+    ],
+    "addons_repositories": [
+        "REPO_URL"
     ]
 }
 ```
@@ -55,7 +58,10 @@ Optional:
 - POST `/supervisor/options`
 ```json
 {
-    "beta_channel": "true|false"
+    "beta_channel": "true|false",
+    "addons_repositories": [
+        "REPO_URL"
+    ]
 }
 ```
 

hassio/addons/__init__.py

@@ -5,7 +5,7 @@
 import shutil
 
 from .data import AddonsData
-from .git import AddonsRepo
+from .git import AddonsRepoHassIO, AddonsRepoCustom
 from ..const import STATE_STOPPED, STATE_STARTED
 from ..dock.addon import DockerAddon
 
@@ -21,28 +21,74 @@ def __init__(self, config, loop, dock):
 
         self.loop = loop
         self.dock = dock
-        self.repo = AddonsRepo(config, loop)
+        self.repositories = []
         self.dockers = {}
 
     async def prepare(self, arch):
         """Startup addon management."""
         self.arch = arch
 
+        # init hassio repository
+        self.repositories.append(AddonsRepoHassIO(self.config, self.loop))
+
+        # init custom repositories
+        for url in self.config.addons_repositories:
+            self.repositories.append(
+                AddonsRepoCustom(self.config, self.loop, url))
+
         # load addon repository
-        if await self.repo.load():
-            self.read_addons_repo()
+        tasks = [addon.load() for addon in self.repositories]
+        if tasks:
+            await asyncio.wait(tasks, loop=self.loop)
+
+            # read data from repositories
+            self.read_data_from_repositories()
+            self.merge_update_config()
 
         # load installed addons
         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 add_custom_repository(self, url):
+        """Add a new custom repository."""
+        if url in self.config.addons_repositories:
+            _LOGGER.warning("Repository already exists %s", url)
+            return False
+
+        repo = AddonsRepoCustom(self.config, self.loop, url)
+
+        if not await repo.load():
+            _LOGGER.error("Can't load from repository %s", url)
+            return False
+
+        self.config.addons_repositories = url
+        self.repositories.append(repo)
+        return True
+
+    def drop_custom_repository(self, url):
+        """Remove a custom repository."""
+        for repo in self.repositories:
+            if repo.url == url:
+                self.repositories.remove(repo)
+                self.config.drop_addon_repository(url)
+                repo.remove()
+                return True
+
+        return False
+
     async def reload(self):
         """Update addons from repo and reload list."""
-        if not await self.repo.pull():
+        tasks = [addon.pull() for addon in self.repositories]
+        if not tasks:
             return
-        self.read_addons_repo()
+
+        await asyncio.wait(tasks, loop=self.loop)
+
+        # read data from repositories
+        self.read_data_from_repositories()
+        self.merge_update_config()
 
         # remove stalled addons
         for addon in self.list_removed:
@@ -51,10 +97,7 @@ async def reload(self):
     async def auto_boot(self, start_type):
         """Boot addons with mode auto."""
         boot_list = self.list_startup(start_type)
-        tasks = []
-
-        for addon in boot_list:
-            tasks.append(self.loop.create_task(self.start(addon)))
+        tasks = [self.start(addon) for addon in boot_list]
 
         _LOGGER.info("Startup %s run %d addons", start_type, len(tasks))
         if tasks:

hassio/addons/data.py

@@ -1,22 +1,24 @@
 """Init file for HassIO addons."""
+import copy
 import logging
 import glob
 
 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
 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_DEDICATED)
+    ATTR_STARTUP, ATTR_BOOT, ATTR_MAP, ATTR_OPTIONS, ATTR_PORTS, BOOT_AUTO,
+    DOCKER_REPO, ATTR_INSTALLED, ATTR_SCHEMA, ATTR_IMAGE, ATTR_DEDICATED,
+    MAP_CONFIG, MAP_SSL, MAP_ADDONS, MAP_BACKUP)
 from ..config import Config
 from ..tools import read_json_file, write_json_file
 
 _LOGGER = logging.getLogger(__name__)
 
-ADDONS_REPO_PATTERN = "{}/*/config.json"
+ADDONS_REPO_PATTERN = "{}/**/config.json"
 SYSTEM = "system"
 USER = "user"
 
@@ -41,31 +43,60 @@ def save(self):
         }
         super().save()
 
-    def read_addons_repo(self):
+    def read_data_from_repositories(self):
         """Read data from addons repository."""
         self._current_data = {}
 
         self._read_addons_folder(self.config.path_addons_repo)
-        self._read_addons_folder(self.config.path_addons_custom)
+        self._read_addons_folder(self.config.path_addons_custom, custom=True)
 
-    def _read_addons_folder(self, folder):
+    def _read_addons_folder(self, folder, custom=False):
         """Read data from addons folder."""
         pattern = ADDONS_REPO_PATTERN.format(folder)
 
-        for addon in glob.iglob(pattern):
+        for addon in glob.iglob(pattern, recursive=True):
             try:
                 addon_config = read_json_file(addon)
 
                 addon_config = SCHEMA_ADDON_CONFIG(addon_config)
-                self._current_data[addon_config[ATTR_SLUG]] = addon_config
+                if custom:
+                    addon_slug = "{}_{}".format(
+                        extract_hash_from_path(folder, addon),
+                        addon_config[ATTR_SLUG],
+                    )
+                else:
+                    addon_slug = addon_config[ATTR_SLUG]
 
-            except (OSError, KeyError):
+                self._current_data[addon_slug] = addon_config
+
+            except OSError:
                 _LOGGER.warning("Can't read %s", addon)
 
             except vol.Invalid as ex:
                 _LOGGER.warning("Can't read %s -> %s", addon,
                                 humanize_error(addon_config, ex))
 
+    def merge_update_config(self):
+        """Update local config if they have update.
+
+        It need to be the same version as the local version is.
+        """
+        have_change = False
+
+        for addon, data in self._system_data.items():
+            # dedicated
+            if addon not in self._current_data:
+                continue
+
+            current = self._current_data[addon]
+            if data[ATTR_VERSION] == current[ATTR_VERSION]:
+                if data != current:
+                    self._system_data[addon] = copy.deepcopy(current)
+                    have_change = True
+
+        if have_change:
+            self.save()
+
     @property
     def list_installed(self):
         """Return a list of installed addons."""
@@ -83,7 +114,7 @@ def list_api(self):
 
             data.append({
                 ATTR_NAME: values[ATTR_NAME],
-                ATTR_SLUG: values[ATTR_SLUG],
+                ATTR_SLUG: addon,
                 ATTR_DESCRIPTON: values[ATTR_DESCRIPTON],
                 ATTR_VERSION: values[ATTR_VERSION],
                 ATTR_INSTALLED: i_version,
@@ -132,7 +163,7 @@ def version_installed(self, addon):
 
     def set_addon_install(self, addon, version):
         """Set addon as installed."""
-        self._system_data[addon] = self._current_data[addon]
+        self._system_data[addon] = copy.deepcopy(self._current_data[addon])
         self._user_data[addon] = {
             ATTR_OPTIONS: {},
             ATTR_VERSION: version,
@@ -147,13 +178,13 @@ def set_addon_uninstall(self, addon):
 
     def set_addon_update(self, addon, version):
         """Update version of addon."""
-        self._system_data[addon] = self._current_data[addon]
+        self._system_data[addon] = copy.deepcopy(self._current_data[addon])
         self._user_data[addon][ATTR_VERSION] = version
         self.save()
 
     def set_options(self, addon, options):
         """Store user addon options."""
-        self._user_data[addon][ATTR_OPTIONS] = options
+        self._user_data[addon][ATTR_OPTIONS] = copy.deepcopy(options)
         self.save()
 
     def set_boot(self, addon, boot):
@@ -200,15 +231,23 @@ def get_image(self, addon):
         if ATTR_IMAGE not in addon_data:
             return "{}/{}-addon-{}".format(DOCKER_REPO, self.arch, addon)
 
-        return addon_data[ATTR_IMAGE]
+        return addon_data[ATTR_IMAGE].format(arch=self.arch)
 
-    def need_config(self, addon):
+    def map_config(self, addon):
         """Return True if config map is needed."""
-        return self._system_data[addon][ATTR_MAP_CONFIG]
+        return MAP_CONFIG in self._system_data[addon][ATTR_MAP]
 
-    def need_ssl(self, addon):
+    def map_ssl(self, addon):
         """Return True if ssl map is needed."""
-        return self._system_data[addon][ATTR_MAP_SSL]
+        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]
 
     def path_data(self, addon):
         """Return addon data path inside supervisor."""

hassio/addons/git.py

@@ -2,9 +2,11 @@
 import asyncio
 import logging
 import os
+import shutil
 
 import git
 
+from .util import get_hash_from_repository
 from ..const import URL_HASSIO_ADDONS
 
 _LOGGER = logging.getLogger(__name__)
@@ -13,26 +15,28 @@
 class AddonsRepo(object):
     """Manage addons git repo."""
 
-    def __init__(self, config, loop):
-        """Initialize docker base wrapper."""
+    def __init__(self, config, loop, path, url):
+        """Initialize git base wrapper."""
         self.config = config
         self.loop = loop
         self.repo = None
+        self.path = path
+        self.url = url
         self._lock = asyncio.Lock(loop=loop)
 
     async def load(self):
         """Init git addon repo."""
-        if not os.path.isdir(self.config.path_addons_repo):
+        if not os.path.isdir(self.path):
             return await self.clone()
 
         async with self._lock:
             try:
-                _LOGGER.info("Load addons repository")
+                _LOGGER.info("Load addon %s repository", self.path)
                 self.repo = await self.loop.run_in_executor(
-                    None, git.Repo, self.config.path_addons_repo)
+                    None, git.Repo, self.path)
 
             except (git.InvalidGitRepositoryError, git.NoSuchPathError) as err:
-                _LOGGER.error("Can't load addons repo: %s.", err)
+                _LOGGER.error("Can't load %s repo: %s.", self.path, err)
                 return False
 
             return True
@@ -41,13 +45,12 @@ async def clone(self):
         """Clone git addon repo."""
         async with self._lock:
             try:
-                _LOGGER.info("Clone addons repository")
+                _LOGGER.info("Clone addon %s repository", self.url)
                 self.repo = await self.loop.run_in_executor(
-                    None, git.Repo.clone_from, URL_HASSIO_ADDONS,
-                    self.config.path_addons_repo)
+                    None, git.Repo.clone_from, self.url, self.path)
 
             except (git.InvalidGitRepositoryError, git.NoSuchPathError) as err:
-                _LOGGER.error("Can't clone addons repo: %s.", err)
+                _LOGGER.error("Can't clone %s repo: %s.", self.url, err)
                 return False
 
             return True
@@ -60,12 +63,43 @@ async def pull(self):
 
         async with self._lock:
             try:
-                _LOGGER.info("Pull addons repository")
+                _LOGGER.info("Pull addon %s repository", self.url)
                 await self.loop.run_in_executor(
                     None, self.repo.remotes.origin.pull)
 
             except (git.InvalidGitRepositoryError, git.NoSuchPathError) as err:
-                _LOGGER.error("Can't pull addons repo: %s.", err)
+                _LOGGER.error("Can't pull %s repo: %s.", self.url, err)
                 return False
 
             return True
+
+
+class AddonsRepoHassIO(AddonsRepo):
+    """HassIO addons repository."""
+
+    def __init__(self, config, loop):
+        """Initialize git hassio addon repository."""
+        super().__init__(
+            config, loop, config.path_addons_repo, URL_HASSIO_ADDONS)
+
+
+class AddonsRepoCustom(AddonsRepo):
+    """Custom addons repository."""
+
+    def __init__(self, config, loop, url):
+        """Initialize git hassio addon repository."""
+        path = os.path.join(
+            config.path_addons_custom, get_hash_from_repository(url))
+
+        super().__init__(config, loop, path, url)
+
+    def remove(self):
+        """Remove a custom addon."""
+        if os.path.isdir(self.path):
+            _LOGGER.info("Remove custom addon repository %s", self.url)
+
+            def log_err(funct, path, _):
+                """Log error."""
+                _LOGGER.warning("Can't remove %s", path)
+
+            shutil.rmtree(self.path, onerror=log_err)