Update setup.py

* Add more addons functions.

* fix lint

* fix lint p2

* Allow more customable network settings

* fix lint

* change point of validate

* fix lint

* fix handling

* fix lint & validate data before write

.travis.yml

@@ -2,7 +2,7 @@ sudo: false
 matrix:
   fast_finish: true
   include:
-    - python: "3.5"
+    - python: "3.6"
 
 cache:
   directories:

API.md

@@ -51,6 +51,13 @@ The addons from `addons` are only installed one.
     ],
     "addons_repositories": [
         "REPO_URL"
+    ],
+    "snapshots": [
+        {
+            "slug": "SLUG",
+            "data": "ISO",
+            "name": "Custom name"
+        }
     ]
 }
 ```
@@ -78,10 +85,10 @@ Get all available addons
     "repositories": [
         {
             "slug": "12345678",
-            "name": "Repitory Name",
+            "name": "Repitory Name|unknown",
             "source": "URL_OF_REPOSITORY",
-            "url": "null|WEBSITE",
-            "maintainer": "null|BLA BLU <fla@dld.ch>"
+            "url": "WEBSITE|REPOSITORY",
+            "maintainer": "BLA BLU <fla@dld.ch>|unknown"
         }
     ]
 }
@@ -148,7 +155,65 @@ Return QR-Code
 }
 ```
 
+### Backup/Snapshot
+
+- POST `/snapshots/new/full`
+```json
+{
+    "name": "Optional"
+}
+```
+
+- POST `/snapshots/new/partial`
+```json
+{
+    "name": "Optional",
+    "addons": ["ADDON_SLUG"],
+    "folders": ["FOLDER_NAME"]
+}
+```
+
+- POST `/snapshots/reload`
+
+- GET `/snapshots/{slug}/info`
+```json
+{
+    "slug": "SNAPSHOT ID",
+    "type": "full|partial",
+    "name": "custom snapshot name / description",
+    "date": "ISO",
+    "size": "SIZE_IN_MB",
+    "homeassistant": {
+      "version": "INSTALLED_HASS_VERSION",
+      "devices": []
+    },
+    "addons": [
+        {
+            "slug": "ADDON_SLUG",
+            "name": "NAME",
+            "version": "INSTALLED_VERSION"
+        }
+    ],
+    "repositories": ["URL"],
+    "folders": ["NAME"]
+}
+```
+
+- POST `/snapshots/{slug}/remove`
+
+- POST `/snapshots/{slug}/restore/full`
+
+- POST `/snapshots/{slug}/restore/partial`
+```json
+{
+    "homeassistant": "bool",
+    "addons": ["ADDON_SLUG"],
+    "folders": ["FOLDER_NAME"]
+}
+```
+
 ### Host
+- POST `/host/reload`
 
 - POST `/host/shutdown`
 
@@ -231,20 +296,25 @@ Output the raw docker log
 
 ### REST API addons
 
+- POST `/addons/reload`
+
 - GET `/addons/{addon}/info`
 ```json
 {
     "name": "xy bla",
     "description": "description",
+    "auto_update": "bool",
     "url": "null|url of addon",
     "detached": "bool",
     "repository": "12345678|null",
-    "version": "VERSION",
+    "version": "null|VERSION_INSTALLED",
     "last_version": "LAST_VERSION",
-    "state": "started|stopped",
+    "state": "none|started|stopped",
     "boot": "auto|manual",
     "build": "bool",
-    "options": {},
+    "options": "{}",
+    "network": "{}|null",
+    "host_network": "bool"
 }
 ```
 
@@ -252,10 +322,16 @@ Output the raw docker log
 ```json
 {
     "boot": "auto|manual",
+    "auto_update": "bool",
+    "network": {
+      "CONTAINER": "port|[ip, port]"
+    },
     "options": {},
 }
 ```
 
+For reset custom network settings, set it `null`.
+
 - POST `/addons/{addon}/start`
 
 - POST `/addons/{addon}/stop`

hassio/__main__.py

@@ -1,5 +1,6 @@
 """Main file for HassIO."""
 import asyncio
+from concurrent.futures import ThreadPoolExecutor
 import logging
 import sys
 
@@ -17,16 +18,27 @@ if __name__ == "__main__":
         exit(1)
 
     loop = asyncio.get_event_loop()
-    hassio = core.HassIO(loop)
+    executor = ThreadPoolExecutor(thread_name_prefix="SyncWorker")
+    loop.set_default_executor(executor)
+
+    _LOGGER.info("Initialize Hassio setup")
+    config = bootstrap.initialize_system_data()
+    hassio = core.HassIO(loop, config)
+
+    bootstrap.migrate_system_env(config)
 
     _LOGGER.info("Run Hassio setup")
     loop.run_until_complete(hassio.setup())
 
-    _LOGGER.info("Start Hassio task")
+    _LOGGER.info("Start Hassio")
     loop.call_soon_threadsafe(loop.create_task, hassio.start())
     loop.call_soon_threadsafe(bootstrap.reg_signal, loop, hassio)
 
+    _LOGGER.info("Run Hassio loop")
     loop.run_forever()
+
+    _LOGGER.info("Cleanup system")
+    executor.shutdown(wait=False)
     loop.close()
 
     _LOGGER.info("Close Hassio")

hassio/addons/__init__.py

@@ -1,220 +1,133 @@
 """Init file for HassIO addons."""
 import asyncio
 import logging
-import shutil
 
-from .data import AddonsData
-from .git import AddonsRepoHassIO, AddonsRepoCustom
-from ..const import STATE_STOPPED, STATE_STARTED
-from ..dock.addon import DockerAddon
+from .addon import Addon
+from .repository import Repository
+from .data import Data
+from ..const import REPOSITORY_CORE, REPOSITORY_LOCAL, BOOT_AUTO
 
 _LOGGER = logging.getLogger(__name__)
 
+BUILTIN_REPOSITORIES = set((REPOSITORY_CORE, REPOSITORY_LOCAL))
 
-class AddonManager(AddonsData):
+
+class AddonManager(object):
     """Manage addons inside HassIO."""
 
     def __init__(self, config, loop, dock):
         """Initialize docker base wrapper."""
-        super().__init__(config)
-
         self.loop = loop
+        self.config = config
         self.dock = dock
-        self.repositories = []
-        self.dockers = {}
+        self.data = Data(config)
+        self.addons = {}
+        self.repositories = {}
 
-    async def prepare(self, arch):
+    @property
+    def list_addons(self):
+        """Return a list of all addons."""
+        return list(self.addons.values())
+
+    @property
+    def list_repositories(self):
+        """Return list of addon repositories."""
+        return list(self.repositories.values())
+
+    def get(self, addon_slug):
+        """Return a adddon from slug."""
+        return self.addons.get(addon_slug)
+
+    async def prepare(self):
         """Startup addon management."""
-        self.arch = arch
+        self.data.reload()
 
-        # init hassio repository
-        self.repositories.append(AddonsRepoHassIO(self.config, self.loop))
+        # init hassio built-in repositories
+        repositories = \
+            set(self.config.addons_repositories) | BUILTIN_REPOSITORIES
 
-        # init custom repositories
-        for url in self.config.addons_repositories:
-            self.repositories.append(
-                AddonsRepoCustom(self.config, self.loop, url))
-
-        # load addon repository
-        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_git_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_git_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
+        # init custom repositories & load addons
+        await self.load_repositories(repositories)
 
     async def reload(self):
         """Update addons from repo and reload list."""
-        tasks = [addon.pull() for addon in self.repositories]
-        if not tasks:
-            return
-
-        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_detached:
-            _LOGGER.warning("Dedicated addon '%s' found!", addon)
-
-    async def auto_boot(self, start_type):
-        """Boot addons with mode auto."""
-        boot_list = self.list_startup(start_type)
-        tasks = [self.start(addon) for addon in boot_list]
-
-        _LOGGER.info("Startup %s run %d addons", start_type, len(tasks))
+        tasks = [repository.update() for repository in
+                 self.repositories.values()]
         if tasks:
             await asyncio.wait(tasks, loop=self.loop)
 
-    async def install(self, addon, version=None):
-        """Install a addon."""
-        if not self.exists_addon(addon):
-            _LOGGER.error("Addon %s not exists for install", addon)
-            return False
+        # read data from repositories
+        self.data.reload()
 
-        if self.arch not in self.get_arch(addon):
-            _LOGGER.error("Addon %s not supported on %s", addon, self.arch)
-            return False
+        # update addons
+        await self.load_addons()
 
-        if self.is_installed(addon):
-            _LOGGER.error("Addon %s is already installed", addon)
-            return False
+    async def load_repositories(self, list_repositories):
+        """Add a new custom repository."""
+        new_rep = set(list_repositories)
+        old_rep = set(self.repositories)
 
-        if not self.path_data(addon).is_dir():
-            _LOGGER.info("Create Home-Assistant addon data folder %s",
-                         self.path_data(addon))
-            self.path_data(addon).mkdir()
+        # add new repository
+        async def _add_repository(url):
+            """Helper function to async add repository."""
+            repository = Repository(self.config, self.loop, self.data, url)
+            if not await repository.load():
+                _LOGGER.error("Can't load from repository %s", url)
+                return
+            self.repositories[url] = repository
 
-        addon_docker = DockerAddon(
-            self.config, self.loop, self.dock, self, addon)
+            # don't add built-in repository to config
+            if url not in BUILTIN_REPOSITORIES:
+                self.config.addons_repositories = url
 
-        version = version or self.get_last_version(addon)
-        if not await addon_docker.install(version):
-            return False
+        tasks = [_add_repository(url) for url in new_rep - old_rep]
+        if tasks:
+            await asyncio.wait(tasks, loop=self.loop)
 
-        self.dockers[addon] = addon_docker
-        self.set_addon_install(addon, version)
-        return True
+        # del new repository
+        for url in old_rep - new_rep - BUILTIN_REPOSITORIES:
+            self.repositories.pop(url).remove()
+            self.config.drop_addon_repository(url)
 
-    async def uninstall(self, addon):
-        """Remove a addon."""
-        if not self.is_installed(addon):
-            _LOGGER.error("Addon %s is already uninstalled", addon)
-            return False
+        # update data
+        self.data.reload()
+        await self.load_addons()
 
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
+    async def load_addons(self):
+        """Update/add internal addon store."""
+        all_addons = set(self.data.system) | set(self.data.cache)
 
-        if not await self.dockers[addon].remove():
-            return False
+        # calc diff
+        add_addons = all_addons - set(self.addons)
+        del_addons = set(self.addons) - all_addons
 
-        if self.path_data(addon).is_dir():
-            _LOGGER.info("Remove Home-Assistant addon data folder %s",
-                         self.path_data(addon))
-            shutil.rmtree(str(self.path_data(addon)))
+        _LOGGER.info("Load addons: %d all - %d new - %d remove",
+                     len(all_addons), len(add_addons), len(del_addons))
 
-        self.dockers.pop(addon)
-        self.set_addon_uninstall(addon)
-        return True
+        # new addons
+        tasks = []
+        for addon_slug in add_addons:
+            addon = Addon(
+                self.config, self.loop, self.dock, self.data, addon_slug)
 
-    async def state(self, addon):
-        """Return running state of addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return
+            tasks.append(addon.load())
+            self.addons[addon_slug] = addon
 
-        if await self.dockers[addon].is_running():
-            return STATE_STARTED
-        return STATE_STOPPED
+        if tasks:
+            await asyncio.wait(tasks, loop=self.loop)
 
-    async def start(self, addon):
-        """Set options and start addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
+        # remove
+        for addon_slug in del_addons:
+            self.addons.pop(addon_slug)
 
-        if not self.write_addon_options(addon):
-            _LOGGER.error("Can't write options for addon %s", addon)
-            return False
+    async def auto_boot(self, stage):
+        """Boot addons with mode auto."""
+        tasks = []
+        for addon in self.addons.values():
+            if addon.is_installed and addon.boot == BOOT_AUTO and \
+                    addon.startup == stage:
+                tasks.append(addon.start())
 
