Merge remote-tracking branch 'origin/dev'

Author: pvizeli

API.md

@@ -303,6 +303,7 @@ Output is the raw Docker log.
 
 - POST `/homeassistant/restart`
 - POST `/homeassistant/options`
+- POST `/homeassistant/check`
 
 ```json
 {

hassio/addons/addon.py

@@ -496,7 +496,7 @@ async def update(self, version=None):
 
         # restore state
         if last_state == STATE_STARTED:
-            return await self.docker.run()
+            await self.docker.run()
         return True
 
     @check_installed

hassio/api/__init__.py

@@ -68,10 +68,11 @@ def register_homeassistant(self, dock_homeassistant):
         api_hass = APIHomeAssistant(self.config, self.loop, dock_homeassistant)
 
         self.webapp.router.add_get('/homeassistant/info', api_hass.info)
+        self.webapp.router.add_get('/homeassistant/logs', api_hass.logs)
         self.webapp.router.add_post('/homeassistant/options', api_hass.options)
         self.webapp.router.add_post('/homeassistant/update', api_hass.update)
         self.webapp.router.add_post('/homeassistant/restart', api_hass.restart)
-        self.webapp.router.add_get('/homeassistant/logs', api_hass.logs)
+        self.webapp.router.add_post('/homeassistant/check', api_hass.check)
 
     def register_addons(self, addons):
         """Register homeassistant function."""

hassio/api/addons.py

@@ -170,19 +170,13 @@ async def install(self, request):
 
     @api_process
     def uninstall(self, request):
-        """Uninstall addon.
-
-        Return a coroutine.
-        """
+        """Uninstall addon."""
         addon = self._extract_addon(request)
         return asyncio.shield(addon.uninstall(), loop=self.loop)
 
     @api_process
     def start(self, request):
-        """Start addon.
-
-        Return a coroutine.
-        """
+        """Start addon."""
         addon = self._extract_addon(request)
 
         # check options
@@ -196,10 +190,7 @@ def start(self, request):
 
     @api_process
     def stop(self, request):
-        """Stop addon.
-
-        Return a coroutine.
-        """
+        """Stop addon."""
         addon = self._extract_addon(request)
         return asyncio.shield(addon.stop(), loop=self.loop)
 
@@ -218,19 +209,13 @@ async def update(self, request):
 
     @api_process
     def restart(self, request):
-        """Restart addon.
-
-        Return a coroutine.
-        """
+        """Restart addon."""
         addon = self._extract_addon(request)
         return asyncio.shield(addon.restart(), loop=self.loop)
 
     @api_process_raw(CONTENT_TYPE_BINARY)
     def logs(self, request):
-        """Return logs from addon.
-
-        Return a coroutine.
-        """
+        """Return logs from addon."""
         addon = self._extract_addon(request)
         return addon.logs()
 

hassio/api/homeassistant.py

@@ -73,16 +73,19 @@ async def update(self, request):
 
     @api_process
     def restart(self, request):
-        """Restart homeassistant.
-
-        Return a coroutine.
-        """
+        """Restart homeassistant."""
         return asyncio.shield(self.homeassistant.restart(), loop=self.loop)
 
     @api_process_raw(CONTENT_TYPE_BINARY)
     def logs(self, request):
-        """Return homeassistant docker logs.
-
-        Return a coroutine.
-        """
+        """Return homeassistant docker logs."""
         return self.homeassistant.logs()
+
+    @api_process
+    async def check(self, request):
+        """Check config of homeassistant."""
+        code, message = await self.homeassistant.check_config()
+        if not code:
+            raise RuntimeError(message)
+
+        return True

hassio/api/host.py

@@ -59,18 +59,12 @@ async def options(self, request):
 
     @api_process_hostcontrol
     def reboot(self, request):
-        """Reboot host.
-
-        Return a coroutine.
-        """
+        """Reboot host."""
         return self.host_control.reboot()
 
     @api_process_hostcontrol
     def shutdown(self, request):
-        """Poweroff host.
-
-        Return a coroutine.
-        """
+        """Poweroff host."""
         return self.host_control.shutdown()
 
     @api_process_hostcontrol

hassio/api/snapshots.py

@@ -112,10 +112,7 @@ async def snapshot_partial(self, request):
 
     @api_process
     def restore_full(self, request):
-        """Full-Restore a snapshot.
-
-        Return a coroutine.
-        """
+        """Full-Restore a snapshot."""
         snapshot = self._extract_snapshot(request)
         return asyncio.shield(
             self.snapshots.do_restore_full(snapshot), loop=self.loop)

hassio/api/supervisor.py

@@ -121,8 +121,5 @@ async def reload(self, request):
 
     @api_process_raw(CONTENT_TYPE_BINARY)
     def logs(self, request):
-        """Return supervisor docker logs.
-
-        Return a coroutine.
-        """
+        """Return supervisor docker logs."""
         return self.supervisor.logs()

hassio/const.py

@@ -1,7 +1,7 @@
 """Const file for HassIO."""
 from pathlib import Path
 
-HASSIO_VERSION = '0.54'
+HASSIO_VERSION = '0.55'
 
 URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
                       'hassio/{}/version.json')

hassio/dock/__init__.py

@@ -5,6 +5,7 @@
 
 import docker
 
+from .util import docker_process
 from ..const import LABEL_VERSION, LABEL_ARCH
 
 _LOGGER = logging.getLogger(__name__)
@@ -52,14 +53,10 @@ def process_metadata(self, metadata, force=False):
         if need_arch and LABEL_ARCH in metadata['Config']['Labels']:
             self.arch = metadata['Config']['Labels'][LABEL_ARCH]
 
-    async def install(self, tag):
+    @docker_process
+    def install(self, tag):
         """Pull docker image."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute install while a task is in progress")
-            return False
-
-        async with self._lock:
-            return await self.loop.run_in_executor(None, self._install, tag)
+        return self.loop.run_in_executor(None, self._install, tag)
 
     def _install(self, tag):
         """Pull docker image.
@@ -80,10 +77,7 @@ def _install(self, tag):
         return True
 
     def exists(self):
-        """Return True if docker image exists in local repo.
-
-        Return a Future.
-        """
+        """Return True if docker image exists in local repo."""
         return self.loop.run_in_executor(None, self._exists)
 
     def _exists(self):
@@ -126,14 +120,10 @@ def _is_running(self):
 
         return True
 
-    async def attach(self):
+    @docker_process
+    def attach(self):
         """Attach to running docker container."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute attach while a task is in progress")
-            return False
-
-        async with self._lock:
-            return await self.loop.run_in_executor(None, self._attach)
+        return self.loop.run_in_executor(None, self._attach)
 
     def _attach(self):
         """Attach to running docker container.
@@ -154,14 +144,10 @@ def _attach(self):
 
         return True
 
-    async def run(self):
+    @docker_process
+    def run(self):
         """Run docker image."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute run while a task is in progress")
-            return False
-
-        async with self._lock:
-            return await self.loop.run_in_executor(None, self._run)
+        return self.loop.run_in_executor(None, self._run)
 
     def _run(self):
         """Run docker image.
@@ -170,15 +156,10 @@ def _run(self):
         """
         raise NotImplementedError()
 
-    async def stop(self):
+    @docker_process
+    def stop(self):
         """Stop/remove docker container."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute stop while a task is in progress")
-            return False
-
-        async with self._lock:
-            await self.loop.run_in_executor(None, self._stop)
-            return True
+        return self.loop.run_in_executor(None, self._stop)
 
     def _stop(self):
         """Stop/remove and remove docker container.
@@ -188,7 +169,7 @@ def _stop(self):
         try:
             container = self.dock.containers.get(self.name)
         except docker.errors.DockerException:
-            return
+            return False
 
         if container.status == 'running':
             _LOGGER.info("Stop %s docker application", self.image)
@@ -199,14 +180,12 @@ def _stop(self):
             _LOGGER.info("Clean %s docker application", self.image)
             container.remove(force=True)
 
-    async def remove(self):
-        """Remove docker images."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute remove while a task is in progress")
-            return False
+        return True
 
-        async with self._lock:
-            return await self.loop.run_in_executor(None, self._remove)
+    @docker_process
+    def remove(self):
+        """Remove docker images."""
+        return self.loop.run_in_executor(None, self._remove)
 
     def _remove(self):
         """remove docker images.
@@ -235,16 +214,13 @@ def _remove(self):
         # clean metadata
         self.version = None
         self.arch = None
+
         return True
 
-    async def update(self, tag):
+    @docker_process
+    def update(self, tag):
         """Update a docker image."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute update while a task is in progress")
-            return False
-
-        async with self._lock:
-            return await self.loop.run_in_executor(None, self._update, tag)
+        return self.loop.run_in_executor(None, self._update, tag)
 
     def _update(self, tag):
         """Update a docker image.
@@ -258,22 +234,16 @@ def _update(self, tag):
         if not self._install(tag):
             return False
 
-        # container
+        # stop container & cleanup
         self._stop()
-
-        # cleanup images
         self._cleanup()
 
         return True
 
-    async def logs(self):
+    @docker_process
+    def logs(self):
         """Return docker logs of container."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute logs while a task is in progress")
-            return b""
-
-        async with self._lock:
-            return await self.loop.run_in_executor(None, self._logs)
+        return self.loop.run_in_executor(None, self._logs)
 
     def _logs(self):
         """Return docker logs of container.
@@ -290,14 +260,10 @@ def _logs(self):
         except docker.errors.DockerException as err:
             _LOGGER.warning("Can't grap logs from %s -> %s", self.image, err)
 
-    async def restart(self):
+    @docker_process
+    def restart(self):
         """Restart docker container."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute restart while a task is in progress")
-            return False
-
-        async with self._lock:
-            return await self.loop.run_in_executor(None, self._restart)
+        return self.loop.run_in_executor(None, self._restart)
 
     def _restart(self):
         """Restart docker container.
@@ -319,14 +285,10 @@ def _restart(self):
 
         return True
 
-    async def cleanup(self):
+    @docker_process
+    def cleanup(self):
         """Check if old version exists and cleanup."""
-        if self._lock.locked():
-            _LOGGER.error("Can't excute cleanup while a task is in progress")
-            return False
-
-        async with self._lock:
-            await self.loop.run_in_executor(None, self._cleanup)
+        return self.loop.run_in_executor(None, self._cleanup)
 
     def _cleanup(self):
         """Check if old version exists and cleanup.
@@ -337,7 +299,7 @@ def _cleanup(self):
             latest = self.dock.images.get(self.image)
         except docker.errors.DockerException:
             _LOGGER.warning("Can't find %s for cleanup", self.image)
-            return
+            return False
 
         for image in self.dock.images.list(name=self.image):
             if latest.id == image.id:
@@ -346,3 +308,17 @@ def _cleanup(self):
             with suppress(docker.errors.DockerException):
                 _LOGGER.info("Cleanup docker images: %s", image.tags)
                 self.dock.images.remove(image.id, force=True)
+
+        return True
+
+    @docker_process
+    def execute_command(self, command):
+        """Create a temporary container and run command."""
+        return self.loop.run_in_executor(None, self._execute_command, command)
+
+    def _execute_command(self, command):
+        """Create a temporary container and run command.
+
+        Need run inside executor.
+        """
+        raise NotImplementedError()