Add support for stats & code cleanup (#297)

* Add support for stats & code cleanup

* Add more stats

* Move code into own object

* Add to API

* Update API

* Add error handling

* fix lint

* fix block io

hassio/docker/interface.py

@@ -6,6 +6,7 @@ import logging
 import docker
 
 from .utils import docker_process
+from .stats import DockerStats
 from ..const import LABEL_VERSION, LABEL_ARCH
 from ..coresys import CoreSysAttributes
 
@@ -325,3 +326,24 @@ class DockerInterface(CoreSysAttributes):
         Need run inside executor.
         """
         raise NotImplementedError()
+
+    def stats(self):
+        """Read and return stats from container."""
+        return self._loop.run_in_executor(None, self._stats)
+
+    def _stats(self):
+        """Create a temporary container and run command.
+
+        Need run inside executor.
+        """
+        try:
+            container = self._docker.containers.get(self.name)
+        except docker.errors.DockerException:
+            return None
+
+        try:
+            stats = container.stats(stream=False)
+            return DockerStats(stats)
+        except docker.errors.DockerException as err:
+            _LOGGER.error("Can't read stats from %s: %s", self.name, err)
+            return None

hassio/docker/stats.py

@@ -0,0 +1,90 @@
+"""Calc & represent docker stats data."""
+from contextlib import suppress
+
+
+class DockerStats(object):
+    """Hold stats data from container inside."""
+
+    def __init__(self, stats):
+        """Initialize docker stats."""
+        self._cpu = 0.0
+        self._network_rx = 0
+        self._network_tx = 0
+        self._blk_read = 0
+        self._blk_write = 0
+
+        try:
+            self._memory_usage = stats['memory_stats']['usage']
+            self._memory_limit = stats['memory_stats']['limit']
+        except KeyError:
+            self._memory_usage = 0
+            self._memory_limit = 0
+
+        with suppress(KeyError):
+            self._calc_cpu_percent(stats)
+
+        with suppress(KeyError):
+            self._calc_network(stats['networks'])
+
+        with suppress(KeyError):
+            self._calc_block_io(stats['blkio_stats'])
+
+    def _calc_cpu_percent(self, stats):
+        """Calculate CPU percent."""
+        cpu_delta = stats['cpu_stats']['cpu_usage']['total_usage'] - \
+            stats['precpu_stats']['cpu_usage']['total_usage']
+        system_delta = stats['cpu_stats']['system_cpu_usage'] - \
+            stats['precpu_stats']['system_cpu_usage']
+
+        if system_delta > 0.0 and cpu_delta > 0.0:
+            self._cpu = (cpu_delta / system_delta) * \
+                len(stats['cpu_stats']['cpu_usage']['percpu_usage']) * 100.0
+
+    def _calc_network(self, networks):
+        """Calculate Network IO stats."""
+        for _, stats in networks.items():
+            self._network_rx += stats['rx_bytes']
+            self._network_tx += stats['tx_bytes']
+
+    def _calc_block_io(self, blkio):
+        """Calculate block IO stats."""
+        for stats in blkio['io_service_bytes_recursive']:
+            if stats['op'] == 'Read':
+                self._blk_read += stats['value']
+            elif stats['op'] == 'Write':
+                self._blk_write += stats['value']
+
+    @property
+    def cpu_percent(self):
+        """Return CPU percent."""
+        return self._cpu
+
+    @property
+    def memory_usage(self):
+        """Return memory usage."""
+        return self._memory_usage
+
+    @property
+    def memory_limit(self):
+        """Return memory limit."""
+        return self._memory_limit
+
+    @property
+    def network_rx(self):
+        """Return network rx stats."""
+        return self._network_rx
+
+    @property
+    def network_tx(self):
+        """Return network rx stats."""
+        return self._network_tx
+
+    @property
+    def blk_read(self):
+        """Return block IO read stats."""
+        return self._blk_read
+
+    @property
+    def blk_write(self):
+        """Return block IO write stats."""
+        return self._blk_write