-        return await self.dockers[addon].run()
-
-    async def stop(self, addon):
-        """Stop addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
-
-        return await self.dockers[addon].stop()
-
-    async def update(self, addon, version=None):
-        """Update addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
-
-        version = version or self.get_last_version(addon)
-
-        # update
-        if not await self.dockers[addon].update(version):
-            return False
-
-        self.set_addon_update(addon, version)
-        return True
-
-    async def restart(self, addon):
-        """Restart addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
-
-        if not self.write_addon_options(addon):
-            _LOGGER.error("Can't write options for addon %s", addon)
-            return False
-
-        return await self.dockers[addon].restart()
-
-    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()
+        _LOGGER.info("Startup %s run %d addons", stage, len(tasks))
+        if tasks:
+            await asyncio.wait(tasks, loop=self.loop)

hassio/addons/addon.py

@@ -0,0 +1,488 @@
+"""Init file for HassIO addons."""
+from copy import deepcopy
+import logging
+import json
+from pathlib import Path, PurePath
+import re
+import shutil
+import tarfile
+from tempfile import TemporaryDirectory
+
+import voluptuous as vol
+from voluptuous.humanize import humanize_error
+
+from .validate import (
+    validate_options, SCHEMA_ADDON_SNAPSHOT, MAP_VOLUME)
+from ..const import (
+    ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON, ATTR_BOOT, ATTR_MAP,
+    ATTR_OPTIONS, ATTR_PORTS, ATTR_SCHEMA, ATTR_IMAGE, ATTR_REPOSITORY,
+    ATTR_URL, ATTR_ARCH, ATTR_LOCATON, ATTR_DEVICES, ATTR_ENVIRONMENT,
+    ATTR_HOST_NETWORK, ATTR_TMPFS, ATTR_PRIVILEGED, ATTR_STARTUP,
+    STATE_STARTED, STATE_STOPPED, STATE_NONE, ATTR_USER, ATTR_SYSTEM,
+    ATTR_STATE, ATTR_TIMEOUT, ATTR_AUTO_UPDATE, ATTR_NETWORK)
+from .util import check_installed
+from ..dock.addon import DockerAddon
+from ..tools import write_json_file, read_json_file
+
+_LOGGER = logging.getLogger(__name__)
+
+RE_VOLUME = re.compile(MAP_VOLUME)
+
+
+class Addon(object):
+    """Hold data for addon inside HassIO."""
+
+    def __init__(self, config, loop, dock, data, slug):
+        """Initialize data holder."""
+        self.loop = loop
+        self.config = config
+        self.data = data
+        self._id = slug
+
+        self.addon_docker = DockerAddon(config, loop, dock, self)
+
+    async def load(self):
+        """Async initialize of object."""
+        if self.is_installed:
+            await self.addon_docker.attach()
+
+    @property
+    def slug(self):
+        """Return slug/id of addon."""
+        return self._id
+
+    @property
+    def _mesh(self):
+        """Return addon data from system or cache."""
+        return self.data.system.get(self._id, self.data.cache.get(self._id))
+
+    @property
+    def is_installed(self):
+        """Return True if a addon is installed."""
+        return self._id in self.data.system
+
+    @property
+    def is_detached(self):
+        """Return True if addon is detached."""
+        return self._id not in self.data.cache
+
+    @property
+    def version_installed(self):
+        """Return installed version."""
+        return self.data.user.get(self._id, {}).get(ATTR_VERSION)
+
+    def _set_install(self, version):
+        """Set addon as installed."""
+        self.data.system[self._id] = deepcopy(self.data.cache[self._id])
+        self.data.user[self._id] = {
+            ATTR_OPTIONS: {},
+            ATTR_VERSION: version,
+        }
+        self.data.save()
+
+    def _set_uninstall(self):
+        """Set addon as uninstalled."""
+        self.data.system.pop(self._id, None)
+        self.data.user.pop(self._id, None)
+        self.data.save()
+
+    def _set_update(self, version):
+        """Update version of addon."""
+        self.data.system[self._id] = deepcopy(self.data.cache[self._id])
+        self.data.user[self._id][ATTR_VERSION] = version
+        self.data.save()
+
+    def _restore_data(self, user, system):
+        """Restore data to addon."""
+        self.data.user[self._id] = deepcopy(user)
+        self.data.system[self._id] = deepcopy(system)
+        self.data.save()
+
+    @property
+    def options(self):
+        """Return options with local changes."""
+        if self.is_installed:
+            return {
+                **self.data.system[self._id][ATTR_OPTIONS],
+                **self.data.user[self._id][ATTR_OPTIONS],
+            }
+        return self.data.cache[self._id][ATTR_OPTIONS]
+
+    @options.setter
+    def options(self, value):
+        """Store user addon options."""
+        self.data.user[self._id][ATTR_OPTIONS] = deepcopy(value)
+        self.data.save()
+
+    @property
+    def boot(self):
+        """Return boot config with prio local settings."""
+        if ATTR_BOOT in self.data.user.get(self._id, {}):
+            return self.data.user[self._id][ATTR_BOOT]
+        return self._mesh[ATTR_BOOT]
+
+    @boot.setter
+    def boot(self, value):
+        """Store user boot options."""
+        self.data.user[self._id][ATTR_BOOT] = value
+        self.data.save()
+
+    @property
+    def auto_update(self):
+        """Return if auto update is enable."""
+        return self.data.user[self._id][ATTR_AUTO_UPDATE]
+
+    @auto_update.setter
+    def auto_update(self, value):
+        """Set auto update."""
+        self.data.user[self._id][ATTR_AUTO_UPDATE] = value
+        self.data.save()
+
+    @property
+    def name(self):
+        """Return name of addon."""
+        return self._mesh[ATTR_NAME]
+
+    @property
+    def timeout(self):
+        """Return timeout of addon for docker stop."""
+        return self._mesh[ATTR_TIMEOUT]
+
+    @property
+    def description(self):
+        """Return description of addon."""
+        return self._mesh[ATTR_DESCRIPTON]
+
+    @property
+    def repository(self):
+        """Return repository of addon."""
+        return self._mesh[ATTR_REPOSITORY]
+
+    @property
+    def last_version(self):
+        """Return version of addon."""
+        if self._id in self.data.cache:
+            return self.data.cache[self._id][ATTR_VERSION]
+        return self.version_installed
+
+    @property
+    def startup(self):
+        """Return startup type of addon."""
+        return self._mesh.get(ATTR_STARTUP)
+
+    @property
+    def ports(self):
+        """Return ports of addon."""
+        if self.network_mode != 'bridge' or ATTR_PORTS not in self._mesh:
+            return
+
+        if not self.is_installed or \
+                ATTR_NETWORK not in self.data.user[self._id]:
+            return self._mesh[ATTR_PORTS]
+        return self.data.user[self._id][ATTR_NETWORK]
+
+    @ports.setter
+    def ports(self, value):
+        """Set custom ports of addon."""
+        if value is None:
+            self.data.user[self._id].pop(ATTR_NETWORK, None)
+        else:
+            new_ports = {}
+            for container_port, host_port in value.items():
+                if container_port in self._mesh.get(ATTR_PORTS, {}):
+                    new_ports[container_port] = host_port
+
+            self.data.user[self._id][ATTR_NETWORK] = new_ports
+
+        self.data.save()
+
+    @property
+    def network_mode(self):
+        """Return network mode of addon."""
+        if self._mesh[ATTR_HOST_NETWORK]:
+            return 'host'
+        return 'bridge'
+
+    @property
+    def devices(self):
+        """Return devices of addon."""
+        return self._mesh.get(ATTR_DEVICES)
+
+    @property
+    def tmpfs(self):
+        """Return tmpfs of addon."""
+        return self._mesh.get(ATTR_TMPFS)
+
+    @property
+    def environment(self):
+        """Return environment of addon."""
+        return self._mesh.get(ATTR_ENVIRONMENT)
+
+    @property
+    def privileged(self):
+        """Return list of privilege."""
+        return self._mesh.get(ATTR_PRIVILEGED)
+
+    @property
+    def url(self):
+        """Return url of addon."""
+        return self._mesh.get(ATTR_URL)
+
+    @property
+    def supported_arch(self):
+        """Return list of supported arch."""
+        return self._mesh[ATTR_ARCH]
+
+    @property
+    def image(self):
+        """Return image name of addon."""
+        addon_data = self._mesh
+
+        # Repository with dockerhub images
+        if ATTR_IMAGE in addon_data:
+            return addon_data[ATTR_IMAGE].format(arch=self.config.arch)
+
+        # local build
+        return "{}/{}-addon-{}".format(
+            addon_data[ATTR_REPOSITORY], self.config.arch,
+            addon_data[ATTR_SLUG])
+
+    @property
+    def need_build(self):
+        """Return True if this  addon need a local build."""
+        return ATTR_IMAGE not in self._mesh
+
+    @property
+    def map_volumes(self):
+        """Return a dict of {volume: policy} from addon."""
+        volumes = {}
+        for volume in self._mesh[ATTR_MAP]:
+            result = RE_VOLUME.match(volume)
+            volumes[result.group(1)] = result.group(2) or 'ro'
+
+        return volumes
+
+    @property
+    def path_data(self):
+        """Return addon data path inside supervisor."""
+        return Path(self.config.path_addons_data, self._id)
+
+    @property
+    def path_extern_data(self):
+        """Return addon data path external for docker."""
+        return PurePath(self.config.path_extern_addons_data, self._id)
+
+    @property
+    def path_addon_options(self):
+        """Return path to addons options."""
+        return Path(self.path_data, "options.json")
+
+    @property
+    def path_addon_location(self):
+        """Return path to this addon."""
+        return Path(self._mesh[ATTR_LOCATON])
+
+    def write_options(self):
+        """Return True if addon options is written to data."""
+        schema = self.schema
+        options = self.options
+
+        try:
+            schema(options)
+            return write_json_file(self.path_addon_options, options)
+        except vol.Invalid as ex:
+            _LOGGER.error("Addon %s have wrong options -> %s", self._id,
+                          humanize_error(options, ex))
+
+        return False
+
+    @property
+    def schema(self):
+        """Create a schema for addon options."""
+        raw_schema = self._mesh[ATTR_SCHEMA]
+
+        if isinstance(raw_schema, bool):
+            return vol.Schema(dict)
+        return vol.Schema(vol.All(dict, validate_options(raw_schema)))
+
+    async def install(self, version=None):
+        """Install a addon."""
+        if self.config.arch not in self.supported_arch:
+            _LOGGER.error(
+                "Addon %s not supported on %s", self._id, self.config.arch)
+            return False
+
+        if self.is_installed:
+            _LOGGER.error("Addon %s is already installed", self._id)
+            return False
+
+        if not self.path_data.is_dir():
+            _LOGGER.info(
+                "Create Home-Assistant addon data folder %s", self.path_data)
+            self.path_data.mkdir()
+
+        version = version or self.last_version
+        if not await self.addon_docker.install(version):
+            return False
+
+        self._set_install(version)
+        return True
+
+    @check_installed
+    async def uninstall(self):
+        """Remove a addon."""
+        if not await self.addon_docker.remove():
+            return False
+
+        if self.path_data.is_dir():
+            _LOGGER.info(
+                "Remove Home-Assistant addon data folder %s", self.path_data)
+            shutil.rmtree(str(self.path_data))
+
+        self._set_uninstall()
+        return True
+
+    async def state(self):
+        """Return running state of addon."""
+        if not self.is_installed:
+            return STATE_NONE
+
+        if await self.addon_docker.is_running():
+            return STATE_STARTED
+        return STATE_STOPPED
+
+    @check_installed
+    async def start(self):
+        """Set options and start addon."""
+        return await self.addon_docker.run()
+
+    @check_installed
+    async def stop(self):
+        """Stop addon."""
+        return await self.addon_docker.stop()
+
+    @check_installed
+    async def update(self, version=None):
+        """Update addon."""
+        version = version or self.last_version
+
+        if version == self.version_installed:
+            _LOGGER.warning(
+                "Addon %s is already installed in %s", self._id, version)
+            return True
+
+        if not await self.addon_docker.update(version):
+            return False
+
+        self._set_update(version)
+        return True
+
+    @check_installed
+    async def restart(self):
+        """Restart addon."""
+        return await self.addon_docker.restart()
+
+    @check_installed
+    async def logs(self):
+        """Return addons log output."""
+        return await self.addon_docker.logs()
+
+    @check_installed
+    async def snapshot(self, tar_file):
+        """Snapshot a state of a addon."""
+        with TemporaryDirectory(dir=str(self.config.path_tmp)) as temp:
+            # store local image
+            if self.need_build and not await \
+                    self.addon_docker.export_image(Path(temp, "image.tar")):
+                return False
+
+            data = {
+                ATTR_USER: self.data.user.get(self._id, {}),
+                ATTR_SYSTEM: self.data.system.get(self._id, {}),
+                ATTR_VERSION: self.version_installed,
+                ATTR_STATE: await self.state(),
+            }
+
+            # store local configs/state
+            if not write_json_file(Path(temp, "addon.json"), data):
+                _LOGGER.error("Can't write addon.json for %s", self._id)
+                return False
+
+            # write into tarfile
+            def _create_tar():
+                """Write tar inside loop."""
+                with tarfile.open(tar_file, "w:gz",
+                                  compresslevel=1) as snapshot:
+                    snapshot.add(temp, arcname=".")
+                    snapshot.add(self.path_data, arcname="data")
+
+            try:
+                await self.loop.run_in_executor(None, _create_tar)
+            except tarfile.TarError as err:
+                _LOGGER.error("Can't write tarfile %s -> %s", tar_file, err)
+                return False
+
+        return True
+
+    async def restore(self, tar_file):
+        """Restore a state of a addon."""
+        with TemporaryDirectory(dir=str(self.config.path_tmp)) as temp:
+            # extract snapshot
+            def _extract_tar():
+                """Extract tar snapshot."""
+                with tarfile.open(tar_file, "r:gz") as snapshot:
+                    snapshot.extractall(path=Path(temp))
+
+            try:
+                await self.loop.run_in_executor(None, _extract_tar)
+            except tarfile.TarError as err:
+                _LOGGER.error("Can't read tarfile %s -> %s", tar_file, err)
+                return False
+
+            # read snapshot data
+            try:
+                data = read_json_file(Path(temp, "addon.json"))
+            except (OSError, json.JSONDecodeError) as err:
+                _LOGGER.error("Can't read addon.json -> %s", err)
+
+            # validate
+            try:
+                data = SCHEMA_ADDON_SNAPSHOT(data)
+            except vol.Invalid as err:
+                _LOGGER.error("Can't validate %s, snapshot data -> %s",
+                              self._id, humanize_error(data, err))
+                return False
+
+            # restore data / reload addon
+            self._restore_data(data[ATTR_USER], data[ATTR_SYSTEM])
+
+            # check version / restore image
+            version = data[ATTR_VERSION]
+            if version != self.addon_docker.version:
+                image_file = Path(temp, "image.tar")
+                if image_file.is_file():
+                    await self.addon_docker.import_image(image_file, version)
+                else:
+                    if await self.addon_docker.install(version):
+                        await self.addon_docker.cleanup()
+            else:
+                await self.addon_docker.stop()
+
+            # restore data
+            def _restore_data():
+                """Restore data."""
+                if self.path_data.is_dir():
+                    shutil.rmtree(str(self.path_data), ignore_errors=True)
+                shutil.copytree(str(Path(temp, "data")), str(self.path_data))
+
+            try:
+                await self.loop.run_in_executor(None, _restore_data)
+            except shutil.Error as err:
+                _LOGGER.error("Can't restore origin data -> %s", err)
+                return False
+
+            # run addon
+            if data[ATTR_STATE] == STATE_STARTED:
+                return await self.start()
+
+        return True

hassio/addons/built-in.json

@@ -1,12 +1,10 @@
 {
     "local": {
-        "slug": "local",
         "name": "Local Add-Ons",
         "url": "https://home-assistant.io/hassio",
         "maintainer": "By our self"
     },
     "core": {
-        "slug": "core",
         "name": "Built-in Add-Ons",
         "url": "https://home-assistant.io/addons",
         "maintainer": "Home Assistant authors"

hassio/addons/data.py

@@ -2,7 +2,7 @@
 import copy
 import logging
 import json
-from pathlib import Path, PurePath
+from pathlib import Path
 import re
 
 import voluptuous as vol
@@ -10,53 +10,83 @@ from voluptuous.humanize import humanize_error
 
 from .util import extract_hash_from_path
 from .validate import (
-    validate_options, SCHEMA_ADDON_CONFIG, SCHEMA_REPOSITORY_CONFIG,
+    SCHEMA_ADDON_CONFIG, SCHEMA_ADDON_FILE, 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,
-    ATTR_SCHEMA, ATTR_IMAGE, ATTR_REPOSITORY, ATTR_URL, ATTR_ARCH,
-    ATTR_LOCATON, ATTR_DEVICES, ATTR_ENVIRONMENT, ATTR_HOST_NETWORK,
-    ATTR_TMPFS)
-from ..config import Config
+    FILE_HASSIO_ADDONS, ATTR_VERSION, ATTR_SLUG, ATTR_REPOSITORY, ATTR_LOCATON,
+    REPOSITORY_CORE, REPOSITORY_LOCAL, ATTR_USER, ATTR_SYSTEM)
 from ..tools import read_json_file, write_json_file
 
 _LOGGER = logging.getLogger(__name__)
 
-SYSTEM = 'system'
-USER = 'user'
-
-REPOSITORY_CORE = 'core'
-REPOSITORY_LOCAL = 'local'
-
 RE_VOLUME = re.compile(MAP_VOLUME)
 
 
-class AddonsData(Config):
+class Data(object):
     """Hold data for addons inside HassIO."""
 
     def __init__(self, config):
         """Initialize data holder."""
-        super().__init__(FILE_HASSIO_ADDONS)
+        self._file = FILE_HASSIO_ADDONS
+        self._data = {}
         self.config = config
-        self._system_data = self._data.get(SYSTEM, {})
-        self._user_data = self._data.get(USER, {})
-        self._addons_cache = {}
-        self._repositories_data = {}
-        self.arch = None
+        self._cache = {}
+        self._repositories = {}
+
+        # init or load data
+        if self._file.is_file():
+            try:
+                self._data = read_json_file(self._file)
+            except (OSError, json.JSONDecodeError):
+                _LOGGER.warning("Can't read %s", self._file)
+                self._data = {}
+
+        # validate
+        try:
+            self._data = SCHEMA_ADDON_FILE(self._data)
+        except vol.Invalid as ex:
+            _LOGGER.error("Can't parse addons.json -> %s",
+                          humanize_error(self._data, ex))
 
     def save(self):
         """Store data to config file."""
-        self._data = {
-            USER: self._user_data,
-            SYSTEM: self._system_data,
-        }
-        super().save()
+        # validate
+        try:
+            self._data = SCHEMA_ADDON_FILE(self._data)
+        except vol.Invalid as ex:
+            _LOGGER.error("Can't parse addons data -> %s",
+                          humanize_error(self._data, ex))
+            return False
 
-    def read_data_from_repositories(self):
+        if not write_json_file(self._file, self._data):
+            _LOGGER.error("Can't store config in %s", self._file)
+            return False
+        return True
+
+    @property
+    def user(self):
+        """Return local addon user data."""
+        return self._data[ATTR_USER]
+
+    @property
+    def system(self):
+        """Return local addon data."""
+        return self._data[ATTR_SYSTEM]
+
+    @property
+    def cache(self):
+        """Return addon data from cache/repositories."""
+        return self._cache
+
+    @property
+    def repositories(self):
+        """Return addon data from repositories."""
+        return self._repositories
+
+    def reload(self):
         """Read data from addons repository."""
-        self._addons_cache = {}
-        self._repositories_data = {}
+        self._cache = {}
+        self._repositories = {}
 
         # read core repository
         self._read_addons_folder(
@@ -74,19 +104,21 @@ class AddonsData(Config):
             if repository_element.is_dir():
                 self._read_git_repository(repository_element)
 
+        # update local data
+        self._merge_config()
+
     def _read_git_repository(self, path):
         """Process a custom repository folder."""
         slug = extract_hash_from_path(path)
-        repository_info = {ATTR_SLUG: slug}
 
         # exists repository json
         repository_file = Path(path, "repository.json")
         try:
-            repository_info.update(SCHEMA_REPOSITORY_CONFIG(
+            repository_info = SCHEMA_REPOSITORY_CONFIG(
                 read_json_file(repository_file)
-            ))
+            )
 
-        except OSError:
+        except (OSError, json.JSONDecodeError):
             _LOGGER.warning("Can't read repository information from %s",
                             repository_file)
             return
@@ -96,7 +128,7 @@ class AddonsData(Config):
             return
 
         # process data
-        self._repositories_data[slug] = repository_info
+        self._repositories[slug] = repository_info
         self._read_addons_folder(path, slug)
 
     def _read_addons_folder(self, path, repository):
@@ -115,7 +147,7 @@ class AddonsData(Config):
                 # store
                 addon_config[ATTR_REPOSITORY] = repository
                 addon_config[ATTR_LOCATON] = str(addon.parent)
-                self._addons_cache[addon_slug] = addon_config
+                self._cache[addon_slug] = addon_config
 
             except OSError:
                 _LOGGER.warning("Can't read %s", addon)
@@ -133,261 +165,32 @@ class AddonsData(Config):
             _LOGGER.warning("Can't read built-in.json -> %s", err)
             return
 
-        # if core addons are available
-        for data in self._addons_cache.values():
-            if data[ATTR_REPOSITORY] == REPOSITORY_CORE:
-                self._repositories_data[REPOSITORY_CORE] = \
-                    builtin_data[REPOSITORY_CORE]
-                break
+        # core repository
+        self._repositories[REPOSITORY_CORE] = \
+            builtin_data[REPOSITORY_CORE]
 
-        # if local addons are available
-        for data in self._addons_cache.values():
-            if data[ATTR_REPOSITORY] == REPOSITORY_LOCAL:
-                self._repositories_data[REPOSITORY_LOCAL] = \
-                    builtin_data[REPOSITORY_LOCAL]
-                break
+        # local repository
+        self._repositories[REPOSITORY_LOCAL] = \
+            builtin_data[REPOSITORY_LOCAL]
 
-    def merge_update_config(self):
+    def _merge_config(self):
         """Update local config if they have update.
 
-        It need to be the same version as the local version is.
+        It need to be the same version as the local version is for merge.
         """
         have_change = False
 
-        for addon in self.list_installed:
+        for addon in set(self.system):
             # detached
-            if addon not in self._addons_cache:
+            if addon not in self._cache:
                 continue
 
-            cache = self._addons_cache[addon]
-            data = self._system_data[addon]
+            cache = self._cache[addon]
+            data = self.system[addon]
             if data[ATTR_VERSION] == cache[ATTR_VERSION]:
                 if data != cache:
-                    self._system_data[addon] = copy.deepcopy(cache)
+                    self.system[addon] = copy.deepcopy(cache)
                     have_change = True
 
         if have_change:
             self.save()
-
-    @property
-    def list_installed(self):
-        """Return a list of installed addons."""
-        return set(self._system_data)
-
-    @property
-    def list_all(self):
-        """Return a dict of all addons."""
-        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."""
-        addon_list = set()
-        for addon in self._system_data.keys():
-            if self.get_boot(addon) != BOOT_AUTO:
-                continue
-
-            try:
-                if self._system_data[addon][ATTR_STARTUP] == start_type:
-                    addon_list.add(addon)
-            except KeyError:
-                _LOGGER.warning("Orphaned addon detect %s", addon)
-                continue
-
-        return addon_list
-
-    @property
-    def list_detached(self):
-        """Return local addons they not support from repo."""
-        addon_list = set()
-        for addon in self._system_data.keys():
-            if addon not in self._addons_cache:
-                addon_list.add(addon)
-
-        return addon_list
-
-    @property
-    def list_repositories(self):
-        """Return list of addon repositories."""
-        return list(self._repositories_data.values())
-
-    def exists_addon(self, addon):
-        """Return True if a addon exists."""
-        return addon in self._addons_cache or addon in self._system_data
-
-    def is_installed(self, addon):
-        """Return True if a addon is installed."""
-        return addon in self._system_data
-
-    def version_installed(self, addon):
-        """Return installed version."""
-        return self._user_data.get(addon, {}).get(ATTR_VERSION)
-
-    def set_addon_install(self, addon, version):
-        """Set addon as installed."""
-        self._system_data[addon] = copy.deepcopy(self._addons_cache[addon])
-        self._user_data[addon] = {
-            ATTR_OPTIONS: {},
-            ATTR_VERSION: version,
-        }
-        self.save()
-
-    def set_addon_uninstall(self, addon):
-        """Set addon as uninstalled."""
-        self._system_data.pop(addon, None)
-        self._user_data.pop(addon, None)
-        self.save()
-
-    def set_addon_update(self, addon, version):
-        """Update version of addon."""
-        self._system_data[addon] = copy.deepcopy(self._addons_cache[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] = copy.deepcopy(options)
-        self.save()
-
-    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."""
-        return {
-            **self._system_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._user_data[addon]:
-            return self._user_data[addon][ATTR_BOOT]
-
-        return self._system_data[addon][ATTR_BOOT]
-
-    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 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_network_mode(self, addon):
-        """Return network mode of addon."""
-        if self._system_data[addon][ATTR_HOST_NETWORK]:
-            return 'host'
-        return 'bridge'
-
-    def get_devices(self, addon):
-        """Return devices of addon."""
-        return self._system_data[addon].get(ATTR_DEVICES)
-
-    def get_tmpfs(self, addon):
-        """Return tmpfs of addon."""
-        return self._system_data[addon].get(ATTR_TMPFS)
-
-    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 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."""
-        addon_data = self._system_data.get(
-            addon, self._addons_cache.get(addon)
-        )
-
-        # Repository with dockerhub images
-        if ATTR_IMAGE in addon_data:
-            return addon_data[ATTR_IMAGE].format(arch=self.arch)
-
-        # 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."""
-        addon_data = self._system_data.get(
-            addon, self._addons_cache.get(addon)
-        )
-        return ATTR_IMAGE not in addon_data
-
-    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'
-
-        return volumes
-
-    def path_data(self, addon):
-        """Return addon data path inside supervisor."""
-        return Path(self.config.path_addons_data, addon)
-
-    def path_extern_data(self, addon):
-        """Return addon data path external for docker."""
-        return PurePath(self.config.path_extern_addons_data, addon)
-
-    def path_addon_options(self, addon):
-        """Return path to addons options."""
-        return Path(self.path_data(addon), "options.json")
-
-    def path_addon_location(self, addon):
-        """Return path to this addon."""
-        return Path(self._addons_cache[addon][ATTR_LOCATON])
-
-    def write_addon_options(self, addon):
-        """Return True if addon options is written to data."""
-        schema = self.get_schema(addon)
-        options = self.get_options(addon)
-
-        try:
-            schema(options)
-            return write_json_file(self.path_addon_options(addon), options)
-        except vol.Invalid as ex:
-            _LOGGER.error("Addon %s have wrong options -> %s", addon,
-                          humanize_error(options, ex))
-
-        return False
-
-    def get_schema(self, addon):
-        """Create a schema for addon options."""
-        raw_schema = self._system_data[addon][ATTR_SCHEMA]
-
-        schema = vol.Schema(vol.All(dict, validate_options(raw_schema)))
-        return schema

hassio/addons/git.py

@@ -12,7 +12,7 @@ from ..const import URL_HASSIO_ADDONS
 _LOGGER = logging.getLogger(__name__)
 
 
-class AddonsRepo(object):
+class GitRepo(object):
     """Manage addons git repo."""
 
     def __init__(self, config, loop, path, url):
@@ -77,7 +77,7 @@ class AddonsRepo(object):
             return True
 
 
-class AddonsRepoHassIO(AddonsRepo):
+class GitRepoHassIO(GitRepo):
     """HassIO addons repository."""
 
     def __init__(self, config, loop):
@@ -86,7 +86,7 @@ class AddonsRepoHassIO(AddonsRepo):
             config, loop, config.path_addons_core, URL_HASSIO_ADDONS)
 
 
-class AddonsRepoCustom(AddonsRepo):
+class GitRepoCustom(GitRepo):
     """Custom addons repository."""
 
     def __init__(self, config, loop, url):

hassio/addons/repository.py

@@ -0,0 +1,71 @@
+"""Represent a HassIO repository."""
+from .git import GitRepoHassIO, GitRepoCustom
+from .util import get_hash_from_repository
+from ..const import (
+    REPOSITORY_CORE, REPOSITORY_LOCAL, ATTR_NAME, ATTR_URL, ATTR_MAINTAINER)
+
+UNKNOWN = 'unknown'
+
+
+class Repository(object):
+    """Repository in HassIO."""
+
+    def __init__(self, config, loop, data, repository):
+        """Initialize repository object."""
+        self.data = data
+        self.source = None
+        self.git = None
+
+        if repository == REPOSITORY_LOCAL:
+            self._id = repository
+        elif repository == REPOSITORY_CORE:
+            self._id = repository
+            self.git = GitRepoHassIO(config, loop)
+        else:
+            self._id = get_hash_from_repository(repository)
+            self.git = GitRepoCustom(config, loop, repository)
+            self.source = repository
+
+    @property
+    def _mesh(self):
+        """Return data struct repository."""
+        return self.data.repositories.get(self._id, {})
+
+    @property
+    def slug(self):
+        """Return slug of repository."""
+        return self._id
+
+    @property
+    def name(self):
+        """Return name of repository."""
+        return self._mesh.get(ATTR_NAME, UNKNOWN)
+
+    @property
+    def url(self):
+        """Return url of repository."""
+        return self._mesh.get(ATTR_URL, self.source)
+
+    @property
+    def maintainer(self):
+        """Return url of repository."""
+        return self._mesh.get(ATTR_MAINTAINER, UNKNOWN)
+
+    async def load(self):
+        """Load addon repository."""
+        if self.git:
+            return await self.git.load()
+        return True
+
+    async def update(self):
+        """Update addon repository."""
+        if self.git:
+            return await self.git.pull()
+        return True
+
+    def remove(self):
+        """Remove addon repository."""
+        if self._id in (REPOSITORY_CORE, REPOSITORY_LOCAL):
+            raise RuntimeError("Can't remove built-in repositories!")
+
+        self.git.remove()

hassio/addons/util.py

@@ -1,10 +1,12 @@
 """Util addons functions."""
 import hashlib
+import logging
 import re
 
-RE_SLUGIFY = re.compile(r'[^a-z0-9_]+')
 RE_SHA1 = re.compile(r"[a-f0-9]{8}")
 
+_LOGGER = logging.getLogger(__name__)
+
 
 def get_hash_from_repository(name):
     """Generate a hash from repository."""
@@ -21,6 +23,13 @@ def extract_hash_from_path(path):
     return repo_dir
 
 
-def create_hash_index_list(name_list):
-    """Create a dict with hash from repositories list."""
-    return {get_hash_from_repository(repo): repo for repo in name_list}
+def check_installed(method):
+    """Wrap function with check if addon is installed."""
+    async def wrap_check(addon, *args, **kwargs):
+        """Return False if not installed or the function."""
+        if not addon.is_installed:
+            _LOGGER.error("Addon %s is not installed", addon.slug)
+            return False
+        return await method(addon, *args, **kwargs)
+
+    return wrap_check

hassio/addons/validate.py

@@ -7,7 +7,10 @@ from ..const import (
     STARTUP_BEFORE, STARTUP_INITIALIZE, BOOT_AUTO, BOOT_MANUAL, ATTR_SCHEMA,
     ATTR_IMAGE, ATTR_URL, ATTR_MAINTAINER, ATTR_ARCH, ATTR_DEVICES,
     ATTR_ENVIRONMENT, ATTR_HOST_NETWORK, ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64,
-    ARCH_I386, ATTR_TMPFS)
+    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_AUTO_UPDATE)
+from ..validate import NETWORK_PORT, DOCKER_PORTS
 
 
 MAP_VOLUME = r"^(config|ssl|addons|backup|share)(?::(rw|:ro))?$"
@@ -18,26 +21,21 @@ V_FLOAT = 'float'
 V_BOOL = 'bool'
 V_EMAIL = 'email'
 V_URL = 'url'
+V_PORT = 'port'
 
-ADDON_ELEMENT = vol.In([V_STR, V_INT, V_FLOAT, V_BOOL, V_EMAIL, V_URL])
+ADDON_ELEMENT = vol.In([V_STR, V_INT, V_FLOAT, V_BOOL, V_EMAIL, V_URL, V_PORT])
 
 ARCH_ALL = [
     ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386
 ]
 
-
-def check_network(data):
-    """Validate network settings."""
-    host_network = data[ATTR_HOST_NETWORK]
-
-    if ATTR_PORTS in data and host_network:
-        raise vol.Invalid("Hostnetwork & ports are not allow!")
-
-    return data
+PRIVILEGE_ALL = [
+    "NET_ADMIN"
+]
 
 
 # pylint: disable=no-value-for-parameter
-SCHEMA_ADDON_CONFIG = vol.Schema(vol.All({
+SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Required(ATTR_NAME): vol.Coerce(str),
     vol.Required(ATTR_VERSION): vol.Coerce(str),
     vol.Required(ATTR_SLUG): vol.Coerce(str),
@@ -49,21 +47,24 @@ SCHEMA_ADDON_CONFIG = vol.Schema(vol.All({
                 STARTUP_INITIALIZE]),
     vol.Required(ATTR_BOOT):
         vol.In([BOOT_AUTO, BOOT_MANUAL]),
-    vol.Optional(ATTR_PORTS): dict,
+    vol.Optional(ATTR_PORTS): DOCKER_PORTS,
     vol.Optional(ATTR_HOST_NETWORK, default=False): vol.Boolean(),
     vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
     vol.Optional(ATTR_TMPFS):
         vol.Match(r"^size=(\d)*[kmg](,uid=\d{1,4})?(,rw)?$"),
     vol.Optional(ATTR_MAP, default=[]): [vol.Match(MAP_VOLUME)],
     vol.Optional(ATTR_ENVIRONMENT): {vol.Match(r"\w*"): vol.Coerce(str)},
+    vol.Optional(ATTR_PRIVILEGED): [vol.In(PRIVILEGE_ALL)],
     vol.Required(ATTR_OPTIONS): dict,
-    vol.Required(ATTR_SCHEMA): {
+    vol.Required(ATTR_SCHEMA): vol.Any({
         vol.Coerce(str): vol.Any(ADDON_ELEMENT, [
             vol.Any(ADDON_ELEMENT, {vol.Coerce(str): ADDON_ELEMENT})
         ])
-    },
+    }, False),
     vol.Optional(ATTR_IMAGE): vol.Match(r"\w*/\w*"),
-}, check_network), extra=vol.ALLOW_EXTRA)
+    vol.Optional(ATTR_TIMEOUT, default=10):
+        vol.All(vol.Coerce(int), vol.Range(min=10, max=120))
+}, extra=vol.ALLOW_EXTRA)
 
 
 # pylint: disable=no-value-for-parameter
@@ -74,6 +75,41 @@ SCHEMA_REPOSITORY_CONFIG = vol.Schema({
 }, extra=vol.ALLOW_EXTRA)
 
 
+# pylint: disable=no-value-for-parameter
+SCHEMA_ADDON_USER = vol.Schema({
+    vol.Required(ATTR_VERSION): vol.Coerce(str),
+    vol.Required(ATTR_OPTIONS): dict,
+    vol.Optional(ATTR_AUTO_UPDATE, default=False): vol.Boolean(),
+    vol.Optional(ATTR_BOOT):
+        vol.In([BOOT_AUTO, BOOT_MANUAL]),
+    vol.Optional(ATTR_NETWORK): DOCKER_PORTS,
+})
+
+
+SCHEMA_ADDON_SYSTEM = SCHEMA_ADDON_CONFIG.extend({
+    vol.Required(ATTR_LOCATON): vol.Coerce(str),
+    vol.Required(ATTR_REPOSITORY): vol.Coerce(str),
+})
+
+
+SCHEMA_ADDON_FILE = vol.Schema({
+    vol.Optional(ATTR_USER, default={}): {
+        vol.Coerce(str): SCHEMA_ADDON_USER,
+    },
+    vol.Optional(ATTR_SYSTEM, default={}): {
+        vol.Coerce(str): SCHEMA_ADDON_SYSTEM,
+    }
+})
+
+
+SCHEMA_ADDON_SNAPSHOT = vol.Schema({
+    vol.Required(ATTR_USER): SCHEMA_ADDON_USER,
+    vol.Required(ATTR_SYSTEM): SCHEMA_ADDON_SYSTEM,
+    vol.Required(ATTR_STATE): vol.In([STATE_STARTED, STATE_STOPPED]),
+    vol.Required(ATTR_VERSION): vol.Coerce(str),
+})
+
+
 def validate_options(raw_schema):
     """Validate schema."""
     def validate(struct):
@@ -122,6 +158,8 @@ def _single_validate(typ, value, key):
             return vol.Email()(value)
         elif typ == V_URL:
             return vol.Url()(value)
+        elif typ == V_PORT:
+            return NETWORK_PORT(value)
 
         raise vol.Invalid("Fatal error for {} type {}.".format(key, typ))
     except ValueError:

hassio/api/__init__.py

@@ -10,6 +10,7 @@ from .host import APIHost
 from .network import APINetwork
 from .supervisor import APISupervisor
 from .security import APISecurity
+from .snapshots import APISnapshots
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -43,10 +44,12 @@ class RestAPI(object):
         self.webapp.router.add_get('/network/info', api_net.info)
         self.webapp.router.add_post('/network/options', api_net.options)
 
-    def register_supervisor(self, supervisor, addons, host_control):
+    def register_supervisor(self, supervisor, snapshots, addons, host_control,
+                            websession):
         """Register supervisor function."""
         api_supervisor = APISupervisor(
-            self.config, self.loop, supervisor, addons, host_control)
+            self.config, self.loop, supervisor, snapshots, addons,
+            host_control, websession)
 
         self.webapp.router.add_get('/supervisor/ping', api_supervisor.ping)
         self.webapp.router.add_get('/supervisor/info', api_supervisor.info)
@@ -98,6 +101,25 @@ 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_snapshots(self, snapshots):
+        """Register snapshots function."""
+        api_snapshots = APISnapshots(self.config, self.loop, snapshots)
+
+        self.webapp.router.add_post(
+            '/snapshots/new/full', api_snapshots.snapshot_full)
+        self.webapp.router.add_post(
+            '/snapshots/new/partial', api_snapshots.snapshot_partial)
+
+        self.webapp.router.add_get(
+            '/snapshots/{snapshot}/info', api_snapshots.info)
+        self.webapp.router.add_post(
+            '/snapshots/{snapshot}/remove', api_snapshots.remove)
+        self.webapp.router.add_post(
+            '/snapshots/{snapshot}/restore/full', api_snapshots.restore_full)
+        self.webapp.router.add_post(
+            '/snapshots/{snapshot}/restore/partial',
+            api_snapshots.restore_partial)
+
     def register_panel(self):
         """Register panel for homeassistant."""
         panel = Path(__file__).parents[1].joinpath('panel/hassio-main.html')

hassio/api/addons.py

@@ -9,7 +9,9 @@ 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,
-    ATTR_BUILD, STATE_STOPPED, STATE_STARTED, BOOT_AUTO, BOOT_MANUAL)
+    ATTR_BUILD, ATTR_AUTO_UPDATE, ATTR_NETWORK, ATTR_HOST_NETWORK,
+    BOOT_AUTO, BOOT_MANUAL)
+from ..validate import DOCKER_PORTS
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -17,8 +19,11 @@ SCHEMA_VERSION = vol.Schema({
     vol.Optional(ATTR_VERSION): vol.Coerce(str),
 })
 
+# pylint: disable=no-value-for-parameter
 SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL])
+    vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL]),
+    vol.Optional(ATTR_NETWORK): vol.Any(None, DOCKER_PORTS),
+    vol.Optional(ATTR_AUTO_UPDATE): vol.Boolean(),
 })
 
 
@@ -33,12 +38,11 @@ class APIAddons(object):
 
     def _extract_addon(self, request, check_installed=True):
         """Return addon and if not exists trow a exception."""
-        addon = request.match_info.get('addon')
-
-        # check data
-        if not self.addons.exists_addon(addon):
+        addon = self.addons.get(request.match_info.get('addon'))
+        if not addon:
             raise RuntimeError("Addon not exists")
-        if check_installed and not self.addons.is_installed(addon):
+
+        if check_installed and not addon.is_installed:
             raise RuntimeError("Addon is not installed")
 
         return addon
@@ -46,38 +50,44 @@ class APIAddons(object):
     @api_process
     async def info(self, request):
         """Return addon information."""
-        addon = self._extract_addon(request)
+        addon = self._extract_addon(request, check_installed=False)
 
         return {
-            ATTR_NAME: self.addons.get_name(addon),
-            ATTR_DESCRIPTON: self.addons.get_description(addon),
-            ATTR_VERSION: self.addons.version_installed(addon),
-            ATTR_REPOSITORY: self.addons.get_repository(addon),
-            ATTR_LAST_VERSION: self.addons.get_last_version(addon),
-            ATTR_STATE: await self.addons.state(addon),
-            ATTR_BOOT: self.addons.get_boot(addon),
-            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),
+            ATTR_NAME: addon.name,
+            ATTR_DESCRIPTON: addon.description,
+            ATTR_VERSION: addon.version_installed,
+            ATTR_AUTO_UPDATE: addon.auto_update,
+            ATTR_REPOSITORY: addon.repository,
+            ATTR_LAST_VERSION: addon.last_version,
+            ATTR_STATE: await addon.state(),
+            ATTR_BOOT: addon.boot,
+            ATTR_OPTIONS: addon.options,
+            ATTR_URL: addon.url,
+            ATTR_DETACHED: addon.is_detached,
+            ATTR_BUILD: addon.need_build,
+            ATTR_NETWORK: addon.ports,
+            ATTR_HOST_NETWORK: addon.network_mode == 'host',
         }
 
     @api_process
     async def options(self, request):
         """Store user options for addon."""
         addon = self._extract_addon(request)
-        options_schema = self.addons.get_schema(addon)
 
         addon_schema = SCHEMA_OPTIONS.extend({
-            vol.Optional(ATTR_OPTIONS): options_schema,
+            vol.Optional(ATTR_OPTIONS): addon.schema,
         })
 
         body = await api_validate(addon_schema, request)
 
         if ATTR_OPTIONS in body:
-            self.addons.set_options(addon, body[ATTR_OPTIONS])
+            addon.options = body[ATTR_OPTIONS]
         if ATTR_BOOT in body:
-            self.addons.set_boot(addon, body[ATTR_BOOT])
+            addon.boot = body[ATTR_BOOT]
+        if ATTR_AUTO_UPDATE in body:
+            addon.auto_update = body[ATTR_AUTO_UPDATE]
+        if ATTR_NETWORK in body:
+            addon.ports = body[ATTR_NETWORK]
 
         return True
 
@@ -86,77 +96,55 @@ class APIAddons(object):
         """Install addon."""
         body = await api_validate(SCHEMA_VERSION, request)
         addon = self._extract_addon(request, check_installed=False)
-        version = body.get(
-            ATTR_VERSION, self.addons.get_last_version(addon))
-
-        # check if arch supported
-        if self.addons.arch not in self.addons.get_arch(addon):
-            raise RuntimeError(
-                "Addon is not supported on {}".format(self.addons.arch))
+        version = body.get(ATTR_VERSION)
 
         return await asyncio.shield(
-            self.addons.install(addon, version), loop=self.loop)
+            addon.install(version=version), loop=self.loop)
 
     @api_process
     async def uninstall(self, request):
         """Uninstall addon."""
         addon = self._extract_addon(request)
-
-        return await asyncio.shield(
-            self.addons.uninstall(addon), loop=self.loop)
+        return await asyncio.shield(addon.uninstall(), loop=self.loop)
 
     @api_process
     async def start(self, request):
         """Start addon."""
         addon = self._extract_addon(request)
 
-        if await self.addons.state(addon) == STATE_STARTED:
-            raise RuntimeError("Addon is already running")
-
-        # validate options
+        # check options
+        options = addon.options
         try:
-            schema = self.addons.get_schema(addon)
-            options = self.addons.get_options(addon)
-            schema(options)
+            addon.schema(options)
         except vol.Invalid as ex:
             raise RuntimeError(humanize_error(options, ex)) from None
 
-        return await asyncio.shield(
-            self.addons.start(addon), loop=self.loop)
+        return await asyncio.shield(addon.start(), loop=self.loop)
 
     @api_process
     async def stop(self, request):
         """Stop addon."""
         addon = self._extract_addon(request)
-
-        if await self.addons.state(addon) == STATE_STOPPED:
-            raise RuntimeError("Addon is already stoped")
-
-        return await asyncio.shield(
-            self.addons.stop(addon), loop=self.loop)
+        return await asyncio.shield(addon.stop(), loop=self.loop)
 
     @api_process
     async def update(self, request):
         """Update addon."""
         body = await api_validate(SCHEMA_VERSION, request)
         addon = self._extract_addon(request)
-        version = body.get(
-            ATTR_VERSION, self.addons.get_last_version(addon))
-
-        if version == self.addons.version_installed(addon):
-            raise RuntimeError("Version is already in use")
+        version = body.get(ATTR_VERSION)
 
         return await asyncio.shield(
-            self.addons.update(addon, version), loop=self.loop)
+            addon.update(version=version), loop=self.loop)
 
     @api_process
     async def restart(self, request):
         """Restart addon."""
         addon = self._extract_addon(request)
-        return await asyncio.shield(self.addons.restart(addon), loop=self.loop)
+        return await asyncio.shield(addon.restart(), loop=self.loop)
 
     @api_process_raw
     def logs(self, request):
         """Return logs from addon."""
         addon = self._extract_addon(request)
-        return self.addons.logs(addon)
+        return addon.logs()

hassio/api/homeassistant.py

@@ -6,12 +6,13 @@ import voluptuous as vol
 
 from .util import api_process, api_process_raw, api_validate
 from ..const import ATTR_VERSION, ATTR_LAST_VERSION, ATTR_DEVICES
+from ..validate import HASS_DEVICES
 
 _LOGGER = logging.getLogger(__name__)
 
 
 SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_DEVICES): [vol.Coerce(str)],
+    vol.Optional(ATTR_DEVICES): HASS_DEVICES,
 })
 
 SCHEMA_VERSION = vol.Schema({

hassio/api/snapshots.py

@@ -0,0 +1,117 @@
+"""Init file for HassIO snapshot rest api."""
+import asyncio
+import logging
+
+import voluptuous as vol
+
+from .util import api_process, api_validate
+from ..snapshots.validate import ALL_FOLDERS
+from ..const import (
+    ATTR_NAME, ATTR_SLUG, ATTR_DATE, ATTR_ADDONS, ATTR_REPOSITORIES,
+    ATTR_HOMEASSISTANT, ATTR_VERSION, ATTR_SIZE, ATTR_FOLDERS, ATTR_TYPE,
+    ATTR_DEVICES)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_RESTORE_PARTIAL = vol.Schema({
+    vol.Optional(ATTR_HOMEASSISTANT): vol.Boolean(),
+    vol.Optional(ATTR_ADDONS): [vol.Coerce(str)],
+    vol.Optional(ATTR_FOLDERS): [vol.In(ALL_FOLDERS)],
+})
+
+SCHEMA_SNAPSHOT_FULL = vol.Schema({
+    vol.Optional(ATTR_NAME): vol.Coerce(str),
+})
+
+SCHEMA_SNAPSHOT_PARTIAL = SCHEMA_SNAPSHOT_FULL.extend({
+    vol.Optional(ATTR_ADDONS): [vol.Coerce(str)],
+    vol.Optional(ATTR_FOLDERS): [vol.In(ALL_FOLDERS)],
+})
+
+
+class APISnapshots(object):
+    """Handle rest api for snapshot functions."""
+
+    def __init__(self, config, loop, snapshots):
+        """Initialize network rest api part."""
+        self.config = config
+        self.loop = loop
+        self.snapshots = snapshots
+
+    def _extract_snapshot(self, request):
+        """Return addon and if not exists trow a exception."""
+        snapshot = self.snapshots.get(request.match_info.get('snapshot'))
+        if not snapshot:
+            raise RuntimeError("Snapshot not exists")
+        return snapshot
+
+    @staticmethod
+    def _addons_list(snapshot):
+        """Generate a list with addons data."""
+        data = []
+        for addon_data in snapshot.addons:
+            data.append({
+                ATTR_SLUG: addon_data[ATTR_SLUG],
+                ATTR_NAME: addon_data[ATTR_NAME],
+                ATTR_VERSION: addon_data[ATTR_VERSION],
+            })
+        return data
+
+    @api_process
+    async def info(self, request):
+        """Return snapshot info."""
+        snapshot = self._extract_snapshot(request)
+
+        return {
+            ATTR_SLUG: snapshot.slug,
+            ATTR_TYPE: snapshot.sys_type,
+            ATTR_NAME: snapshot.name,
+            ATTR_DATE: snapshot.date,
+            ATTR_SIZE: snapshot.size,
+            ATTR_HOMEASSISTANT: {
+                ATTR_VERSION: snapshot.homeassistant_version,
+                ATTR_DEVICES: snapshot.homeassistant_devices,
+            },
+            ATTR_ADDONS: self._addons_list(snapshot),
+            ATTR_REPOSITORIES: snapshot.repositories,
+            ATTR_FOLDERS: snapshot.folders,
+        }
+
+    @api_process
+    async def snapshot_full(self, request):
+        """Full-Snapshot a snapshot."""
+        body = await api_validate(SCHEMA_SNAPSHOT_FULL, request)
+        return await asyncio.shield(
+            self.snapshots.do_snapshot_full(**body), loop=self.loop)
+
+    @api_process
+    async def snapshot_partial(self, request):
+        """Partial-Snapshot a snapshot."""
+        body = await api_validate(SCHEMA_SNAPSHOT_PARTIAL, request)
+        return await asyncio.shield(
+            self.snapshots.do_snapshot_partial(**body), loop=self.loop)
+
+    @api_process
+    async def restore_full(self, request):
+        """Full-Restore a snapshot."""
+        snapshot = self._extract_snapshot(request)
+        return await asyncio.shield(
+            self.snapshots.do_restore_full(snapshot), loop=self.loop)
+
+    @api_process
+    async def restore_partial(self, request):
+        """Partial-Restore a snapshot."""
+        snapshot = self._extract_snapshot(request)
+        body = await api_validate(SCHEMA_SNAPSHOT_PARTIAL, request)
+
+        return await asyncio.shield(
+            self.snapshots.do_restore_partial(snapshot, **body),
+            loop=self.loop)
+
+    @api_process
+    async def remove(self, request):
+        """Remove a snapshot."""
+        snapshot = self._extract_snapshot(request)
+        return self.snapshots.remove(snapshot)

hassio/api/supervisor.py

@@ -5,13 +5,12 @@ import logging
 import voluptuous as vol
 
 from .util import api_process, api_process_raw, api_validate
-from ..addons.util import create_hash_index_list
 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_BUILD, ATTR_TIMEZONE)
+    ATTR_BUILD, ATTR_TIMEZONE, ATTR_DATE, ATTR_SNAPSHOTS)
 from ..tools import validate_timezone
 
 _LOGGER = logging.getLogger(__name__)
@@ -31,36 +30,35 @@ SCHEMA_VERSION = vol.Schema({
 class APISupervisor(object):
     """Handle rest api for supervisor functions."""
 
-    def __init__(self, config, loop, supervisor, addons, host_control):
+    def __init__(self, config, loop, supervisor, snapshots, addons,
+                 host_control, websession):
         """Initialize supervisor rest api part."""
         self.config = config
         self.loop = loop
         self.supervisor = supervisor
         self.addons = addons
+        self.snapshots = snapshots
         self.host_control = host_control
+        self.websession = websession
 
     def _addons_list(self, only_installed=False):
         """Return a list of addons."""
-        detached = self.addons.list_detached
-
-        if only_installed:
-            addons = self.addons.list_installed
-        else:
-            addons = self.addons.list_all
-
         data = []
-        for addon in addons:
+        for addon in self.addons.list_addons:
+            if only_installed and not addon.is_installed:
+                continue
+
             data.append({
-                ATTR_NAME: self.addons.get_name(addon),
-                ATTR_SLUG: addon,
-                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: self.addons.get_repository(addon),
-                ATTR_BUILD: self.addons.need_build(addon),
-                ATTR_URL: self.addons.get_url(addon),
+                ATTR_NAME: addon.name,
+                ATTR_SLUG: addon.slug,
+                ATTR_DESCRIPTON: addon.description,
+                ATTR_VERSION: addon.last_version,
+                ATTR_INSTALLED: addon.version_installed,
+                ATTR_ARCH: addon.supported_arch,
+                ATTR_DETACHED: addon.is_detached,
+                ATTR_REPOSITORY: addon.repository,
+                ATTR_BUILD: addon.need_build,
+                ATTR_URL: addon.url,
             })
 
         return data
@@ -68,15 +66,25 @@ class APISupervisor(object):
     def _repositories_list(self):
         """Return a list of addons repositories."""
         data = []
-        list_id = create_hash_index_list(self.config.addons_repositories)
-
         for repository in self.addons.list_repositories:
             data.append({
-                ATTR_SLUG: repository[ATTR_SLUG],
-                ATTR_NAME: repository[ATTR_NAME],
-                ATTR_SOURCE: list_id.get(repository[ATTR_SLUG]),
-                ATTR_URL: repository.get(ATTR_URL),
-                ATTR_MAINTAINER: repository.get(ATTR_MAINTAINER),
+                ATTR_SLUG: repository.slug,
+                ATTR_NAME: repository.name,
+                ATTR_SOURCE: repository.source,
+                ATTR_URL: repository.url,
+                ATTR_MAINTAINER: repository.maintainer,
+            })
+
+        return data
+
+    def _snapshots_list(self):
+        """Return a list of available snapshots."""
+        data = []
+        for snapshot in self.snapshots.list_snapshots:
+            data.append({
+                ATTR_SLUG: snapshot.slug,
+                ATTR_NAME: snapshot.name,
+                ATTR_DATE: snapshot.date,
             })
 
         return data
@@ -93,10 +101,11 @@ class APISupervisor(object):
             ATTR_VERSION: HASSIO_VERSION,
             ATTR_LAST_VERSION: self.config.last_hassio,
             ATTR_BETA_CHANNEL: self.config.upstream_beta,
-            ATTR_ARCH: self.addons.arch,
+            ATTR_ARCH: self.config.arch,
             ATTR_TIMEZONE: self.config.timezone,
             ATTR_ADDONS: self._addons_list(only_installed=True),
             ATTR_ADDONS_REPOSITORIES: self.config.addons_repositories,
+            ATTR_SNAPSHOTS: self._snapshots_list(),
         }
 
     @api_process
@@ -120,21 +129,7 @@ class APISupervisor(object):
 
         if ATTR_ADDONS_REPOSITORIES in body:
             new = set(body[ATTR_ADDONS_REPOSITORIES])
-            old = set(self.config.addons_repositories)
-
-            # add new repositories
-            tasks = [self.addons.add_git_repository(url) for url in
-                     set(new - old)]
-            if tasks:
-                await asyncio.shield(
-                    asyncio.wait(tasks, loop=self.loop), loop=self.loop)
-
-            # remove old repositories
-            for url in set(old - new):
-                self.addons.drop_git_repository(url)
-
-            # read repository
-            self.addons.read_data_from_repositories()
+            await asyncio.shield(self.addons.load_repositories(new))
 
         return True
 
@@ -154,7 +149,9 @@ class APISupervisor(object):
     async def reload(self, request):
         """Reload addons, config ect."""
         tasks = [
-            self.addons.reload(), self.config.fetch_update_infos(),
+            self.addons.reload(),
+            self.snapshots.reload(),
+            self.config.fetch_update_infos(self.websession),
             self.host_control.load()
         ]
         results, _ = await asyncio.shield(

hassio/api/util.py

@@ -81,6 +81,9 @@ def api_process_raw(method):
 
 def api_return_error(message=None):
     """Return a API error message."""
+    if message:
+        _LOGGER.error(message)
+
     return web.json_response({
         JSON_RESULT: RESULT_ERROR,
         JSON_MESSAGE: message,

hassio/bootstrap.py

@@ -2,6 +2,7 @@
 import logging
 import os
 import signal
+from pathlib import Path
 
 from colorlog import ColoredFormatter
 
@@ -11,9 +12,9 @@ from .config import CoreConfig
 _LOGGER = logging.getLogger(__name__)
 
 
-def initialize_system_data(websession):
+def initialize_system_data():
     """Setup default config and create folders."""
-    config = CoreConfig(websession)
+    config = CoreConfig()
 
     # homeassistant config folder
     if not config.path_config.is_dir():
@@ -42,10 +43,10 @@ def initialize_system_data(websession):
                      config.path_addons_git)
         config.path_addons_git.mkdir(parents=True)
 
-    if not config.path_addons_build.is_dir():
-        _LOGGER.info("Create Home-Assistant addon build folder %s",
-                     config.path_addons_build)
-        config.path_addons_build.mkdir(parents=True)
+    # hassio tmp folder
+    if not config.path_tmp.is_dir():
+        _LOGGER.info("Create hassio temp folder %s", config.path_tmp)
+        config.path_tmp.mkdir(parents=True)
 
     # hassio backup folder
     if not config.path_backup.is_dir():
@@ -60,6 +61,18 @@ def initialize_system_data(websession):
     return config
 
 
+def migrate_system_env(config):
+    """Cleanup some stuff after update."""
+
+    # hass.io 0.37 -> 0.38
+    old_build = Path(config.path_hassio, "addons/build")
+    if old_build.is_dir():
+        try:
+            old_build.rmdir()
+        except OSError:
+            _LOGGER.warning("Can't cleanup old addons build dir.")
+
+
 def initialize_logging():
     """Setup the logging."""
     logging.basicConfig(level=logging.INFO)

hassio/config.py

@@ -8,9 +8,10 @@ from pathlib import Path, PurePath
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
-from .const import FILE_HASSIO_CONFIG, HASSIO_SHARE
+from .const import FILE_HASSIO_CONFIG, HASSIO_DATA
 from .tools import (
     fetch_last_versions, write_json_file, read_json_file, validate_timezone)
+from .validate import HASS_DEVICES
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -27,12 +28,11 @@ ADDONS_CORE = PurePath("addons/core")
 ADDONS_LOCAL = PurePath("addons/local")
 ADDONS_GIT = PurePath("addons/git")
 ADDONS_DATA = PurePath("addons/data")
-ADDONS_BUILD = PurePath("addons/build")
 ADDONS_CUSTOM_LIST = 'addons_custom_list'
 
 BACKUP_DATA = PurePath("backup")
-
 SHARE_DATA = PurePath("share")
+TMP_DATA = PurePath("tmp")
 
 UPSTREAM_BETA = 'upstream_beta'
 API_ENDPOINT = 'api_endpoint'
@@ -50,7 +50,7 @@ SCHEMA_CONFIG = vol.Schema({
     vol.Optional(API_ENDPOINT): vol.Coerce(str),
     vol.Optional(TIMEZONE, default='UTC'): validate_timezone,
     vol.Optional(HOMEASSISTANT_LAST): vol.Coerce(str),
-    vol.Optional(HOMEASSISTANT_DEVICES, default=[]): [vol.Coerce(str)],
+    vol.Optional(HOMEASSISTANT_DEVICES, default=[]): HASS_DEVICES,
     vol.Optional(HASSIO_LAST): vol.Coerce(str),
     vol.Optional(ADDONS_CUSTOM_LIST, default=[]): [vol.Url()],
     vol.Optional(SECURITY_INITIALIZE, default=False): vol.Boolean(),
@@ -61,12 +61,13 @@ SCHEMA_CONFIG = vol.Schema({
 }, extra=vol.REMOVE_EXTRA)
 
 
-class Config(object):
-    """Hold all config data."""
+class CoreConfig(object):
+    """Hold all core config data."""
 
-    def __init__(self, config_file):
+    def __init__(self):
         """Initialize config object."""
-        self._file = config_file
+        self.arch = None
+        self._file = FILE_HASSIO_CONFIG
         self._data = {}
 
         # init or load data
@@ -77,35 +78,35 @@ class Config(object):
                 _LOGGER.warning("Can't read %s", self._file)
                 self._data = {}
 
+        # validate data
+        if not self._validate_config():
+            self._data = SCHEMA_CONFIG({})
+
+    def _validate_config(self):
+        """Validate config and return True or False."""
+        # validate data
+        try:
+            self._data = SCHEMA_CONFIG(self._data)
+        except vol.Invalid as ex:
+            _LOGGER.warning(
+                "Invalid config %s", humanize_error(self._data, ex))
+            return False
+
+        return True
+
     def save(self):
         """Store data to config file."""
+        if not self._validate_config():
+            return False
+
         if not write_json_file(self._file, self._data):
             _LOGGER.error("Can't store config in %s", self._file)
             return False
         return True
 
-
-class CoreConfig(Config):
-    """Hold all core config data."""
-
-    def __init__(self, websession):
-        """Initialize config object."""
-        self.websession = websession
-
-        super().__init__(FILE_HASSIO_CONFIG)
-
-        # validate data
-        try:
-            self._data = SCHEMA_CONFIG(self._data)
-            self.save()
-        except vol.Invalid as ex:
-            _LOGGER.warning(
-                "Invalid config %s", humanize_error(self._data, ex))
-
-    async def fetch_update_infos(self):
+    async def fetch_update_infos(self, websession):
         """Read current versions from web."""
-        last = await fetch_last_versions(
-            self.websession, beta=self.upstream_beta)
+        last = await fetch_last_versions(websession, beta=self.upstream_beta)
 
         if last:
             self._data.update({
@@ -175,6 +176,11 @@ class CoreConfig(Config):
         """Actual version of hassio."""
         return self._data.get(HASSIO_LAST)
 
+    @property
+    def path_hassio(self):
+        """Return hassio data path."""
+        return HASSIO_DATA
+
     @property
     def path_extern_hassio(self):
         """Return hassio data path extern for docker."""
@@ -188,7 +194,7 @@ class CoreConfig(Config):
     @property
     def path_config(self):
         """Return config path inside supervisor."""
-        return Path(HASSIO_SHARE, HOMEASSISTANT_CONFIG)
+        return Path(HASSIO_DATA, HOMEASSISTANT_CONFIG)
 
     @property
     def path_extern_ssl(self):
@@ -198,22 +204,22 @@ class CoreConfig(Config):
     @property
     def path_ssl(self):
         """Return SSL path inside supervisor."""
-        return Path(HASSIO_SHARE, HASSIO_SSL)
+        return Path(HASSIO_DATA, HASSIO_SSL)
 
     @property
     def path_addons_core(self):
         """Return git path for core addons."""
-        return Path(HASSIO_SHARE, ADDONS_CORE)
+        return Path(HASSIO_DATA, ADDONS_CORE)
 
     @property
     def path_addons_git(self):
         """Return path for git addons."""
-        return Path(HASSIO_SHARE, ADDONS_GIT)
+        return Path(HASSIO_DATA, ADDONS_GIT)
 
     @property
     def path_addons_local(self):
         """Return path for customs addons."""
-        return Path(HASSIO_SHARE, ADDONS_LOCAL)
+        return Path(HASSIO_DATA, ADDONS_LOCAL)
 
     @property
     def path_extern_addons_local(self):
@@ -223,7 +229,7 @@ class CoreConfig(Config):
     @property
     def path_addons_data(self):
         """Return root addon data folder."""
-        return Path(HASSIO_SHARE, ADDONS_DATA)
+        return Path(HASSIO_DATA, ADDONS_DATA)
 
     @property
     def path_extern_addons_data(self):
@@ -231,14 +237,14 @@ class CoreConfig(Config):
         return PurePath(self.path_extern_hassio, ADDONS_DATA)
 
     @property
-    def path_addons_build(self):
-        """Return root addon build folder."""
-        return Path(HASSIO_SHARE, ADDONS_BUILD)
+    def path_tmp(self):
+        """Return hass.io temp folder."""
+        return Path(HASSIO_DATA, TMP_DATA)
 
     @property
     def path_backup(self):
         """Return root backup data folder."""
-        return Path(HASSIO_SHARE, BACKUP_DATA)
+        return Path(HASSIO_DATA, BACKUP_DATA)
 
     @property
     def path_extern_backup(self):
@@ -248,7 +254,7 @@ class CoreConfig(Config):
     @property
     def path_share(self):
         """Return root share data folder."""
-        return Path(HASSIO_SHARE, SHARE_DATA)
+        return Path(HASSIO_DATA, SHARE_DATA)
 
     @property
     def path_extern_share(self):

hassio/const.py

@@ -1,7 +1,7 @@
 """Const file for HassIO."""
 from pathlib import Path
 
-HASSIO_VERSION = '0.35'
+HASSIO_VERSION = '0.40'
 
 URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
                       'hassio/master/version.json')
@@ -10,18 +10,20 @@ URL_HASSIO_VERSION_BETA = ('https://raw.githubusercontent.com/home-assistant/'
 
 URL_HASSIO_ADDONS = 'https://github.com/home-assistant/hassio-addons'
 
-HASSIO_SHARE = Path("/data")
+HASSIO_DATA = Path("/data")
 
 RUN_UPDATE_INFO_TASKS = 28800
 RUN_UPDATE_SUPERVISOR_TASKS = 29100
+RUN_UPDATE_ADDONS_TASKS = 57600
 RUN_RELOAD_ADDONS_TASKS = 28800
+RUN_RELOAD_SNAPSHOTS_TASKS = 72000
 RUN_WATCHDOG_HOMEASSISTANT = 15
 RUN_CLEANUP_API_SESSIONS = 900
 
 RESTART_EXIT_CODE = 100
 
-FILE_HASSIO_ADDONS = Path(HASSIO_SHARE, "addons.json")
-FILE_HASSIO_CONFIG = Path(HASSIO_SHARE, "config.json")
+FILE_HASSIO_ADDONS = Path(HASSIO_DATA, "addons.json")
+FILE_HASSIO_CONFIG = Path(HASSIO_DATA, "config.json")
 
 SOCKET_DOCKER = Path("/var/run/docker.sock")
 SOCKET_HC = Path("/var/run/hassio-hc.sock")
@@ -41,6 +43,7 @@ JSON_MESSAGE = 'message'
 RESULT_ERROR = 'error'
 RESULT_OK = 'ok'
 
+ATTR_DATE = 'date'
 ATTR_ARCH = 'arch'
 ATTR_HOSTNAME = 'hostname'
 ATTR_TIMEZONE = 'timezone'
@@ -79,7 +82,18 @@ ATTR_BUILD = 'build'
 ATTR_DEVICES = 'devices'
 ATTR_ENVIRONMENT = 'environment'
 ATTR_HOST_NETWORK = 'host_network'
+ATTR_NETWORK = 'network'
 ATTR_TMPFS = 'tmpfs'
+ATTR_PRIVILEGED = 'privileged'
+ATTR_USER = 'user'
+ATTR_SYSTEM = 'system'
+ATTR_SNAPSHOTS = 'snapshots'
+ATTR_HOMEASSISTANT = 'homeassistant'
+ATTR_FOLDERS = 'folders'
+ATTR_SIZE = 'size'
+ATTR_TYPE = 'type'
+ATTR_TIMEOUT = 'timeout'
+ATTR_AUTO_UPDATE = 'auto_update'
 
 STARTUP_INITIALIZE = 'initialize'
 STARTUP_BEFORE = 'before'
@@ -91,6 +105,7 @@ BOOT_MANUAL = 'manual'
 
 STATE_STARTED = 'started'
 STATE_STOPPED = 'stopped'
+STATE_NONE = 'none'
 
 MAP_CONFIG = 'config'
 MAP_SSL = 'ssl'
@@ -102,3 +117,14 @@ ARCH_ARMHF = 'armhf'
 ARCH_AARCH64 = 'aarch64'
 ARCH_AMD64 = 'amd64'
 ARCH_I386 = 'i386'
+
+REPOSITORY_CORE = 'core'
+REPOSITORY_LOCAL = 'local'
+
+FOLDER_HOMEASSISTANT = 'homeassistant'
+FOLDER_SHARE = 'share'
+FOLDER_ADDONS = 'addons/local'
+FOLDER_SSL = 'ssl'
+
+SNAPSHOT_FULL = 'full'
+SNAPSHOT_PARTIAL = 'partial'

hassio/core.py

@@ -5,7 +5,6 @@ import logging
 import aiohttp
 import docker
 
-from . import bootstrap
 from .addons import AddonManager
 from .api import RestAPI
 from .host_control import HostControl
@@ -13,14 +12,15 @@ from .const import (
     SOCKET_DOCKER, RUN_UPDATE_INFO_TASKS, RUN_RELOAD_ADDONS_TASKS,
     RUN_UPDATE_SUPERVISOR_TASKS, RUN_WATCHDOG_HOMEASSISTANT,
     RUN_CLEANUP_API_SESSIONS, STARTUP_AFTER, STARTUP_BEFORE,
-    STARTUP_INITIALIZE)
+    STARTUP_INITIALIZE, RUN_RELOAD_SNAPSHOTS_TASKS, RUN_UPDATE_ADDONS_TASKS)
 from .scheduler import Scheduler
 from .dock.homeassistant import DockerHomeAssistant
 from .dock.supervisor import DockerSupervisor
+from .snapshots import SnapshotsManager
 from .tasks import (
     hassio_update, homeassistant_watchdog, homeassistant_setup,
-    api_sessions_cleanup)
-from .tools import get_arch_from_image, get_local_ip, fetch_timezone
+    api_sessions_cleanup, addons_update)
+from .tools import get_local_ip, fetch_timezone
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,28 +28,30 @@ _LOGGER = logging.getLogger(__name__)
 class HassIO(object):
     """Main object of hassio."""
 
-    def __init__(self, loop):
+    def __init__(self, loop, config):
         """Initialize hassio object."""
         self.exit_code = 0
         self.loop = loop
-        self.websession = aiohttp.ClientSession(loop=self.loop)
-        self.config = bootstrap.initialize_system_data(self.websession)
-        self.scheduler = Scheduler(self.loop)
-        self.api = RestAPI(self.config, self.loop)
+        self.config = config
+        self.websession = aiohttp.ClientSession(loop=loop)
+        self.scheduler = Scheduler(loop)
+        self.api = RestAPI(config, loop)
         self.dock = docker.DockerClient(
             base_url="unix:/{}".format(str(SOCKET_DOCKER)), version='auto')
 
         # init basic docker container
-        self.supervisor = DockerSupervisor(
-            self.config, self.loop, self.dock, self.stop)
-        self.homeassistant = DockerHomeAssistant(
-            self.config, self.loop, self.dock)
+        self.supervisor = DockerSupervisor(config, loop, self.dock, self.stop)
+        self.homeassistant = DockerHomeAssistant(config, loop, self.dock)
 
         # init HostControl
-        self.host_control = HostControl(self.loop)
+        self.host_control = HostControl(loop)
 
         # init addon system
-        self.addons = AddonManager(self.config, self.loop, self.dock)
+        self.addons = AddonManager(config, loop, self.dock)
+
+        # init snapshot system
+        self.snapshots = SnapshotsManager(
+            config, loop, self.scheduler, self.addons, self.homeassistant)
 
     async def setup(self):
         """Setup HassIO orchestration."""
@@ -58,6 +60,9 @@ class HassIO(object):
             _LOGGER.fatal("Can't attach to supervisor docker container!")
         await self.supervisor.cleanup()
 
+        # set running arch
+        self.config.arch = self.supervisor.arch
+
         # set api endpoint
         self.config.api_endpoint = await get_local_ip(self.loop)
 
@@ -70,16 +75,18 @@ class HassIO(object):
 
         # schedule update info tasks
         self.scheduler.register_task(
-
             self.host_control.load, RUN_UPDATE_INFO_TASKS)
+
         # rest api views
         self.api.register_host(self.host_control)
         self.api.register_network(self.host_control)
         self.api.register_supervisor(
-            self.supervisor, self.addons, self.host_control)
+            self.supervisor, self.snapshots, self.addons, self.host_control,
+            self.websession)
         self.api.register_homeassistant(self.homeassistant)
         self.api.register_addons(self.addons)
         self.api.register_security()
+        self.api.register_snapshots(self.snapshots)
         self.api.register_panel()
 
         # schedule api session cleanup
@@ -87,37 +94,44 @@ class HassIO(object):
             api_sessions_cleanup(self.config), RUN_CLEANUP_API_SESSIONS,
             now=True)
 
-        # schedule update info tasks
-        self.scheduler.register_task(
-            self.config.fetch_update_infos, RUN_UPDATE_INFO_TASKS,
-            now=True)
-
         # first start of supervisor?
         if not await self.homeassistant.exists():
             _LOGGER.info("No HomeAssistant docker found.")
             await homeassistant_setup(
-                self.config, self.loop, self.homeassistant)
+                self.config, self.loop, self.homeassistant, self.websession)
         else:
             await self.homeassistant.attach()
 
         # Load addons
-        arch = get_arch_from_image(self.supervisor.image)
-        await self.addons.prepare(arch)
+        await self.addons.prepare()
 
         # schedule addon update task
         self.scheduler.register_task(
             self.addons.reload, RUN_RELOAD_ADDONS_TASKS, now=True)
+        self.scheduler.register_task(
+            addons_update(self.loop, self.addons), RUN_UPDATE_ADDONS_TASKS)
 
         # schedule self update task
         self.scheduler.register_task(
-            hassio_update(self.config, self.supervisor),
+            hassio_update(self.config, self.supervisor, self.websession),
             RUN_UPDATE_SUPERVISOR_TASKS)
 
+        # schedule snapshot update tasks
+        self.scheduler.register_task(
+            self.snapshots.reload, RUN_RELOAD_SNAPSHOTS_TASKS, now=True)
+
         # start addon mark as initialize
         await self.addons.auto_boot(STARTUP_INITIALIZE)
 
     async def start(self):
         """Start HassIO orchestration."""
+        # on release channel, try update itself
+        # on beta channel, only read new versions
+        await asyncio.wait(
+            [hassio_update(self.config, self.supervisor, self.websession)()],
+            loop=self.loop
+        )
+
         # start api
         await self.api.start()
         _LOGGER.info("Start hassio api on %s", self.config.api_endpoint)
@@ -146,11 +160,11 @@ class HassIO(object):
     async def stop(self, exit_code=0):
         """Stop a running orchestration."""
         # don't process scheduler anymore
-        self.scheduler.stop()
+        self.scheduler.suspend = True
 
-        # process stop task pararell
-        tasks = [self.websession.close(), self.api.stop()]
-        await asyncio.wait(tasks, loop=self.loop)
+        # process stop tasks
+        self.websession.close()
+        await self.api.stop()
 
         self.exit_code = exit_code
         self.loop.stop()

hassio/dock/__init__.py

@@ -5,7 +5,7 @@ import logging
 
 import docker
 
-from ..const import LABEL_VERSION
+from ..const import LABEL_VERSION, LABEL_ARCH
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -13,13 +13,15 @@ _LOGGER = logging.getLogger(__name__)
 class DockerBase(object):
     """Docker hassio wrapper."""
 
-    def __init__(self, config, loop, dock, image=None):
+    def __init__(self, config, loop, dock, image=None, timeout=30):
         """Initialize docker base wrapper."""
         self.config = config
         self.loop = loop
         self.dock = dock
         self.image = image
+        self.timeout = timeout
         self.version = None
+        self.arch = None
         self._lock = asyncio.Lock(loop=loop)
 
     @property
@@ -38,13 +40,18 @@ class DockerBase(object):
         if not self.image:
             self.image = metadata['Config']['Image']
 
-        # read metadata
+        # read version
         need_version = force or not self.version
         if need_version and LABEL_VERSION in metadata['Config']['Labels']:
             self.version = metadata['Config']['Labels'][LABEL_VERSION]
         elif need_version:
             _LOGGER.warning("Can't read version from %s", self.name)
 
+        # read arch
+        need_arch = force or not self.arch
+        if need_arch and LABEL_ARCH in metadata['Config']['Labels']:
+            self.arch = metadata['Config']['Labels'][LABEL_ARCH]
+
     async def install(self, tag):
         """Pull docker image."""
         if self._lock.locked():
@@ -183,17 +190,17 @@ class DockerBase(object):
         except docker.errors.DockerException:
             return
 
-        _LOGGER.info("Stop %s docker application", self.image)
-
         if container.status == 'running':
+            _LOGGER.info("Stop %s docker application", self.image)
             with suppress(docker.errors.DockerException):
-                container.stop()
+                container.stop(timeout=self.timeout)
 
         with suppress(docker.errors.DockerException):
+            _LOGGER.info("Clean %s docker application", self.image)
             container.remove(force=True)
 
     async def remove(self):
-        """Remove docker container."""
+        """Remove docker images."""
         if self._lock.locked():
             _LOGGER.error("Can't excute remove while a task is in progress")
             return False
@@ -202,12 +209,12 @@ class DockerBase(object):
             return await self.loop.run_in_executor(None, self._remove)
 
     def _remove(self):
-        """remove docker container.
+        """remove docker images.
 
         Need run inside executor.
         """
-        if self._is_running():
-            self._stop()
+        # cleanup container
+        self._stop()
 
         _LOGGER.info(
             "Remove docker %s with latest and %s", self.image, self.version)
@@ -225,6 +232,9 @@ class DockerBase(object):
             _LOGGER.warning("Can't remove image %s -> %s", self.image, err)
             return False
 
+        # clean metadata
+        self.version = None
+        self.arch = None
         return True
 
     async def update(self, tag):
@@ -261,7 +271,7 @@ class DockerBase(object):
         """Return docker logs of container."""
         if self._lock.locked():
             _LOGGER.error("Can't excute logs while a task is in progress")
-            return False
+            return b""
 
         async with self._lock:
             return await self.loop.run_in_executor(None, self._logs)
@@ -303,7 +313,7 @@ class DockerBase(object):
         _LOGGER.info("Restart %s", self.image)
 
         try:
-            container.restart(timeout=30)
+            container.restart(timeout=self.timeout)
         except docker.errors.DockerException as err:
             _LOGGER.warning("Can't restart %s -> %s", self.image, err)
             return False

hassio/dock/addon.py

@@ -4,6 +4,7 @@ from pathlib import Path
 import shutil
 
 import docker
+import requests
 
 from . import DockerBase
 from .util import dockerfile_template
@@ -16,22 +17,21 @@ _LOGGER = logging.getLogger(__name__)
 class DockerAddon(DockerBase):
     """Docker hassio wrapper for HomeAssistant."""
 
-    def __init__(self, config, loop, dock, addons_data, addon):
+    def __init__(self, config, loop, dock, addon):
         """Initialize docker homeassistant wrapper."""
         super().__init__(
-            config, loop, dock, image=addons_data.get_image(addon))
+            config, loop, dock, image=addon.image, timeout=addon.timeout)
         self.addon = addon
-        self.addons_data = addons_data
 
     @property
     def name(self):
         """Return name of docker container."""
-        return "addon_{}".format(self.addon)
+        return "addon_{}".format(self.addon.slug)
 
     @property
     def environment(self):
         """Return environment for docker add-on."""
-        addon_env = self.addons_data.get_environment(self.addon) or {}
+        addon_env = self.addon.environment or {}
 
         return {
             **addon_env,
@@ -41,7 +41,7 @@ class DockerAddon(DockerBase):
     @property
     def tmpfs(self):
         """Return tmpfs for docker add-on."""
-        options = self.addons_data.get_tmpfs(self.addon)
+        options = self.addon.tmpfs
         if options:
             return {"/tmpfs": "{}".format(options)}
         return None
@@ -50,11 +50,11 @@ class DockerAddon(DockerBase):
     def volumes(self):
         """Generate volumes for mappings."""
         volumes = {
-            str(self.addons_data.path_extern_data(self.addon)): {
+            str(self.addon.path_extern_data): {
                 'bind': '/data', 'mode': 'rw'
             }}
 
-        addon_mapping = self.addons_data.map_volumes(self.addon)
+        addon_mapping = self.addon.map_volumes
 
         if MAP_CONFIG in addon_mapping:
             volumes.update({
@@ -94,19 +94,24 @@ class DockerAddon(DockerBase):
         Need run inside executor.
         """
         if self._is_running():
-            return
+            return True
 
         # cleanup
         self._stop()
 
+        # write config
+        if not self.addon.write_options():
+            return False
+
         try:
             self.dock.containers.run(
                 self.image,
                 name=self.name,
                 detach=True,
-                network_mode=self.addons_data.get_network_mode(self.addon),
-                ports=self.addons_data.get_ports(self.addon),
-                devices=self.addons_data.get_devices(self.addon),
+                network_mode=self.addon.network_mode,
+                ports=self.addon.ports,
+                devices=self.addon.devices,
+                cap_add=self.addon.privileged,
                 environment=self.environment,
                 volumes=self.volumes,
                 tmpfs=self.tmpfs
@@ -125,40 +130,31 @@ class DockerAddon(DockerBase):
 
         Need run inside executor.
         """
-        if self.addons_data.need_build(self.addon):
+        if self.addon.need_build:
             return self._build(tag)
 
         return super()._install(tag)
 
-    async def build(self, tag):
-        """Build a docker container."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute build while a task is in progress")
-            return False
-
-        async with self._lock:
-            return await self.loop.run_in_executor(None, self._build, tag)
-
     def _build(self, tag):
         """Build a docker container.
 
         Need run inside executor.
         """
-        build_dir = Path(self.config.path_addons_build, self.addon)
+        build_dir = Path(self.config.path_tmp, self.addon.slug)
         try:
             # prepare temporary addon build folder
             try:
-                source = self.addons_data.path_addon_location(self.addon)
+                source = self.addon.path_addon_location
                 shutil.copytree(str(source), str(build_dir))
             except shutil.Error as err:
                 _LOGGER.error("Can't copy %s to temporary build folder -> %s",
-                              source, build_dir)
+                              source, err)
                 return False
 
             # prepare Dockerfile
             try:
                 dockerfile_template(
-                    Path(build_dir, 'Dockerfile'), self.addons_data.arch,
+                    Path(build_dir, 'Dockerfile'), self.config.arch,
                     tag, META_ADDON)
             except OSError as err:
                 _LOGGER.error("Can't prepare dockerfile -> %s", err)
@@ -183,3 +179,74 @@ class DockerAddon(DockerBase):
 
         finally:
             shutil.rmtree(str(build_dir), ignore_errors=True)
+
+    async def export_image(self, path):
+        """Export current images into a tar file."""
+        if self._lock.locked():
+            _LOGGER.error("Can't excute export while a task is in progress")
+            return False
+
+        async with self._lock:
+            return await self.loop.run_in_executor(
+                None, self._export_image, path)
+
+    def _export_image(self, tar_file):
+        """Export current images into a tar file.
+
+        Need run inside executor.
+        """
+        try:
+            image = self.dock.api.get_image(self.image)
+        except docker.errors.DockerException as err:
+            _LOGGER.error("Can't fetch image %s -> %s", self.image, err)
+            return False
+
+        try:
+            with tar_file.open("wb") as write_tar:
+                for chunk in image.stream():
+                    write_tar.write(chunk)
+        except (OSError, requests.exceptions.ReadTimeout) as err:
+            _LOGGER.error("Can't write tar file %s -> %s", tar_file, err)
+            return False
+
+        _LOGGER.info("Export image %s to %s", self.image, tar_file)
+        return True
+
+    async def import_image(self, path, tag):
+        """Import a tar file as image."""
+        if self._lock.locked():
+            _LOGGER.error("Can't excute import while a task is in progress")
+            return False
+
+        async with self._lock:
+            return await self.loop.run_in_executor(
+                None, self._import_image, path, tag)
+
+    def _import_image(self, tar_file, tag):
+        """Import a tar file as image.
+
+        Need run inside executor.
+        """
+        try:
+            with tar_file.open("rb") as read_tar:
+                self.dock.api.load_image(read_tar)
+
+            image = self.dock.images.get(self.image)
+            image.tag(self.image, tag=tag)
+        except (docker.errors.DockerException, OSError) as err:
+            _LOGGER.error("Can't import image %s -> %s", self.image, err)
+            return False
+
+        _LOGGER.info("Import image %s and tag %s", tar_file, tag)
+        self.process_metadata(image.attrs, force=True)
+        self._cleanup()
+        return True
+
+    def _restart(self):
+        """Restart docker container.
+
+        Addons prepare some thing on start and that is normaly not repeatable.
+        Need run inside executor.
+        """
+        self._stop()
+        return self._run()

hassio/dock/util.py

@@ -5,10 +5,10 @@ from ..const import ARCH_AARCH64, ARCH_ARMHF, ARCH_I386, ARCH_AMD64
 
 
 RESIN_BASE_IMAGE = {
-    ARCH_ARMHF: "resin/armhf-alpine:3.5",
-    ARCH_AARCH64: "resin/aarch64-alpine:3.5",
-    ARCH_I386: "resin/i386-alpine:3.5",
-    ARCH_AMD64: "resin/amd64-alpine:3.5",
+    ARCH_ARMHF: "homeassistant/armhf-base:latest",
+    ARCH_AARCH64: "homeassistant/aarch64-base:latest",
+    ARCH_I386: "homeassistant/i386-base:latest",
+    ARCH_AMD64: "homeassistant/amd64-base:latest",
 }
 
 TMPL_IMAGE = re.compile(r"%%BASE_IMAGE%%")

hassio/scheduler.py

@@ -16,11 +16,7 @@ class Scheduler(object):
         """Initialize task schedule."""
         self.loop = loop
         self._data = {}
-        self._stop = False
-
-    def stop(self):
-        """Stop to execute tasks in scheduler."""
-        self._stop = True
+        self.suspend = False
 
     def register_task(self, coro_callback, seconds, repeat=True,
                       now=False):
@@ -51,11 +47,8 @@ class Scheduler(object):
         """Run a scheduled task."""
         data = self._data.pop(idx)
 
-        # stop execute tasks
-        if self._stop:
-            return
-
-        self.loop.create_task(data[CALL]())
+        if not self.suspend:
+            self.loop.create_task(data[CALL]())
 
         if data[REPEAT]:
             task = self.loop.call_later(data[SEC], self._run_task, idx)

hassio/snapshots/__init__.py

@@ -0,0 +1,313 @@
+"""Snapshot system control."""
+import asyncio
+from datetime import datetime
+import logging
+from pathlib import Path
+import tarfile
+
+from .snapshot import Snapshot
+from .util import create_slug
+from ..const import (
+    ATTR_SLUG, FOLDER_HOMEASSISTANT, SNAPSHOT_FULL, SNAPSHOT_PARTIAL)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SnapshotsManager(object):
+    """Manage snapshots."""
+
+    def __init__(self, config, loop, sheduler, addons, homeassistant):
+        """Initialize a snapshot manager."""
+        self.config = config
+        self.loop = loop
+        self.sheduler = sheduler
+        self.addons = addons
+        self.homeassistant = homeassistant
+        self.snapshots = {}
+        self._lock = asyncio.Lock(loop=loop)
+
+    @property
+    def list_snapshots(self):
+        """Return a list of all snapshot object."""
+        return set(self.snapshots.values())
+
+    def get(self, slug):
+        """Return snapshot object."""
+        return self.snapshots.get(slug)
+
+    def _create_snapshot(self, name, sys_type):
+        """Initialize a new snapshot object from name."""
+        date_str = str(datetime.utcnow())
+        slug = create_slug(name, date_str)
+        tar_file = Path(self.config.path_backup, "{}.tar".format(slug))
+
+        # init object
+        snapshot = Snapshot(self.config, self.loop, tar_file)
+        snapshot.create(slug, name, date_str, sys_type)
+
+        # set general data
+        snapshot.homeassistant_version = self.homeassistant.version
+        snapshot.homeassistant_devices = self.config.homeassistant_devices
+        snapshot.repositories = self.config.addons_repositories
+
+        return snapshot
+
+    async def reload(self):
+        """Load exists backups."""
+        self.snapshots = {}
+
+        async def _load_snapshot(tar_file):
+            """Internal function to load snapshot."""
+            snapshot = Snapshot(self.config, self.loop, tar_file)
+            if await snapshot.load():
+                self.snapshots[snapshot.slug] = snapshot
+
+        tasks = [_load_snapshot(tar_file) for tar_file in
+                 self.config.path_backup.glob("*.tar")]
+
+        _LOGGER.info("Found %d snapshot files", len(tasks))
+        if tasks:
+            await asyncio.wait(tasks, loop=self.loop)
+
+    def remove(self, snapshot):
+        """Remove a snapshot."""
+        try:
+            snapshot.tar_file.unlink()
+            self.snapshots.pop(snapshot.slug, None)
+        except OSError as err:
+            _LOGGER.error("Can't remove snapshot %s -> %s", snapshot.slug, err)
+            return False
+
+        return True
+
+    async def do_snapshot_full(self, name=""):
+        """Create a full snapshot."""
+        if self._lock.locked():
+            _LOGGER.error("It is already a snapshot/restore process running")
+            return False
+
+        snapshot = self._create_snapshot(name, SNAPSHOT_FULL)
+        _LOGGER.info("Full-Snapshot %s start", snapshot.slug)
+        try:
+            self.sheduler.suspend = True
+            await self._lock.acquire()
+
+            async with snapshot:
+                # snapshot addons
+                tasks = []
+                for addon in self.addons.list_addons:
+                    if not addon.is_installed:
+                        continue
+                    tasks.append(snapshot.import_addon(addon))
+
+                if tasks:
+                    _LOGGER.info("Full-Snapshot %s run %d addons",
+                                 snapshot.slug, len(tasks))
+                    await asyncio.wait(tasks, loop=self.loop)
+
+                # snapshot folders
+                _LOGGER.info("Full-Snapshot %s store folders", snapshot.slug)
+                await snapshot.store_folders()
+
+            _LOGGER.info("Full-Snapshot %s done", snapshot.slug)
+            self.snapshots[snapshot.slug] = snapshot
+            return True
+
+        except (OSError, ValueError, tarfile.TarError) as err:
+            _LOGGER.info("Full-Snapshot %s error -> %s", snapshot.slug, err)
+            return False
+
+        finally:
+            self.sheduler.suspend = False
+            self._lock.release()
+
+    async def do_snapshot_partial(self, name="", addons=None, folders=None):
+        """Create a partial snapshot."""
+        if self._lock.locked():
+            _LOGGER.error("It is already a snapshot/restore process running")
+            return False
+
+        addons = addons or []
+        folders = folders or []
+        snapshot = self._create_snapshot(name, SNAPSHOT_PARTIAL)
+
+        _LOGGER.info("Partial-Snapshot %s start", snapshot.slug)
+        try:
+            self.sheduler.suspend = True
+            await self._lock.acquire()
+
+            async with snapshot:
+                # snapshot addons
+                tasks = []
+                for slug in addons:
+                    addon = self.addons.get(slug)
+                    if addon.is_installed:
+                        tasks.append(snapshot.import_addon(addon))
+
+                if tasks:
+                    _LOGGER.info("Partial-Snapshot %s run %d addons",
+                                 snapshot.slug, len(tasks))
+                    await asyncio.wait(tasks, loop=self.loop)
+
+                # snapshot folders
+                _LOGGER.info("Partial-Snapshot %s store folders %s",
+                             snapshot.slug, folders)
+                await snapshot.store_folders(folders)
+
+            _LOGGER.info("Partial-Snapshot %s done", snapshot.slug)
+            self.snapshots[snapshot.slug] = snapshot
+            return True
+
+        except (OSError, ValueError, tarfile.TarError) as err:
+            _LOGGER.info("Partial-Snapshot %s error -> %s", snapshot.slug, err)
+            return False
+
+        finally:
+            self.sheduler.suspend = False
+            self._lock.release()
+
+    async def do_restore_full(self, snapshot):
+        """Restore a snapshot."""
+        if self._lock.locked():
+            _LOGGER.error("It is already a snapshot/restore process running")
+            return False
+
+        if snapshot.sys_type != SNAPSHOT_FULL:
+            _LOGGER.error(
+                "Full-Restore %s is only a partial snapshot!", snapshot.slug)
+            return False
+
+        _LOGGER.info("Full-Restore %s start", snapshot.slug)
+        try:
+            self.sheduler.suspend = True
+            await self._lock.acquire()
+
+            async with snapshot:
+                # stop system
+                tasks = []
+                tasks.append(self.homeassistant.stop())
+
+                for addon in self.addons.list_addons:
+                    if addon.is_installed:
+                        tasks.append(addon.stop())
+
+                await asyncio.wait(tasks, loop=self.loop)
+
+                # restore folders
+                _LOGGER.info("Full-Restore %s restore folders", snapshot.slug)
+                await snapshot.restore_folders()
+
+                # start homeassistant restore
+                self.config.homeassistant_devices = \
+                    snapshot.homeassistant_devices
+                task_hass = self.loop.create_task(
+                    self.homeassistant.update(snapshot.homeassistant_version))
+
+                # restore repositories
+                await self.addons.load_repositories(snapshot.repositories)
+
+                # restore addons
+                tasks = []
+                actual_addons = \
+                    set(addon.slug for addon in self.addons.list_addons
+                        if addon.is_installed)
+                restore_addons = \
+                    set(data[ATTR_SLUG] for data in snapshot.addons)
+                remove_addons = actual_addons - restore_addons
+
+                _LOGGER.info("Full-Restore %s restore addons %s, remove %s",
+                             snapshot.slug, restore_addons, remove_addons)
+
+                for slug in remove_addons:
+                    addon = self.addons.get(slug)
+                    if addon:
+                        tasks.append(addon.uninstall())
+                    else:
+                        _LOGGER.warning("Can't remove addon %s", slug)
+
+                for slug in restore_addons:
+                    addon = self.addons.get(slug)
+                    if addon:
+                        tasks.append(snapshot.export_addon(addon))
+                    else:
+                        _LOGGER.warning("Can't restore addon %s", slug)
+
+                if tasks:
+                    _LOGGER.info("Full-Restore %s restore addons tasks %d",
+                                 snapshot.slug, len(tasks))
+                    await asyncio.wait(tasks, loop=self.loop)
+
+                # finish homeassistant task
+                _LOGGER.info("Full-Restore %s wait until homeassistant ready",
+                             snapshot.slug)
+                await task_hass
+                await self.homeassistant.run()
+
+            _LOGGER.info("Full-Restore %s done", snapshot.slug)
+            return True
+
+        except (OSError, ValueError, tarfile.TarError) as err:
+            _LOGGER.info("Full-Restore %s error -> %s", slug, err)
+            return False
+
+        finally:
+            self.sheduler.suspend = False
+            self._lock.release()
+
+    async def do_restore_partial(self, snapshot, homeassistant=False,
+                                 addons=None, folders=None):
+        """Restore a snapshot."""
+        if self._lock.locked():
+            _LOGGER.error("It is already a snapshot/restore process running")
+            return False
+
+        addons = addons or []
+        folders = folders or []
+
+        _LOGGER.info("Partial-Restore %s start", snapshot.slug)
+        try:
+            self.sheduler.suspend = True
+            await self._lock.acquire()
+
+            async with snapshot:
+                tasks = []
+
+                if FOLDER_HOMEASSISTANT in folders:
+                    await self.homeassistant.stop()
+
+                if folders:
+                    _LOGGER.info("Partial-Restore %s restore folders %s",
+                                 snapshot.slug, folders)
+                    await snapshot.restore_folders(folders)
+
+                if homeassistant:
+                    self.config.homeassistant_devices = \
+                        snapshot.homeassistant_devices
+                    tasks.append(self.homeassistant.update(
+                        snapshot.homeassistant_version))
+
+                for slug in addons:
+                    addon = self.addons.get(slug)
+                    if addon:
+                        tasks.append(snapshot.export_addon(addon))
+                    else:
+                        _LOGGER.warning("Can't restore addon %s", slug)
+
+                if tasks:
+                    _LOGGER.info("Partial-Restore %s run %d tasks",
+                                 snapshot.slug, len(tasks))
+                    await asyncio.wait(tasks, loop=self.loop)
+
+                # make sure homeassistant run agen
+                await self.homeassistant.run()
+
+            _LOGGER.info("Partial-Restore %s done", snapshot.slug)
+            return True
+
+        except (OSError, ValueError, tarfile.TarError) as err:
+            _LOGGER.info("Partial-Restore %s error -> %s", slug, err)
+            return False
+
+        finally:
+            self.sheduler.suspend = False
+            self._lock.release()

hassio/snapshots/snapshot.py

@@ -0,0 +1,271 @@
+"""Represent a snapshot file."""
+import asyncio
+import json
+import logging
+from pathlib import Path
+import tarfile
+from tempfile import TemporaryDirectory
+
+import voluptuous as vol
+from voluptuous.humanize import humanize_error
+
+from .validate import SCHEMA_SNAPSHOT, ALL_FOLDERS
+from .util import remove_folder
+from ..const import (
+    ATTR_SLUG, ATTR_NAME, ATTR_DATE, ATTR_ADDONS, ATTR_REPOSITORIES,
+    ATTR_HOMEASSISTANT, ATTR_FOLDERS, ATTR_VERSION, ATTR_TYPE, ATTR_DEVICES)
+from ..tools import write_json_file
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Snapshot(object):
+    """A signle hassio snapshot."""
+
+    def __init__(self, config, loop, tar_file):
+        """Initialize a snapshot."""
+        self.loop = loop
+        self.config = config
+        self.tar_file = tar_file
+        self._data = {}
+        self._tmp = None
+
+    @property
+    def slug(self):
+        """Return snapshot slug."""
+        return self._data.get(ATTR_SLUG)
+
+    @property
+    def sys_type(self):
+        """Return snapshot type."""
+        return self._data.get(ATTR_TYPE)
+
+    @property
+    def name(self):
+        """Return snapshot name."""
+        return self._data[ATTR_NAME]
+
+    @property
+    def date(self):
+        """Return snapshot date."""
+        return self._data[ATTR_DATE]
+
+    @property
+    def addons(self):
+        """Return snapshot date."""
+        return self._data[ATTR_ADDONS]
+
+    @property
+    def folders(self):
+        """Return list of saved folders."""
+        return self._data[ATTR_FOLDERS]
+
+    @property
+    def repositories(self):
+        """Return snapshot date."""
+        return self._data[ATTR_REPOSITORIES]
+
+    @repositories.setter
+    def repositories(self, value):
+        """Set snapshot date."""
+        self._data[ATTR_REPOSITORIES] = value
+
+    @property
+    def homeassistant_version(self):
+        """Return snapshot homeassistant version."""
+        return self._data[ATTR_HOMEASSISTANT].get(ATTR_VERSION)
+
+    @homeassistant_version.setter
+    def homeassistant_version(self, value):
+        """Set snapshot homeassistant version."""
+        self._data[ATTR_HOMEASSISTANT][ATTR_VERSION] = value
+
+    @property
+    def homeassistant_devices(self):
+        """Return snapshot homeassistant devices."""
+        return self._data[ATTR_HOMEASSISTANT].get(ATTR_DEVICES)
+
+    @homeassistant_devices.setter
+    def homeassistant_devices(self, value):
+        """Set snapshot homeassistant devices."""
+        self._data[ATTR_HOMEASSISTANT][ATTR_DEVICES] = value
+
+    @property
+    def size(self):
+        """Return snapshot size."""
+        if not self.tar_file.is_file():
+            return 0
+        return self.tar_file.stat().st_size / 1048576  # calc mbyte
+
+    def create(self, slug, name, date, sys_type):
+        """Initialize a new snapshot."""
+        # init metadata
+        self._data[ATTR_SLUG] = slug
+        self._data[ATTR_NAME] = name
+        self._data[ATTR_DATE] = date
+        self._data[ATTR_TYPE] = sys_type
+
+        # init other constructs
+        self._data[ATTR_HOMEASSISTANT] = {}
+        self._data[ATTR_ADDONS] = []
+        self._data[ATTR_REPOSITORIES] = []
+        self._data[ATTR_FOLDERS] = []
+
+    async def load(self):
+        """Read snapshot.json from tar file."""
+        if not self.tar_file.is_file():
+            _LOGGER.error("No tarfile %s", self.tar_file)
+            return False
+
+        def _load_file():
+            """Read snapshot.json."""
+            with tarfile.open(self.tar_file, "r:") as snapshot:
+                json_file = snapshot.extractfile("./snapshot.json")
+                return json_file.read()
+
+        # read snapshot.json
+        try:
+            raw = await self.loop.run_in_executor(None, _load_file)
+        except (tarfile.TarError, KeyError) as err:
+            _LOGGER.error(
+                "Can't read snapshot tarfile %s -> %s", self.tar_file, err)
+            return False
+
+        # parse data
+        try:
+            raw_dict = json.loads(raw)
+        except json.JSONDecodeError as err:
+            _LOGGER.error("Can't read data for %s -> %s", self.tar_file, err)
+            return False
+
+        # validate
+        try:
+            self._data = SCHEMA_SNAPSHOT(raw_dict)
+        except vol.Invalid as err:
+            _LOGGER.error("Can't validate data for %s -> %s", self.tar_file,
+                          humanize_error(raw_dict, err))
+            return False
+
+        return True
+
+    async def __aenter__(self):
+        """Async context to open a snapshot."""
+        self._tmp = TemporaryDirectory(dir=str(self.config.path_tmp))
+
+        # create a snapshot
+        if not self.tar_file.is_file():
+            return self
+
+        # extract a exists snapshot
+        def _extract_snapshot():
+            """Extract a snapshot."""
+            with tarfile.open(self.tar_file, "r:") as tar:
+                tar.extractall(path=self._tmp.name)
+
+        await self.loop.run_in_executor(None, _extract_snapshot)
+
+    async def __aexit__(self, exception_type, exception_value, traceback):
+        """Async context to close a snapshot."""
+        # exists snapshot or exception on build
+        if self.tar_file.is_file() or exception_type is not None:
+            return self._tmp.cleanup()
+
+        # validate data
+        try:
+            self._data = SCHEMA_SNAPSHOT(self._data)
+        except vol.Invalid as err:
+            _LOGGER.error("Invalid data for %s -> %s", self.tar_file,
+                          humanize_error(self._data, err))
+            raise ValueError("Invalid config") from None
+
+        # new snapshot, build it
+        def _create_snapshot():
+            """Create a new snapshot."""
+            with tarfile.open(self.tar_file, "w:") as tar:
+                tar.add(self._tmp.name, arcname=".")
+
+        if write_json_file(Path(self._tmp.name, "snapshot.json"), self._data):
+            await self.loop.run_in_executor(None, _create_snapshot)
+        else:
+            _LOGGER.error("Can't write snapshot.json")
+
+        self._tmp.cleanup()
+        self._tmp = None
+
+    async def import_addon(self, addon):
+        """Add a addon into snapshot."""
+        snapshot_file = Path(self._tmp.name, "{}.tar.gz".format(addon.slug))
+
+        if not await addon.snapshot(snapshot_file):
+            _LOGGER.error("Can't make snapshot from %s", addon.slug)
+            return False
+
+        # store to config
+        self._data[ATTR_ADDONS].append({
+            ATTR_SLUG: addon.slug,
+            ATTR_NAME: addon.name,
+            ATTR_VERSION: addon.version_installed,
+        })
+
+        return True
+
+    async def export_addon(self, addon):
+        """Restore a addon from snapshot."""
+        snapshot_file = Path(self._tmp.name, "{}.tar.gz".format(addon.slug))
+
+        if not await addon.restore(snapshot_file):
+            _LOGGER.error("Can't restore snapshot for %s", addon.slug)
+            return False
+
+        return True
+
+    async def store_folders(self, folder_list=None):
+        """Backup hassio data into snapshot."""
+        folder_list = folder_list or ALL_FOLDERS
+
+        def _folder_save(name):
+            """Intenal function to snapshot a folder."""
+            slug_name = name.replace("/", "_")
+            snapshot_tar = Path(self._tmp.name, "{}.tar.gz".format(slug_name))
+            origin_dir = Path(self.config.path_hassio, name)
+
+            try:
+                with tarfile.open(snapshot_tar, "w:gz",
+                                  compresslevel=1) as tar_file:
+                    tar_file.add(origin_dir, arcname=".")
+
+                self._data[ATTR_FOLDERS].append(name)
+            except tarfile.TarError as err:
+                _LOGGER.warning("Can't snapshot folder %s -> %s", name, err)
+
+        # run tasks
+        tasks = [self.loop.run_in_executor(None, _folder_save, folder)
+                 for folder in folder_list]
+        if tasks:
+            await asyncio.wait(tasks, loop=self.loop)
+
+    async def restore_folders(self, folder_list=None):
+        """Backup hassio data into snapshot."""
+        folder_list = folder_list or ALL_FOLDERS
+
+        def _folder_restore(name):
+            """Intenal function to restore a folder."""
+            slug_name = name.replace("/", "_")
+            snapshot_tar = Path(self._tmp.name, "{}.tar.gz".format(slug_name))
+            origin_dir = Path(self.config.path_hassio, name)
+
+            # clean old stuff
+            if origin_dir.is_dir():
+                remove_folder(origin_dir)
+
+            try:
+                with tarfile.open(snapshot_tar, "r:gz") as tar_file:
+                    tar_file.extractall(path=origin_dir)
+            except tarfile.TarError as err:
+                _LOGGER.warning("Can't restore folder %s -> %s", name, err)
+
+        # run tasks
+        tasks = [self.loop.run_in_executor(None, _folder_restore, folder)
+                 for folder in folder_list]
+        if tasks:
+            await asyncio.wait(tasks, loop=self.loop)

hassio/snapshots/util.py

@@ -0,0 +1,21 @@
+"""Util addons functions."""
+import hashlib
+import shutil
+
+
+def create_slug(name, date_str):
+    """Generate a hash from repository."""
+    key = "{} - {}".format(date_str, name).lower().encode()
+    return hashlib.sha1(key).hexdigest()[:8]
+
+
+def remove_folder(folder):
+    """Remove folder data but not the folder itself."""
+    for obj in folder.iterdir():
+        try:
+            if obj.is_dir():
+                shutil.rmtree(str(obj), ignore_errors=True)
+            else:
+                obj.unlink()
+        except (OSError, shutil.Error):
+            pass

hassio/snapshots/validate.py

@@ -0,0 +1,31 @@
+"""Validate some things around restore."""
+
+import voluptuous as vol
+
+from ..const import (
+    ATTR_REPOSITORIES, ATTR_ADDONS, ATTR_NAME, ATTR_SLUG, ATTR_DATE,
+    ATTR_VERSION, ATTR_HOMEASSISTANT, ATTR_FOLDERS, ATTR_TYPE, ATTR_DEVICES,
+    FOLDER_SHARE, FOLDER_HOMEASSISTANT, FOLDER_ADDONS, FOLDER_SSL,
+    SNAPSHOT_FULL, SNAPSHOT_PARTIAL)
+from ..validate import HASS_DEVICES
+
+ALL_FOLDERS = [FOLDER_HOMEASSISTANT, FOLDER_SHARE, FOLDER_ADDONS, FOLDER_SSL]
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_SNAPSHOT = vol.Schema({
+    vol.Required(ATTR_SLUG): vol.Coerce(str),
+    vol.Required(ATTR_TYPE): vol.In([SNAPSHOT_FULL, SNAPSHOT_PARTIAL]),
+    vol.Required(ATTR_NAME): vol.Coerce(str),
+    vol.Required(ATTR_DATE): vol.Coerce(str),
+    vol.Required(ATTR_HOMEASSISTANT): vol.Schema({
+        vol.Required(ATTR_VERSION): vol.Coerce(str),
+        vol.Optional(ATTR_DEVICES, default=[]): HASS_DEVICES,
+    }),
+    vol.Optional(ATTR_FOLDERS, default=[]): [vol.In(ALL_FOLDERS)],
+    vol.Optional(ATTR_ADDONS, default=[]): [vol.Schema({
+        vol.Required(ATTR_SLUG): vol.Coerce(str),
+        vol.Required(ATTR_NAME): vol.Coerce(str),
+        vol.Required(ATTR_VERSION): vol.Coerce(str),
+    })],
+    vol.Optional(ATTR_REPOSITORIES, default=[]): [vol.Url()],
+}, extra=vol.ALLOW_EXTRA)

hassio/tasks.py

@@ -18,13 +18,38 @@ def api_sessions_cleanup(config):
     return _api_sessions_cleanup
 
 
-def hassio_update(config, supervisor):
+def addons_update(loop, addons):
+    """Create scheduler task for auto update addons."""
+    async def _addons_update():
+        """Check if a update is available of a addon and update it."""
+        tasks = []
+        for addon in addons.list_addons:
+            if not addon.is_installed:
+                continue
+
+            if addon.version_installed != addon.version:
+                tasks.append(addon.update())
+
+        if tasks:
+            _LOGGER.info("Addon auto update process %d tasks", len(tasks))
+            await asyncio.wait(tasks, loop=loop)
+
+    return _addons_update
+
+
+def hassio_update(config, supervisor, websession):
     """Create scheduler task for update of supervisor hassio."""
     async def _hassio_update():
         """Check and run update of supervisor hassio."""
+        await config.fetch_update_infos(websession)
         if config.last_hassio == supervisor.version:
             return
 
+        # don't perform a update on beta/dev channel
+        if config.upstream_beta:
+            _LOGGER.warning("Ignore Hass.IO update on beta upstream!")
+            return
+
         _LOGGER.info("Found new HassIO version %s.", config.last_hassio)
         await supervisor.update(config.last_hassio)
 
@@ -43,12 +68,12 @@ def homeassistant_watchdog(loop, homeassistant):
     return _homeassistant_watchdog
 
 
-async def homeassistant_setup(config, loop, homeassistant):
+async def homeassistant_setup(config, loop, homeassistant, websession):
     """Install a homeassistant docker container."""
     while True:
         # read homeassistant tag and install it
         if not config.last_homeassistant:
-            await config.fetch_update_infos()
+            await config.fetch_update_infos(websession)
 
         tag = config.last_homeassistant
         if tag and await homeassistant.install(tag):

hassio/tools.py

@@ -3,7 +3,6 @@ import asyncio
 from contextlib import suppress
 import json
 import logging
-import re
 import socket
 
 import aiohttp
@@ -17,9 +16,6 @@ _LOGGER = logging.getLogger(__name__)
 
 FREEGEOIP_URL = "https://freegeoip.io/json/"
 
-_RE_VERSION = re.compile(r"VERSION=(.*)")
-_IMAGE_ARCH = re.compile(r".*/([a-z0-9]*)-hassio-supervisor")
-
 
 async def fetch_last_versions(websession, beta=False):
     """Fetch current versions from github.
@@ -39,13 +35,6 @@ async def fetch_last_versions(websession, beta=False):
         _LOGGER.warning("Can't parse versions from %s! %s", url, err)
 
 
-def get_arch_from_image(image):
-    """Return arch from hassio image name."""
-    found = _IMAGE_ARCH.match(image)
-    if found:
-        return found.group(1)
-
-
 def get_local_ip(loop):
     """Retrieve local IP address.
 

hassio/validate.py

@@ -0,0 +1,32 @@
+"""Validate functions."""
+import voluptuous as vol
+
+NETWORK_PORT = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
+HASS_DEVICES = [vol.Match(r"^[^/]*$")]
+
+
+def convert_to_docker_ports(data):
+    """Convert data into docker port list."""
+    # dynamic ports
+    if data is None:
+        return
+
+    # single port
+    if isinstance(data, int):
+        return NETWORK_PORT(data)
+
+    # port list
+    if isinstance(data, list) and len(data) > 2:
+        return vol.Schema([NETWORK_PORT])(data)
+
+    # ip port mapping
+    if isinstance(data, list) and len(data) == 2:
+        return (vol.Coerce(str)(data[0]), NETWORK_PORT(data[1]))
+
+    raise vol.Invalid("Can't validate docker host settings")
+
+
+DOCKER_PORTS = vol.Schema({
+    vol.All(vol.Coerce(str), vol.Match(r"^\d+(?:/tcp|/udp)?$")):
+        convert_to_docker_ports,
+})

setup.py

@@ -29,7 +29,13 @@ setup(
     keywords=['docker', 'home-assistant', 'api'],
     zip_safe=False,
     platforms='any',
-    packages=['hassio', 'hassio.dock', 'hassio.api', 'hassio.addons'],
+    packages=[
+        'hassio',
+        'hassio.dock',
+        'hassio.api',
+        'hassio.addons',
+        'hassio.snapshots'
+    ],
     include_package_data=True,
     install_requires=[
         'async_timeout',

version.json

@@ -1,6 +1,6 @@
 {
-    "hassio": "0.35",
-    "homeassistant": "0.45.1",
+    "hassio": "0.40",
+    "homeassistant": "0.48.1",
     "resinos": "0.8",
     "resinhup": "0.1",
     "generic": "0.3"