Merge pull request #1028 from home-assistant/dev

Release 156

.dockerignore

@@ -0,0 +1,13 @@
+# General files
+.git
+.github
+
+# Test related files
+.tox
+
+# Temporary files
+**/__pycache__
+
+# virtualenv
+venv/
+ENV/

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,29 @@
+<!-- READ THIS FIRST:
+- If you need additional help with this template please refer to https://www.home-assistant.io/help/reporting_issues/
+- Make sure you are running the latest version of Home Assistant before reporting an issue: https://github.com/home-assistant/home-assistant/releases
+- Do not report issues for components here, plaese refer to https://github.com/home-assistant/home-assistant/issues
+- This is for bugs only. Feature and enhancement requests should go in our community forum: https://community.home-assistant.io/c/feature-requests
+- Provide as many details as possible. Paste logs, configuration sample and code into the backticks. Do not delete any text from this template!
+- If you have a problem with a Add-on, make a issue on there repository.
+-->
+
+**Home Assistant release with the issue:**
+<!--
+- Frontend -> Developer tools -> Info
+- Or use this command: hass --version
+-->
+
+**Operating environment (HassOS/Generic):**
+<!--
+Please provide details about your environment.
+-->
+
+**Supervisor logs:**
+<!--
+- Frontend -> Hass.io -> System
+- Or use this command: hassio su logs
+-->
+
+
+**Description of problem:**
+

.github/move.yml

@@ -0,0 +1,13 @@
+# Configuration for move-issues - https://github.com/dessant/move-issues
+
+# Delete the command comment. Ignored when the comment also contains other content
+deleteCommand: true
+# Close the source issue after moving
+closeSourceIssue: true
+# Lock the source issue after moving
+lockSourceIssue: false
+# Set custom aliases for targets
+# aliases:
+#   r: repo
+#   or: owner/repo
+

.github/release-drafter.yml

@@ -0,0 +1,4 @@
+template: |
+  ## What's Changed
+
+  $CHANGES

.gitignore

@@ -90,3 +90,6 @@ ENV/
 
 # pylint
 .pylint.d/
+
+# VS Code
+.vscode/

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "home-assistant-polymer"]
+	path = home-assistant-polymer
+	url = https://github.com/home-assistant/home-assistant-polymer
+	branch = dev

.travis.yml

@@ -1,12 +0,0 @@
-sudo: false
-matrix:
-  fast_finish: true
-  include:
-    - python: "3.5"
-
-cache:
-  directories:
-    - $HOME/.cache/pip
-install: pip install -U tox
-language: python
-script: tox

API.md

@@ -1,10 +1,11 @@
-# HassIO Server
+# Hass.io
 
-## HassIO REST API
+## Hass.io RESTful API
 
-Interface for HomeAssistant to controll things from supervisor.
+Interface for Home Assistant to control things from supervisor.
+
+On error / Code 400:
 
-On error:
 ```json
 {
     "result": "error",
@@ -12,7 +13,8 @@ On error:
 }
 ```
 
-On success
+On success / Code 200:
+
 ```json
 {
     "result": "ok",
@@ -20,197 +22,700 @@ On success
 }
 ```
 
-### HassIO
+For access to API you need set the `X-HASSIO-KEY` they will be available for Add-ons/HomeAssistant with environment `HASSIO_TOKEN`.
 
-- `/supervisor/ping`
+### Hass.io
 
-- `/supervisor/info`
+- GET `/supervisor/ping`
+
+This API call don't need a token.
+
+- GET `/supervisor/info`
+
+The addons from `addons` are only installed one.
 
 ```json
 {
     "version": "INSTALL_VERSION",
-    "current": "CURRENT_VERSION",
-    "beta": "true|false",
+    "last_version": "LAST_VERSION",
+    "arch": "armhf|aarch64|i386|amd64",
+    "channel": "stable|beta|dev",
+    "timezone": "TIMEZONE",
+    "ip_address": "ip address",
+    "wait_boot": "int",
     "addons": [
         {
             "name": "xy bla",
             "slug": "xy",
-            "version": "CURRENT_VERSION",
-            "installed": "none|INSTALL_VERSION",
-            "dedicated": "bool",
-            "description": "description"
+            "description": "description",
+            "repository": "12345678|null",
+            "version": "LAST_VERSION",
+            "installed": "INSTALL_VERSION",
+            "icon": "bool",
+            "logo": "bool",
+            "state": "started|stopped",
+        }
+    ],
+    "addons_repositories": [
+        "REPO_URL"
+    ]
+}
+```
+
+- POST `/supervisor/update`
+
+Optional:
+
+```json
+{
+    "version": "VERSION"
+}
+```
+
+- POST `/supervisor/options`
+
+```json
+{
+    "channel": "stable|beta|dev",
+    "timezone": "TIMEZONE",
+    "wait_boot": "int",
+    "addons_repositories": [
+        "REPO_URL"
+    ]
+}
+```
+
+- POST `/supervisor/reload`
+
+Reload addons/version.
+
+- GET `/supervisor/logs`
+
+Output is the raw docker log.
+
+- GET `/supervisor/stats`
+```json
+{
+    "cpu_percent": 0.0,
+    "memory_usage": 283123,
+    "memory_limit": 329392,
+    "network_tx": 0,
+    "network_rx": 0,
+    "blk_read": 0,
+    "blk_write": 0
+}
+```
+
+### Snapshot
+
+- GET `/snapshots`
+
+```json
+{
+    "snapshots": [
+        {
+            "slug": "SLUG",
+            "date": "ISO",
+            "name": "Custom name",
+            "type": "full|partial",
+            "protected": "bool"
         }
     ]
 }
 ```
 
-- `/supervisor/update`
-Optional:
+- POST `/snapshots/reload`
+
+- POST `/snapshots/new/upload`
+
+return:
 ```json
 {
-    "version": "VERSION"
+    "slug": ""
 }
 ```
 
-- `/supervisor/option`
+- POST `/snapshots/new/full`
+
 ```json
 {
-    "beta": "true|false"
+    "name": "Optional",
+    "password": "Optional"
 }
 ```
 
-- `/supervisor/reload`
+return:
+```json
+{
+    "slug": ""
+}
+```
 
-Reload addons/version.
+- POST `/snapshots/new/partial`
 
-- `/supervisor/logs`
+```json
+{
+    "name": "Optional",
+    "addons": ["ADDON_SLUG"],
+    "folders": ["FOLDER_NAME"],
+    "password": "Optional"
+}
+```
 
-Output the raw docker log
+return:
+```json
+{
+    "slug": ""
+}
+```
+
+- 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",
+    "protected": "bool",
+    "homeassistant": "version",
+    "addons": [
+        {
+            "slug": "ADDON_SLUG",
+            "name": "NAME",
+            "version": "INSTALLED_VERSION",
+            "size": "SIZE_IN_MB"
+        }
+    ],
+    "repositories": ["URL"],
+    "folders": ["NAME"]
+}
+```
+
+- POST `/snapshots/{slug}/remove`
+
+- GET `/snapshots/{slug}/download`
+
+- POST `/snapshots/{slug}/restore/full`
+
+```json
+{
+    "password": "Optional"
+}
+```
+
+- POST `/snapshots/{slug}/restore/partial`
+
+```json
+{
+    "homeassistant": "bool",
+    "addons": ["ADDON_SLUG"],
+    "folders": ["FOLDER_NAME"],
+    "password": "Optional"
+}
+```
 
 ### Host
 
-- `/host/shutdown`
+- POST `/host/reload`
 
-- `/host/reboot`
+- POST `/host/shutdown`
+
+- POST `/host/reboot`
+
+- GET `/host/info`
 
-- `/host/info`
-See HostControll info command.
 ```json
 {
-    "os": "",
-    "version": "",
-    "current": "",
-    "level": "",
-    "hostname": "",
+    "hostname": "hostname|null",
+    "features": ["shutdown", "reboot", "hostname", "services", "hassos"],
+    "operating_system": "HassOS XY|Ubuntu 16.4|null",
+    "kernel": "4.15.7|null",
+    "chassis": "specific|null",
+    "deployment": "stable|beta|dev|null",
+    "cpe": "xy|null",
 }
 ```
 
-- `/host/update`
-Optional:
-```json
-{
-    "version": "VERSION"
-}
-```
+- POST `/host/options`
 
-### Network
-
-- `/network/info`
-
-- `/network/options`
 ```json
 {
     "hostname": "",
-    "mode": "dhcp|fixed",
-    "ssid": "",
-    "ip": "",
-    "netmask": "",
-    "gateway": ""
 }
 ```
 
-### HomeAssistant
+- POST `/host/reload`
 
-- `/homeassistant/info`
+#### Services
+
+- GET `/host/services`
+```json
+{
+    "services": [
+        {
+            "name": "xy.service",
+            "description": "XY ...",
+            "state": "active|"
+        }
+    ]
+}
+```
+
+- POST `/host/service/{unit}/stop`
+
+- POST `/host/service/{unit}/start`
+
+- POST `/host/service/{unit}/reload`
+
+### HassOS
+
+- GET `/hassos/info`
+```json
+{
+    "version": "2.3",
+    "version_cli": "7",
+    "version_latest": "2.4",
+    "version_cli_latest": "8",
+    "board": "ova|rpi"
+}
+```
+
+- POST `/hassos/update`
+```json
+{
+    "version": "optional"
+}
+```
+
+- POST `/hassos/update/cli`
+```json
+{
+    "version": "optional"
+}
+```
+
+- POST `/hassos/config/sync`
+
+Load host configs from a USB stick.
+
+### Hardware
+
+- GET `/hardware/info`
+```json
+{
+    "serial": ["/dev/xy"],
+    "input": ["Input device name"],
+    "disk": ["/dev/sdax"],
+    "gpio": ["gpiochip0", "gpiochip100"],
+    "audio": {
+        "CARD_ID": {
+            "name": "xy",
+            "type": "microphone",
+            "devices": [
+                "chan_id": "channel ID",
+                "chan_type": "type of device"
+            ]
+        }
+    }
+}
+```
+
+- GET `/hardware/audio`
+```json
+{
+    "audio": {
+        "input": {
+            "0,0": "Mic"
+        },
+        "output": {
+            "1,0": "Jack",
+            "1,1": "HDMI"
+        }
+    }
+}
+```
+
+### Home Assistant
+
+- GET `/homeassistant/info`
 
 ```json
 {
     "version": "INSTALL_VERSION",
-    "current": "CURRENT_VERSION"
+    "last_version": "LAST_VERSION",
+    "arch": "arch",
+    "machine": "Image machine type",
+    "ip_address": "ip address",
+    "image": "str",
+    "custom": "bool -> if custom image",
+    "boot": "bool",
+    "port": 8123,
+    "ssl": "bool",
+    "watchdog": "bool",
+    "wait_boot": 600
 }
 ```
 
-- `/homeassistant/update`
+- POST `/homeassistant/update`
+
 Optional:
+
 ```json
 {
     "version": "VERSION"
 }
 ```
 
-- `/homeassistant/logs`
+- GET `/homeassistant/logs`
 
-Output the raw docker log
+Output is the raw Docker log.
 
-### REST API addons
+- POST `/homeassistant/restart`
+- POST `/homeassistant/check`
+- POST `/homeassistant/start`
+- POST `/homeassistant/stop`
+- POST `/homeassistant/rebuild`
+
+- POST `/homeassistant/options`
 
-- `/addons/{addon}/info`
 ```json
 {
-    "version": "VERSION",
-    "current": "CURRENT_VERSION",
-    "state": "started|stopped",
+    "image": "Optional|null",
+    "last_version": "Optional for custom image|null",
+    "port": "port for access hass",
+    "ssl": "bool",
+    "password": "",
+    "refresh_token": "",
+    "watchdog": "bool",
+    "wait_boot": 600
+}
+```
+
+Image with `null` and last_version with `null` reset this options.
+
+- POST/GET `/homeassistant/api`
+
+Proxy to real home-assistant instance.
+
+- GET `/homeassistant/websocket`
+
+Proxy to real websocket instance.
+
+- GET `/homeassistant/stats`
+```json
+{
+    "cpu_percent": 0.0,
+    "memory_usage": 283123,
+    "memory_limit": 329392,
+    "network_tx": 0,
+    "network_rx": 0,
+    "blk_read": 0,
+    "blk_write": 0
+}
+```
+
+### RESTful for API addons
+
+If an add-on will call itself, you can use `/addons/self/...`.
+
+- GET `/addons`
+
+Get all available addons.
+
+```json
+{
+    "addons": [
+        {
+            "name": "xy bla",
+            "slug": "xy",
+            "description": "description",
+            "repository": "core|local|REP_ID",
+            "version": "LAST_VERSION",
+            "installed": "none|INSTALL_VERSION",
+            "detached": "bool",
+            "available": "bool",
+            "build": "bool",
+            "url": "null|url",
+            "icon": "bool",
+            "logo": "bool"
+        }
+    ],
+    "repositories": [
+        {
+            "slug": "12345678",
+            "name": "Repitory Name|unknown",
+            "source": "URL_OF_REPOSITORY",
+            "url": "WEBSITE|REPOSITORY",
+            "maintainer": "BLA BLU <fla@dld.ch>|unknown"
+        }
+    ]
+}
+```
+
+- POST `/addons/reload`
+- GET `/addons/{addon}/info`
+
+```json
+{
+    "name": "xy bla",
+    "slug": "xdssd_xybla",
+    "description": "description",
+    "long_description": "null|markdown",
+    "auto_update": "bool",
+    "url": "null|url of addon",
+    "detached": "bool",
+    "available": "bool",
+    "arch": ["armhf", "aarch64", "i386", "amd64"],
+    "machine": "[raspberrypi2, tinker]",
+    "homeassistant": "null|min Home Assistant version",
+    "repository": "12345678|null",
+    "version": "null|VERSION_INSTALLED",
+    "last_version": "LAST_VERSION",
+    "state": "none|started|stopped",
     "boot": "auto|manual",
+    "build": "bool",
+    "options": "{}",
+    "network": "{}|null",
+    "network_description": "{}|null",
+    "host_network": "bool",
+    "host_pid": "bool",
+    "host_ipc": "bool",
+    "host_dbus": "bool",
+    "privileged": ["NET_ADMIN", "SYS_ADMIN"],
+    "apparmor": "disable|default|profile",
+    "devices": ["/dev/xy"],
+    "auto_uart": "bool",
+    "icon": "bool",
+    "logo": "bool",
+    "changelog": "bool",
+    "hassio_api": "bool",
+    "hassio_role": "default|homeassistant|manager|admin",
+    "homeassistant_api": "bool",
+    "auth_api": "bool",
+    "full_access": "bool",
+    "protected": "bool",
+    "rating": "1-6",
+    "stdin": "bool",
+    "webui": "null|http(s)://[HOST]:port/xy/zx",
+    "gpio": "bool",
+    "kernel_modules": "bool",
+    "devicetree": "bool",
+    "docker_api": "bool",
+    "audio": "bool",
+    "audio_input": "null|0,0",
+    "audio_output": "null|0,0",
+    "services_role": "['service:access']",
+    "discovery": "['service']",
+    "ip_address": "ip address",
+    "ingress": "bool",
+    "ingress_entry": "null|/api/hassio_ingress/slug",
+    "ingress_url": "null|/api/hassio_ingress/slug/entry.html",
+    "ingress_port": "null|int"
+}
+```
+
+- GET `/addons/{addon}/icon`
+
+- GET `/addons/{addon}/logo`
+
+- GET `/addons/{addon}/changelog`
+
+- POST `/addons/{addon}/options`
+
+```json
+{
+    "boot": "auto|manual",
+    "auto_update": "bool",
+    "network": {
+      "CONTAINER": "port|[ip, port]"
+    },
     "options": {},
+    "audio_output": "null|0,0",
+    "audio_input": "null|0,0"
 }
 ```
 
-- `/addons/{addon}/options`
+Reset custom network/audio/options, set it `null`.
+
+- POST `/addons/{addon}/security`
+
+This function is not callable by itself.
+
 ```json
 {
-    "boot": "auto|manual",
-    "options": {}, 
+    "protected": "bool",
 }
 ```
 
-- `/addons/{addon}/start`
+- POST `/addons/{addon}/start`
 
-- `/addons/{addon}/stop`
+- POST `/addons/{addon}/stop`
 
-- `/addons/{addon}/install`
-Optional:
+- POST `/addons/{addon}/install`
+
+- POST `/addons/{addon}/uninstall`
+
+- POST `/addons/{addon}/update`
+
+- GET `/addons/{addon}/logs`
+
+Output is the raw Docker log.
+
+- POST `/addons/{addon}/restart`
+
+- POST `/addons/{addon}/rebuild`
+
+Only supported for local build addons
+
+- POST `/addons/{addon}/stdin`
+
+Write data to add-on stdin
+
+- GET `/addons/{addon}/stats`
 ```json
 {
-    "version": "VERSION"
+    "cpu_percent": 0.0,
+    "memory_usage": 283123,
+    "memory_limit": 329392,
+    "network_tx": 0,
+    "network_rx": 0,
+    "blk_read": 0,
+    "blk_write": 0
 }
 ```
 
-- `/addons/{addon}/uninstall`
+### ingress
+
+- POST `/ingress/session`
+
+Create a new Session for access to ingress service.
 
-- `/addons/{addon}/update`
-Optional:
 ```json
 {
-    "version": "VERSION"
+    "session": "token"
 }
 ```
 
-- `/addons/{addon}/logs`
+- VIEW `/ingress/{token}`
 
-Output the raw docker log
+Ingress WebUI for this Add-on. The addon need support HASS Auth!
+Need ingress session as cookie.
 
-## Host Controll
+### discovery
 
-Communicate over unix socket with a host daemon.
-
-- commands
-```
-# info
--> {'os', 'version', 'current', 'level', 'hostname'}
-# reboot
-# shutdown
-# host-update [v]
-
-# network info
-# network hostname xy
-# network wlan ssd xy
-# network wlan password xy
-# network int ip xy
-# network int netmask xy
-# network int route xy
+- GET `/discovery`
+```json
+{
+    "discovery": [
+        {
+            "addon": "slug",
+            "service": "name",
+            "uuid": "uuid",
+            "config": {}
+        }
+    ]
+}
 ```
 
-level:
-- 1: power functions
-- 2: host update
-- 4: network functions
-
-Answer:
-```
-{}|OK|ERROR|WRONG
+- GET `/discovery/{UUID}`
+```json
+{
+    "addon": "slug",
+    "service": "name",
+    "uuid": "uuid",
+    "config": {}
+}
 ```
 
-- {}: json
-- OK: call was successfully
-- ERROR: error on call
-- WRONG: not supported
+- POST `/discovery`
+```json
+{
+    "service": "name",
+    "config": {}
+}
+```
+
+return:
+```json
+{
+    "uuid": "uuid"
+}
+```
+
+- DEL `/discovery/{UUID}`
+
+### Services
+
+- GET `/services`
+```json
+{
+    "services": [
+        {
+            "slug": "name",
+            "available": "bool",
+            "providers": "list"
+        }
+    ]
+}
+```
+
+#### MQTT
+
+- GET `/services/mqtt`
+```json
+{
+    "addon": "name",
+    "host": "xy",
+    "port": "8883",
+    "ssl": "bool",
+    "username": "optional",
+    "password": "optional",
+    "protocol": "3.1.1"
+}
+```
+
+- POST `/services/mqtt`
+```json
+{
+    "host": "xy",
+    "port": "8883",
+    "ssl": "bool|optional",
+    "username": "optional",
+    "password": "optional",
+    "protocol": "3.1.1"
+}
+```
+
+- DEL `/services/mqtt`
+
+### Misc
+
+- GET `/info`
+```json
+{
+    "supervisor": "version",
+    "homeassistant": "version",
+    "hassos": "null|version",
+    "hostname": "name",
+    "machine": "type",
+    "arch": "arch",
+    "supported_arch": ["arch1", "arch2"],
+    "channel": "stable|beta|dev"
+}
+```
+
+### Auth / SSO API
+
+You can use the user system on homeassistant. We handle this auth system on
+supervisor.
+
+You can call post `/auth`
+
+We support:
+- Json `{ "user|name": "...", "password": "..." }`
+- application/x-www-form-urlencoded `user|name=...&password=...`
+- BasicAuth

Dockerfile

@@ -0,0 +1,33 @@
+ARG BUILD_FROM
+FROM $BUILD_FROM
+
+# Install base
+RUN apk add --no-cache \
+    openssl \
+    libffi \
+    musl \
+    git \
+    socat \
+    glib \
+    libstdc++ \
+    eudev-libs
+
+# Install requirements
+COPY requirements.txt /usr/src/
+RUN apk add --no-cache --virtual .build-dependencies \
+    make \
+    g++ \
+    openssl-dev \
+    libffi-dev \
+    musl-dev \
+    && export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install --no-cache-dir -r /usr/src/requirements.txt \
+    && apk del .build-dependencies \
+    && rm -f /usr/src/requirements.txt
+
+# Install HassIO
+COPY . /usr/src/hassio
+RUN pip3 install --no-cache-dir /usr/src/hassio \
+    && rm -rf /usr/src/hassio
+
+CMD [ "python3", "-m", "hassio" ]

LICENSE

@@ -1,29 +1,201 @@
-BSD 3-Clause License
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
 
-Copyright (c) 2017, Pascal Vizeli
-All rights reserved.
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
+   1. Definitions.
 
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
 
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
 
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2017 Pascal Vizeli
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE.md
+graft hassio
+recursive-exclude * *.py[co]

README.md

@@ -1,56 +1,28 @@
-# HassIO
-First private cloud solution for home automation.
+# Hass.io
 
-It is a docker image (supervisor) they manage HomeAssistant docker and give a interface to controll itself over UI. It have a own eco system with addons to extend the functionality in a easy way.
+## First private cloud solution for home automation
 
-[HassIO-Addons](https://github.com/pvizeli/hassio-addons) | [HassIO-Build](https://github.com/pvizeli/hassio-build)
+Hass.io is a Docker-based system for managing your Home Assistant installation
+and related applications. The system is controlled via Home Assistant which
+communicates with the Supervisor. The Supervisor provides an API to manage the
+installation. This includes changing network settings or installing
+and updating software.
 
-**HassIO is at the moment on development and not ready to use productive!**
+![](misc/hassio.png?raw=true)
 
-## Feature in progress
-- Backup/Restore
-- MQTT addon
-- DHCP-Server addon
+## Installation
 
-# HomeAssistant
+Installation instructions can be found at <https://home-assistant.io/hassio>.
 
-## SSL
+## Development
 
-All addons they can create SSL certs do that in same schema. So you can put follow lines to your `configuration.yaml`.
-```yaml
-http:
-  ssl_certificate: /ssl/fullchain.pem
-  ssl_key: /ssl/privkey.pem
-```
+The development of the supervisor is a bit tricky. Not difficult but tricky.
 
-# Hardware Image
-The image is based on ResinOS and Yocto Linux. It comes with the HassIO supervisor pre-installed. This includes support to update the supervisor over the air. After flashing your host OS will not require any more maintenance! The image does not include Home Assistant, instead it will downloaded when the image boots up for the first time.
+- You can use the builder to build your supervisor: https://github.com/home-assistant/hassio-build/tree/master/builder
+- Go into a HassOS device or VM and pull your supervisor.
+- Set the developer modus on updater.json
+- Tag it as `homeassistant/xy-hassio-supervisor:latest`
+- Restart the service like `systemctl restart hassos-supervisor | journalctl -fu hassos-supervisor`
+- Test your changes
 
-Download can be found here: https://drive.google.com/drive/folders/0B2o1Uz6l1wVNbFJnb2gwNXJja28?usp=sharing
-
-After extracting the archive, flash it to a drive using [Etcher](https://etcher.io/).
-
-## History
-- **0.1**: First techpreview with dumy supervisor (ResinOS 2.0.0-RC5)
-- **0.2**: Fix some bugs and update it to HassIO 0.2
-- **0.3**: Update HostControll and feature for HassIO 0.3 (ResinOS 2.0.0 / need reflash)
-- **0.4**: Update HostControll and bring resinos OTA (resinhub) back (ResinOS 2.0.0-rev3)
-
-## Configuring the image
-You can configure the WiFi network that the image should connect to after flashing using [`resin-device-toolbox`](https://resinos.io/docs/raspberrypi3/gettingstarted/#install-resin-device-toolbox).
-
-## Developer access to ResinOS host
-Create an `authorized_keys` file in the boot partition of your SD card with your public key. After a boot it, you can acces your device as root over ssh on port 22222.
-
-## Troubleshooting
-
-Read logoutput from supervisor:
-```bash
-journalctl -f -u resin-supervisor.service
-docker logs homeassistant
-```
-
-## Install on a own System
-
-We have a installer to install HassIO on own linux device without our hardware image:
-https://github.com/pvizeli/hassio-build/tree/master/install
+Small Bugfix or improvements, make a PR. Significant change makes first an RFC.

azure-pipelines.yml

@@ -0,0 +1,45 @@
+# Python package
+# Create and test a Python package on multiple Python versions.
+# Add steps that analyze code, save the dist with the build record, publish to a PyPI-compatible index, and more:
+# https://docs.microsoft.com/azure/devops/pipelines/languages/python
+
+trigger:
+- master
+- dev
+
+pr:
+- dev
+
+jobs:
+
+- job: "Tox"
+
+  pool:
+    vmImage: 'ubuntu-16.04'
+
+  steps:
+  - task: UsePythonVersion@0
+    displayName: 'Use Python $(python.version)'
+    inputs:
+      versionSpec: '3.7'
+
+  - script: pip install tox
+    displayName: 'Install Tox'
+
+  - script: tox
+    displayName: 'Run Tox'
+
+
+- job: "JQ"
+
+  pool:
+    vmImage: 'ubuntu-16.04'
+
+  steps:
+  - script: sudo apt-get install -y jq
+    displayName: 'Install JQ'
+
+  - bash: |
+      shopt -s globstar
+      cat **/*.json | jq '.'
+    displayName: 'Run JQ'

hassio/__init__.py

@@ -1 +1 @@
-"""Init file for HassIO."""
+"""Init file for Hass.io."""

hassio/__main__.py

@@ -1,33 +1,60 @@
-"""Main file for HassIO."""
+"""Main file for Hass.io."""
 import asyncio
+from concurrent.futures import ThreadPoolExecutor
 import logging
 import sys
 
-import hassio.bootstrap as bootstrap
-import hassio.core as core
+from hassio import bootstrap
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def initialize_event_loop():
+    """Attempt to use uvloop."""
+    try:
+        import uvloop
+
+        uvloop.install()
+    except ImportError:
+        pass
+
+    return asyncio.get_event_loop()
+
+
 # pylint: disable=invalid-name
 if __name__ == "__main__":
     bootstrap.initialize_logging()
 
+    # Init async event loop
+    loop = initialize_event_loop()
+
+    # Check if all information are available to setup Hass.io
     if not bootstrap.check_environment():
-        exit(1)
+        sys.exit(1)
 
-    loop = asyncio.get_event_loop()
-    hassio = core.HassIO(loop)
+    # init executor pool
+    executor = ThreadPoolExecutor(thread_name_prefix="SyncWorker")
+    loop.set_default_executor(executor)
 
-    _LOGGER.info("Run Hassio setup")
-    loop.run_until_complete(hassio.setup())
+    _LOGGER.info("Initialize Hass.io setup")
+    coresys = loop.run_until_complete(bootstrap.initialize_coresys())
 
-    _LOGGER.info("Start Hassio task")
-    loop.call_soon_threadsafe(loop.create_task, hassio.start())
-    loop.call_soon_threadsafe(bootstrap.reg_signal, loop, hassio)
+    bootstrap.migrate_system_env(coresys)
 
-    loop.run_forever()
-    loop.close()
+    _LOGGER.info("Setup HassIO")
+    loop.run_until_complete(coresys.core.setup())
 
-    _LOGGER.info("Close Hassio")
-    sys.exit(hassio.exit_code)
+    loop.call_soon_threadsafe(loop.create_task, coresys.core.start())
+    loop.call_soon_threadsafe(bootstrap.reg_signal, loop)
+
+    try:
+        _LOGGER.info("Run Hass.io")
+        loop.run_forever()
+    finally:
+        _LOGGER.info("Stopping Hass.io")
+        loop.run_until_complete(coresys.core.stop())
+        executor.shutdown(wait=False)
+        loop.close()
+
+    _LOGGER.info("Close Hass.io")
+    sys.exit(0)

hassio/addons/__init__.py

@@ -1,164 +1,158 @@
-"""Init file for HassIO addons."""
+"""Init file for Hass.io add-ons."""
 import asyncio
 import logging
-import os
-import shutil
 
+from .addon import Addon
+from .repository import Repository
 from .data import AddonsData
-from .git import AddonsRepo
-from ..const import STATE_STOPPED, STATE_STARTED
-from ..dock.addon import DockerAddon
+from ..const import REPOSITORY_CORE, REPOSITORY_LOCAL, BOOT_AUTO, STATE_STARTED
+from ..coresys import CoreSysAttributes
 
 _LOGGER = logging.getLogger(__name__)
 
+BUILTIN_REPOSITORIES = set((REPOSITORY_CORE, REPOSITORY_LOCAL))
 
-class AddonManager(AddonsData):
-    """Manage addons inside HassIO."""
 
-    def __init__(self, config, loop, dock):
-        """Initialize docker base wrapper."""
-        super().__init__(config)
+class AddonManager(CoreSysAttributes):
+    """Manage add-ons inside Hass.io."""
 
-        self.loop = loop
-        self.dock = dock
-        self.repo = AddonsRepo(config, loop)
-        self.dockers = {}
+    def __init__(self, coresys):
+        """Initialize Docker base wrapper."""
+        self.coresys = coresys
+        self.data = AddonsData(coresys)
+        self.addons_obj = {}
+        self.repositories_obj = {}
 
-    async def prepare(self, arch):
-        """Startup addon management."""
-        self.arch = arch
+    @property
+    def list_addons(self):
+        """Return a list of all add-ons."""
+        return list(self.addons_obj.values())
 
-        # load addon repository
-        if await self.repo.load():
-            self.read_addons_repo()
+    @property
+    def list_installed(self):
+        """Return a list of installed add-ons."""
+        return [addon for addon in self.addons_obj.values()
+                if addon.is_installed]
 
-        # 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()
+    @property
+    def list_repositories(self):
+        """Return list of add-on repositories."""
+        return list(self.repositories_obj.values())
+
+    def get(self, addon_slug):
+        """Return an add-on from slug."""
+        return self.addons_obj.get(addon_slug)
+
+    def from_token(self, token):
+        """Return an add-on from Hass.io token."""
+        for addon in self.list_addons:
+            if addon.is_installed and token == addon.hassio_token:
+                return addon
+        return None
+
+    async def load(self):
+        """Start up add-on management."""
+        self.data.reload()
+
+        # Init Hass.io built-in repositories
+        repositories = \
+            set(self.sys_config.addons_repositories) | BUILTIN_REPOSITORIES
+
+        # Init custom repositories and load add-ons
+        await self.load_repositories(repositories)
 
     async def reload(self):
-        """Update addons from repo and reload list."""
-        if not await self.repo.pull():
-            return
-        self.read_addons_repo()
-
-        # remove stalled addons
-        for addon in self.list_removed:
-            _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 = []
-
-        for addon in boot_list:
-            tasks.append(self.loop.create_task(self.start(addon)))
-
-        _LOGGER.info("Startup %s run %d addons", start_type, len(tasks))
+        """Update add-ons from repository and reload list."""
+        tasks = [repository.update() for repository in
+                 self.repositories_obj.values()]
         if tasks:
-            await asyncio.wait(tasks, loop=self.loop)
+            await asyncio.wait(tasks)
 
-    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.is_installed(addon):
-            _LOGGER.error("Addon %s is already installed", addon)
-            return False
+        # update addons
+        await self.load_addons()
 
-        if not os.path.isdir(self.path_data(addon)):
-            _LOGGER.info("Create Home-Assistant addon data folder %s",
-                         self.path_data(addon))
-            os.mkdir(self.path_data(addon))
+    async def load_repositories(self, list_repositories):
+        """Add a new custom repository."""
+        new_rep = set(list_repositories)
+        old_rep = set(self.repositories_obj)
 
-        addon_docker = DockerAddon(
-            self.config, self.loop, self.dock, self, addon)
+        # add new repository
+        async def _add_repository(url):
+            """Helper function to async add repository."""
+            repository = Repository(self.coresys, url)
+            if not await repository.load():
+                _LOGGER.error("Can't load from repository %s", url)
+                return
+            self.repositories_obj[url] = repository
 
-        version = version or self.get_version(addon)
-        if not await addon_docker.install(version):
-            return False
+            # don't add built-in repository to config
+            if url not in BUILTIN_REPOSITORIES:
+                self.sys_config.add_addon_repository(url)
 
-        self.dockers[addon] = addon_docker
-        self.set_addon_install(addon, version)
-        return True
+        tasks = [_add_repository(url) for url in new_rep - old_rep]
+        if tasks:
+            await asyncio.wait(tasks)
 
-    async def uninstall(self, addon):
-        """Remove a addon."""
-        if not self.is_installed(addon):
-            _LOGGER.error("Addon %s is already uninstalled", addon)
-            return False
+        # del new repository
+        for url in old_rep - new_rep - BUILTIN_REPOSITORIES:
+            self.repositories_obj.pop(url).remove()
+            self.sys_config.drop_addon_repository(url)
 
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
+        # update data
+        self.data.reload()
+        await self.load_addons()
 
-        if not await self.dockers[addon].remove():
-            return False
+    async def load_addons(self):
+        """Update/add internal add-on store."""
+        all_addons = set(self.data.system) | set(self.data.cache)
 
-        if os.path.isdir(self.path_data(addon)):
-            _LOGGER.info("Remove Home-Assistant addon data folder %s",
-                         self.path_data(addon))
-            shutil.rmtree(self.path_data(addon))
+        # calc diff
+        add_addons = all_addons - set(self.addons_obj)
+        del_addons = set(self.addons_obj) - all_addons
 
-        self.dockers.pop(addon)
-        self.set_addon_uninstall(addon)
-        return True
+        _LOGGER.info("Load add-ons: %d all - %d new - %d remove",
+                     len(all_addons), len(add_addons), len(del_addons))
 
-    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
+        # new addons
+        tasks = []
+        for addon_slug in add_addons:
+            addon = Addon(self.coresys, addon_slug)
 
-        if await self.dockers[addon].is_running():
-            return STATE_STARTED
-        return STATE_STOPPED
+            tasks.append(addon.load())
+            self.addons_obj[addon_slug] = addon
 
-    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
+        if tasks:
+            await asyncio.wait(tasks)
 
-        if not self.write_addon_options(addon):
-            _LOGGER.error("Can't write options for addon %s", addon)
-            return False
+        # remove
+        for addon_slug in del_addons:
+            self.addons_obj.pop(addon_slug)
 
-        return await self.dockers[addon].run()
+    async def boot(self, stage):
+        """Boot add-ons with mode auto."""
+        tasks = []
+        for addon in self.addons_obj.values():
+            if addon.is_installed and addon.boot == BOOT_AUTO and \
+                    addon.startup == stage:
+                tasks.append(addon.start())
 
-    async def stop(self, addon):
-        """Stop addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
+        _LOGGER.info("Startup %s run %d add-ons", stage, len(tasks))
+        if tasks:
+            await asyncio.wait(tasks)
+            await asyncio.sleep(self.sys_config.wait_boot)
 
-        return await self.dockers[addon].stop()
+    async def shutdown(self, stage):
+        """Shutdown addons."""
+        tasks = []
+        for addon in self.addons_obj.values():
+            if addon.is_installed and \
+                    await addon.state() == STATE_STARTED and \
+                    addon.startup == stage:
+                tasks.append(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_version(addon)
-        is_running = self.dockers[addon].is_running()
-
-        # update
-        if await self.dockers[addon].update(version):
-            self.set_addon_update(addon, version)
-            if is_running:
-                await self.start(addon)
-            return True
-        return False
-
-    async def logs(self, addon):
-        """Return addons log output."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
-
-        return await self.dockers[addon].logs()
+        _LOGGER.info("Shutdown %s stop %d add-ons", stage, len(tasks))
+        if tasks:
+            await asyncio.wait(tasks)

hassio/addons/build.py

@@ -0,0 +1,82 @@
+"""Hass.io add-on build environment."""
+from __future__ import annotations
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict
+
+from ..const import ATTR_ARGS, ATTR_BUILD_FROM, ATTR_SQUASH, META_ADDON
+from ..coresys import CoreSys, CoreSysAttributes
+from ..utils.json import JsonConfig
+from .validate import SCHEMA_BUILD_CONFIG
+
+if TYPE_CHECKING:
+    from .addon import Addon
+
+
+class AddonBuild(JsonConfig, CoreSysAttributes):
+    """Handle build options for add-ons."""
+
+    def __init__(self, coresys: CoreSys, slug: str) -> None:
+        """Initialize Hass.io add-on builder."""
+        self.coresys: CoreSys = coresys
+        self._id: str = slug
+
+        super().__init__(
+            Path(self.addon.path_location, 'build.json'), SCHEMA_BUILD_CONFIG)
+
+    def save_data(self):
+        """Ignore save function."""
+
+    @property
+    def addon(self) -> Addon:
+        """Return add-on of build data."""
+        return self.sys_addons.get(self._id)
+
+    @property
+    def base_image(self) -> str:
+        """Base images for this add-on."""
+        return self._data[ATTR_BUILD_FROM].get(
+            self.sys_arch.default,
+            f"homeassistant/{self.sys_arch.default}-base:latest")
+
+    @property
+    def squash(self) -> bool:
+        """Return True or False if squash is active."""
+        return self._data[ATTR_SQUASH]
+
+    @property
+    def additional_args(self) -> Dict[str, str]:
+        """Return additional Docker build arguments."""
+        return self._data[ATTR_ARGS]
+
+    def get_docker_args(self, version):
+        """Create a dict with Docker build arguments."""
+        args = {
+            'path': str(self.addon.path_location),
+            'tag': f"{self.addon.image}:{version}",
+            'pull': True,
+            'forcerm': True,
+            'squash': self.squash,
+            'labels': {
+                'io.hass.version': version,
+                'io.hass.arch': self.sys_arch.default,
+                'io.hass.type': META_ADDON,
+                'io.hass.name': self._fix_label('name'),
+                'io.hass.description': self._fix_label('description'),
+            },
+            'buildargs': {
+                'BUILD_FROM': self.base_image,
+                'BUILD_VERSION': version,
+                'BUILD_ARCH': self.sys_arch.default,
+                **self.additional_args,
+            }
+        }
+
+        if self.addon.url:
+            args['labels']['io.hass.url'] = self.addon.url
+
+        return args
+
+    def _fix_label(self, label_name: str) -> str:
+        """Remove characters they are not supported."""
+        label = getattr(self.addon, label_name, "")
+        return label.replace("'", "")

hassio/addons/built-in.json

@@ -0,0 +1,12 @@
+{
+    "local": {
+        "name": "Local add-ons",
+        "url": "https://home-assistant.io/hassio",
+        "maintainer": "you"
+    },
+    "core": {
+        "name": "Official add-ons",
+        "url": "https://home-assistant.io/addons",
+        "maintainer": "Home Assistant"
+    }
+}

hassio/addons/data.py

@@ -1,242 +1,136 @@
-"""Init file for HassIO addons."""
+"""Init file for Hass.io add-on data."""
 import logging
-import glob
+from pathlib import Path
 
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
-from .validate import validate_options, SCHEMA_ADDON_CONFIG
 from ..const import (
-    FILE_HASSIO_ADDONS, ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON,
-    ATTR_STARTUP, ATTR_BOOT, ATTR_MAP_SSL, ATTR_MAP_CONFIG, ATTR_OPTIONS,
-    ATTR_PORTS, BOOT_AUTO, DOCKER_REPO, ATTR_INSTALLED, ATTR_SCHEMA,
-    ATTR_IMAGE, ATTR_DEDICATED)
-from ..config import Config
-from ..tools import read_json_file, write_json_file
+    ATTR_LOCATON,
+    ATTR_REPOSITORY,
+    ATTR_SLUG,
+    ATTR_SYSTEM,
+    ATTR_USER,
+    FILE_HASSIO_ADDONS,
+    REPOSITORY_CORE,
+    REPOSITORY_LOCAL,
+)
+from ..coresys import CoreSysAttributes
+from ..exceptions import JsonFileError
+from ..utils.json import JsonConfig, read_json_file
+from .utils import extract_hash_from_path
+from .validate import SCHEMA_ADDON_CONFIG, SCHEMA_ADDONS_FILE, SCHEMA_REPOSITORY_CONFIG
 
 _LOGGER = logging.getLogger(__name__)
 
-ADDONS_REPO_PATTERN = "{}/*/config.json"
-SYSTEM = "system"
-USER = "user"
 
+class AddonsData(JsonConfig, CoreSysAttributes):
+    """Hold data for Add-ons inside Hass.io."""
 
-class AddonsData(Config):
-    """Hold data for addons inside HassIO."""
-
-    def __init__(self, config):
+    def __init__(self, coresys):
         """Initialize data holder."""
-        super().__init__(FILE_HASSIO_ADDONS)
-        self.config = config
-        self._addons_data = self._data.get(SYSTEM, {})
-        self._user_data = self._data.get(USER, {})
-        self._current_data = {}
-        self.arch = None
+        super().__init__(FILE_HASSIO_ADDONS, SCHEMA_ADDONS_FILE)
+        self.coresys = coresys
+        self._repositories = {}
+        self._cache = {}
 
-    def save(self):
-        """Store data to config file."""
-        self._data = {
-            USER: self._user_data,
-            SYSTEM: self._addons_data,
-        }
-        super().save()
+    @property
+    def user(self):
+        """Return local add-on user data."""
+        return self._data[ATTR_USER]
 
-    def read_addons_repo(self):
-        """Read data from addons repository."""
-        self._current_data = {}
+    @property
+    def system(self):
+        """Return local add-on data."""
+        return self._data[ATTR_SYSTEM]
 
-        self._read_addons_folder(self.config.path_addons_repo)
-        self._read_addons_folder(self.config.path_addons_custom)
+    @property
+    def cache(self):
+        """Return add-on data from cache/repositories."""
+        return self._cache
 
-    def _read_addons_folder(self, folder):
-        """Read data from addons folder."""
-        pattern = ADDONS_REPO_PATTERN.format(folder)
+    @property
+    def repositories(self):
+        """Return add-on data from repositories."""
+        return self._repositories
 
-        for addon in glob.iglob(pattern):
+    def reload(self):
+        """Read data from add-on repository."""
+        self._cache = {}
+        self._repositories = {}
+
+        # read core repository
+        self._read_addons_folder(self.sys_config.path_addons_core, REPOSITORY_CORE)
+
+        # read local repository
+        self._read_addons_folder(self.sys_config.path_addons_local, REPOSITORY_LOCAL)
+
+        # add built-in repositories information
+        self._set_builtin_repositories()
+
+        # read custom git repositories
+        for repository_element in self.sys_config.path_addons_git.iterdir():
+            if repository_element.is_dir():
+                self._read_git_repository(repository_element)
+
+    def _read_git_repository(self, path):
+        """Process a custom repository folder."""
+        slug = extract_hash_from_path(path)
+
+        # exists repository json
+        repository_file = Path(path, "repository.json")
+        try:
+            repository_info = SCHEMA_REPOSITORY_CONFIG(read_json_file(repository_file))
+        except JsonFileError:
+            _LOGGER.warning(
+                "Can't read repository information from %s", repository_file
+            )
+            return
+        except vol.Invalid:
+            _LOGGER.warning("Repository parse error %s", repository_file)
+            return
+
+        # process data
+        self._repositories[slug] = repository_info
+        self._read_addons_folder(path, slug)
+
+    def _read_addons_folder(self, path, repository):
+        """Read data from add-ons folder."""
+        for addon in path.glob("**/config.json"):
             try:
                 addon_config = read_json_file(addon)
-
-                addon_config = SCHEMA_ADDON_CONFIG(addon_config)
-                self._current_data[addon_config[ATTR_SLUG]] = addon_config
-
-            except (OSError, KeyError):
-                _LOGGER.warning("Can't read %s", addon)
-
-            except vol.Invalid as ex:
-                _LOGGER.warning("Can't read %s -> %s", addon,
-                                humanize_error(addon_config, ex))
-
-    @property
-    def list_installed(self):
-        """Return a list of installed addons."""
-        return set(self._addons_data.keys())
-
-    @property
-    def list(self):
-        """Return a list of available addons."""
-        data = []
-        all_addons = {**self._addons_data, **self._current_data}
-        dedicated = self.list_removed
-
-        for addon, values in all_addons.items():
-            i_version = self._addons_data.get(addon, {}).get(ATTR_VERSION)
-
-            data.append({
-                ATTR_NAME: values[ATTR_NAME],
-                ATTR_SLUG: values[ATTR_SLUG],
-                ATTR_DESCRIPTON: values[ATTR_DESCRIPTON],
-                ATTR_VERSION: values[ATTR_VERSION],
-                ATTR_INSTALLED: i_version,
-                ATTR_DEDICATED: addon in dedicated,
-            })
-
-        return data
-
-    def list_startup(self, start_type):
-        """Get list of installed addon with need start by type."""
-        addon_list = set()
-        for addon in self._addons_data.keys():
-            if self.get_boot(addon) != BOOT_AUTO:
+            except JsonFileError:
+                _LOGGER.warning("Can't read %s from repository %s", addon, repository)
                 continue
 
+            # validate
             try:
-                if self._addons_data[addon][ATTR_STARTUP] == start_type:
-                    addon_list.add(addon)
-            except KeyError:
-                _LOGGER.warning("Orphaned addon detect %s", addon)
+                addon_config = SCHEMA_ADDON_CONFIG(addon_config)
+            except vol.Invalid as ex:
+                _LOGGER.warning(
+                    "Can't read %s: %s", addon, humanize_error(addon_config, ex)
+                )
                 continue
 
-        return addon_list
+            # Generate slug
+            addon_slug = "{}_{}".format(repository, addon_config[ATTR_SLUG])
 
-    @property
-    def list_removed(self):
-        """Return local addons they not support from repo."""
-        addon_list = set()
-        for addon in self._addons_data.keys():
-            if addon not in self._current_data:
-                addon_list.add(addon)
-
-        return addon_list
-
-    def exists_addon(self, addon):
-        """Return True if a addon exists."""
-        return addon in self._current_data or addon in self._addons_data
-
-    def is_installed(self, addon):
-        """Return True if a addon is installed."""
-        return addon in self._addons_data
-
-    def version_installed(self, addon):
-        """Return installed version."""
-        return self._addons_data[addon][ATTR_VERSION]
-
-    def set_addon_install(self, addon, version):
-        """Set addon as installed."""
-        self._addons_data[addon] = self._current_data[addon]
-        self._user_data[addon] = {
-            ATTR_OPTIONS: {},
-        }
-        self.save()
-
-    def set_addon_uninstall(self, addon):
-        """Set addon as uninstalled."""
-        self._addons_data.pop(addon, None)
-        self._user_data.pop(addon, None)
-        self.save()
-
-    def set_addon_update(self, addon, version):
-        """Update version of addon."""
-        self._addons_data[addon] = self._current_data[addon]
-        self.save()
-
-    def set_options(self, addon, options):
-        """Store user addon options."""
-        self._user_data[addon][ATTR_OPTIONS] = 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._addons_data[addon][ATTR_OPTIONS],
-            **self._user_data[addon][ATTR_OPTIONS],
-        }
-
-    def get_boot(self, addon):
-        """Return boot config with prio local settings."""
-        if ATTR_BOOT in self._user_data[addon]:
-            return self._user_data[addon][ATTR_BOOT]
-
-        return self._addons_data[addon][ATTR_BOOT]
-
-    def get_name(self, addon):
-        """Return name of addon."""
-        return self._addons_data[addon][ATTR_NAME]
-
-    def get_description(self, addon):
-        """Return description of addon."""
-        return self._addons_data[addon][ATTR_DESCRIPTON]
-
-    def get_version(self, addon):
-        """Return version of addon."""
-        if addon not in self._current_data:
-            return self.version_installed(addon)
-        return self._current_data[addon][ATTR_VERSION]
-
-    def get_ports(self, addon):
-        """Return ports of addon."""
-        return self._addons_data[addon].get(ATTR_PORTS)
-
-    def get_image(self, addon):
-        """Return image name of addon."""
-        addon_data = self._addons_data.get(addon, self._current_data[addon])
-
-        if ATTR_IMAGE not in addon_data:
-            return "{}/{}-addon-{}".format(DOCKER_REPO, self.arch, addon)
-
-        return addon_data[ATTR_IMAGE]
-
-    def need_config(self, addon):
-        """Return True if config map is needed."""
-        return self._addons_data[addon][ATTR_MAP_CONFIG]
-
-    def need_ssl(self, addon):
-        """Return True if ssl map is needed."""
-        return self._addons_data[addon][ATTR_MAP_SSL]
-
-    def path_data(self, addon):
-        """Return addon data path inside supervisor."""
-        return "{}/{}".format(self.config.path_addons_data, addon)
-
-    def path_data_docker(self, addon):
-        """Return addon data path external for docker."""
-        return "{}/{}".format(self.config.path_addons_data_docker, addon)
-
-    def path_addon_options(self, addon):
-        """Return path to addons options."""
-        return "{}/options.json".format(self.path_data(addon))
-
-    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)
+            # store
+            addon_config[ATTR_REPOSITORY] = repository
+            addon_config[ATTR_LOCATON] = str(addon.parent)
+            self._cache[addon_slug] = addon_config
 
+    def _set_builtin_repositories(self):
+        """Add local built-in repository into dataset."""
         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))
+            builtin_file = Path(__file__).parent.joinpath("built-in.json")
+            builtin_data = read_json_file(builtin_file)
+        except JsonFileError:
+            _LOGGER.warning("Can't read built-in json")
+            return
 
-        return False
+        # core repository
+        self._repositories[REPOSITORY_CORE] = builtin_data[REPOSITORY_CORE]
 
-    def get_schema(self, addon):
-        """Create a schema for addon options."""
-        raw_schema = self._addons_data[addon][ATTR_SCHEMA]
-
-        schema = vol.Schema(vol.All(dict, validate_options(raw_schema)))
-        return schema
+        # local repository
+        self._repositories[REPOSITORY_LOCAL] = builtin_data[REPOSITORY_LOCAL]

hassio/addons/git.py

@@ -1,71 +1,155 @@
-"""Init file for HassIO addons git."""
+"""Init file for Hass.io add-on Git."""
 import asyncio
 import logging
-import os
+import functools as ft
+from pathlib import Path
+import shutil
 
 import git
 
-from ..const import URL_HASSIO_ADDONS
+from .utils import get_hash_from_repository
+from ..const import URL_HASSIO_ADDONS, ATTR_URL, ATTR_BRANCH
+from ..coresys import CoreSysAttributes
+from ..validate import RE_REPOSITORY
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class AddonsRepo(object):
-    """Manage addons git repo."""
+class GitRepo(CoreSysAttributes):
+    """Manage Add-on Git repository."""
 
-    def __init__(self, config, loop):
-        """Initialize docker base wrapper."""
-        self.config = config
-        self.loop = loop
+    def __init__(self, coresys, path, url):
+        """Initialize Git base wrapper."""
+        self.coresys = coresys
         self.repo = None
-        self._lock = asyncio.Lock(loop=loop)
+        self.path = path
+        self.lock = asyncio.Lock(loop=coresys.loop)
+
+        self._data = RE_REPOSITORY.match(url).groupdict()
+
+    @property
+    def url(self):
+        """Return repository URL."""
+        return self._data[ATTR_URL]
+
+    @property
+    def branch(self):
+        """Return repository branch."""
+        return self._data[ATTR_BRANCH]
 
     async def load(self):
-        """Init git addon repo."""
-        if not os.path.isdir(self.config.path_addons_repo):
+        """Init Git add-on repository."""
+        if not self.path.is_dir():
             return await self.clone()
 
-        async with self._lock:
+        async with self.lock:
             try:
-                _LOGGER.info("Load addons repository")
-                self.repo = await self.loop.run_in_executor(
-                    None, git.Repo, self.config.path_addons_repo)
+                _LOGGER.info("Load add-on %s repository", self.path)
+                self.repo = await self.sys_run_in_executor(
+                    git.Repo, str(self.path))
 
-            except (git.InvalidGitRepositoryError, git.NoSuchPathError) as err:
-                _LOGGER.error("Can't load addons repo: %s.", err)
+            except (git.InvalidGitRepositoryError, git.NoSuchPathError,
+                    git.GitCommandError) as err:
+                _LOGGER.error("Can't load %s repo: %s.", self.path, err)
+                self._remove()
                 return False
 
             return True
 
     async def clone(self):
-        """Clone git addon repo."""
-        async with self._lock:
-            try:
-                _LOGGER.info("Clone addons repository")
-                self.repo = await self.loop.run_in_executor(
-                    None, git.Repo.clone_from, URL_HASSIO_ADDONS,
-                    self.config.path_addons_repo)
+        """Clone git add-on repository."""
+        async with self.lock:
+            git_args = {
+                attribute: value
+                for attribute, value in (
+                    ('recursive', True),
+                    ('branch', self.branch),
+                    ('depth', 1),
+                    ('shallow-submodules', True)
+                ) if value is not None
+            }
 
-            except (git.InvalidGitRepositoryError, git.NoSuchPathError) as err:
-                _LOGGER.error("Can't clone addons repo: %s.", err)
+            try:
+                _LOGGER.info("Clone add-on %s repository", self.url)
+                self.repo = await self.sys_run_in_executor(ft.partial(
+                    git.Repo.clone_from, self.url, str(self.path),
+                    **git_args
+                ))
+
+            except (git.InvalidGitRepositoryError, git.NoSuchPathError,
+                    git.GitCommandError) as err:
+                _LOGGER.error("Can't clone %s repository: %s.", self.url, err)
+                self._remove()
                 return False
 
             return True
 
     async def pull(self):
-        """Pull git addon repo."""
-        if self._lock.locked():
-            _LOGGER.warning("It is already a task in progress.")
+        """Pull Git add-on repo."""
+        if self.lock.locked():
+            _LOGGER.warning("It is already a task in progress")
             return False
 
-        async with self._lock:
-            try:
-                _LOGGER.info("Pull addons repository")
-                await self.loop.run_in_executor(
-                    None, self.repo.remotes.origin.pull)
+        async with self.lock:
+            _LOGGER.info("Update add-on %s repository", self.url)
+            branch = self.repo.active_branch.name
 
-            except (git.InvalidGitRepositoryError, git.NoSuchPathError) as err:
-                _LOGGER.error("Can't pull addons repo: %s.", err)
+            try:
+                # Download data
+                await self.sys_run_in_executor(ft.partial(
+                    self.repo.remotes.origin.fetch, **{
+                        'update-shallow': True,
+                        'depth': 1,
+                    }))
+
+                # Jump on top of that
+                await self.sys_run_in_executor(ft.partial(
+                    self.repo.git.reset, f"origin/{branch}", hard=True))
+
+                # Cleanup old data
+                await self.sys_run_in_executor(ft.partial(
+                    self.repo.git.clean, "-xdf"))
+
+            except (git.InvalidGitRepositoryError, git.NoSuchPathError,
+                    git.GitCommandError) as err:
+                _LOGGER.error("Can't update %s repo: %s.", self.url, err)
                 return False
 
             return True
+
+    def _remove(self):
+        """Remove a repository."""
+        if not self.path.is_dir():
+            return
+
+        def log_err(funct, path, _):
+            """Log error."""
+            _LOGGER.warning("Can't remove %s", path)
+
+        shutil.rmtree(str(self.path), onerror=log_err)
+
+
+class GitRepoHassIO(GitRepo):
+    """Hass.io add-ons repository."""
+
+    def __init__(self, coresys):
+        """Initialize Git Hass.io add-on repository."""
+        super().__init__(
+            coresys, coresys.config.path_addons_core, URL_HASSIO_ADDONS)
+
+
+class GitRepoCustom(GitRepo):
+    """Custom add-ons repository."""
+
+    def __init__(self, coresys, url):
+        """Initialize custom Git Hass.io addo-n repository."""
+        path = Path(
+            coresys.config.path_addons_git,
+            get_hash_from_repository(url))
+
+        super().__init__(coresys, path, url)
+
+    def remove(self):
+        """Remove a custom repository."""
+        _LOGGER.info("Remove custom add-on repository %s", self.url)
+        self._remove()

hassio/addons/repository.py

@@ -0,0 +1,73 @@
+"""Represent a Hass.io repository."""
+from .git import GitRepoHassIO, GitRepoCustom
+from .utils import get_hash_from_repository
+from ..const import (
+    REPOSITORY_CORE, REPOSITORY_LOCAL, ATTR_NAME, ATTR_URL, ATTR_MAINTAINER)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
+
+UNKNOWN = 'unknown'
+
+
+class Repository(CoreSysAttributes):
+    """Repository in Hass.io."""
+
+    def __init__(self, coresys, repository):
+        """Initialize repository object."""
+        self.coresys = coresys
+        self.source = None
+        self.git = None
+
+        if repository == REPOSITORY_LOCAL:
+            self._id = repository
+        elif repository == REPOSITORY_CORE:
+            self._id = repository
+            self.git = GitRepoHassIO(coresys)
+        else:
+            self._id = get_hash_from_repository(repository)
+            self.git = GitRepoCustom(coresys, repository)
+            self.source = repository
+
+    @property
+    def _mesh(self):
+        """Return data struct repository."""
+        return self.sys_addons.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 add-on repository."""
+        if self.git:
+            return await self.git.pull()
+        return True
+
+    def remove(self):
+        """Remove add-on repository."""
+        if self._id in (REPOSITORY_CORE, REPOSITORY_LOCAL):
+            raise APIError("Can't remove built-in repositories!")
+
+        self.git.remove()

hassio/addons/utils.py

@@ -0,0 +1,131 @@
+"""Util add-ons functions."""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import logging
+from pathlib import Path
+import re
+from typing import TYPE_CHECKING
+
+from ..const import (
+    PRIVILEGED_DAC_READ_SEARCH,
+    PRIVILEGED_NET_ADMIN,
+    PRIVILEGED_SYS_ADMIN,
+    PRIVILEGED_SYS_MODULE,
+    PRIVILEGED_SYS_PTRACE,
+    PRIVILEGED_SYS_RAWIO,
+    ROLE_ADMIN,
+    ROLE_MANAGER,
+    SECURITY_DISABLE,
+    SECURITY_PROFILE,
+)
+from ..exceptions import AddonsNotSupportedError
+
+if TYPE_CHECKING:
+    from .addon import Addon
+
+RE_SHA1 = re.compile(r"[a-f0-9]{8}")
+_LOGGER = logging.getLogger(__name__)
+
+
+def rating_security(addon: Addon) -> int:
+    """Return 1-6 for security rating.
+
+    1 = not secure
+    6 = high secure
+    """
+    rating = 5
+
+    # AppArmor
+    if addon.apparmor == SECURITY_DISABLE:
+        rating += -1
+    elif addon.apparmor == SECURITY_PROFILE:
+        rating += 1
+
+    # Home Assistant Login
+    if addon.access_auth_api:
+        rating += 1
+
+    # Privileged options
+    if any(
+        privilege in addon.privileged
+        for privilege in (
+            PRIVILEGED_NET_ADMIN,
+            PRIVILEGED_SYS_ADMIN,
+            PRIVILEGED_SYS_RAWIO,
+            PRIVILEGED_SYS_PTRACE,
+            PRIVILEGED_SYS_MODULE,
+            PRIVILEGED_DAC_READ_SEARCH,
+        )
+    ):
+        rating += -1
+
+    # API Hass.io role
+    if addon.hassio_role == ROLE_MANAGER:
+        rating += -1
+    elif addon.hassio_role == ROLE_ADMIN:
+        rating += -2
+
+    # Not secure Networking
+    if addon.host_network:
+        rating += -1
+
+    # Insecure PID namespace
+    if addon.host_pid:
+        rating += -2
+
+    # Full Access
+    if addon.with_full_access:
+        rating += -2
+
+    # Docker Access
+    if addon.access_docker_api:
+        rating = 1
+
+    return max(min(6, rating), 1)
+
+
+def get_hash_from_repository(name: str) -> str:
+    """Generate a hash from repository."""
+    key = name.lower().encode()
+    return hashlib.sha1(key).hexdigest()[:8]
+
+
+def extract_hash_from_path(path: Path) -> str:
+    """Extract repo id from path."""
+    repository_dir = path.parts[-1]
+
+    if not RE_SHA1.match(repository_dir):
+        return get_hash_from_repository(repository_dir)
+    return repository_dir
+
+
+def check_installed(method):
+    """Wrap function with check if add-on 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)
+            raise AddonsNotSupportedError()
+        return await method(addon, *args, **kwargs)
+
+    return wrap_check
+
+
+async def remove_data(folder: Path) -> None:
+    """Remove folder and reset privileged."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "rm", "-rf", str(folder), stdout=asyncio.subprocess.DEVNULL
+        )
+
+        _, error_msg = await proc.communicate()
+    except OSError as err:
+        error_msg = str(err)
+    else:
+        if proc.returncode == 0:
+            return
+
+    _LOGGER.error("Can't remove Add-on Data: %s", error_msg)

hassio/addons/validate.py

@@ -1,11 +1,101 @@
-"""Validate addons options schema."""
+"""Validate add-ons options schema."""
+import logging
+import re
+import secrets
+import uuid
+
 import voluptuous as vol
 
 from ..const import (
-    ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON, ATTR_STARTUP,
-    ATTR_BOOT, ATTR_MAP_SSL, ATTR_MAP_CONFIG, ATTR_OPTIONS,
-    ATTR_PORTS, STARTUP_ONCE, STARTUP_AFTER, STARTUP_BEFORE, BOOT_AUTO,
-    BOOT_MANUAL, ATTR_SCHEMA, ATTR_IMAGE)
+    ARCH_ALL,
+    ATTR_ACCESS_TOKEN,
+    ATTR_APPARMOR,
+    ATTR_ARCH,
+    ATTR_ARGS,
+    ATTR_AUDIO,
+    ATTR_AUDIO_INPUT,
+    ATTR_AUDIO_OUTPUT,
+    ATTR_AUTH_API,
+    ATTR_AUTO_UART,
+    ATTR_AUTO_UPDATE,
+    ATTR_BOOT,
+    ATTR_BUILD_FROM,
+    ATTR_DESCRIPTON,
+    ATTR_DEVICES,
+    ATTR_DEVICETREE,
+    ATTR_DISCOVERY,
+    ATTR_DOCKER_API,
+    ATTR_ENVIRONMENT,
+    ATTR_FULL_ACCESS,
+    ATTR_GPIO,
+    ATTR_HASSIO_API,
+    ATTR_HASSIO_ROLE,
+    ATTR_HOMEASSISTANT,
+    ATTR_HOMEASSISTANT_API,
+    ATTR_HOST_DBUS,
+    ATTR_HOST_IPC,
+    ATTR_HOST_NETWORK,
+    ATTR_HOST_PID,
+    ATTR_IMAGE,
+    ATTR_INGRESS,
+    ATTR_INGRESS_ENTRY,
+    ATTR_INGRESS_PORT,
+    ATTR_INGRESS_TOKEN,
+    ATTR_KERNEL_MODULES,
+    ATTR_LEGACY,
+    ATTR_LOCATON,
+    ATTR_MACHINE,
+    ATTR_MAINTAINER,
+    ATTR_MAP,
+    ATTR_NAME,
+    ATTR_NETWORK,
+    ATTR_OPTIONS,
+    ATTR_PORTS,
+    ATTR_PORTS_DESCRIPTION,
+    ATTR_PRIVILEGED,
+    ATTR_PROTECTED,
+    ATTR_REPOSITORY,
+    ATTR_SCHEMA,
+    ATTR_SERVICES,
+    ATTR_SLUG,
+    ATTR_SQUASH,
+    ATTR_STARTUP,
+    ATTR_STATE,
+    ATTR_STDIN,
+    ATTR_SYSTEM,
+    ATTR_TIMEOUT,
+    ATTR_TMPFS,
+    ATTR_URL,
+    ATTR_USER,
+    ATTR_UUID,
+    ATTR_VERSION,
+    ATTR_WEBUI,
+    BOOT_AUTO,
+    BOOT_MANUAL,
+    PRIVILEGED_ALL,
+    ROLE_ALL,
+    ROLE_DEFAULT,
+    STARTUP_ALL,
+    STARTUP_APPLICATION,
+    STARTUP_SERVICES,
+    STATE_STARTED,
+    STATE_STOPPED,
+)
+from ..discovery.validate import valid_discovery_service
+from ..validate import (
+    ALSA_DEVICE,
+    DOCKER_PORTS,
+    DOCKER_PORTS_DESCRIPTION,
+    NETWORK_PORT,
+    TOKEN,
+    UUID_MATCH,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+RE_VOLUME = re.compile(r"^(config|ssl|addons|backup|share)(?::(rw|ro))?$")
+RE_SERVICE = re.compile(r"^(?P<service>mqtt):(?P<rights>provide|want|need)$")
 
 V_STR = 'str'
 V_INT = 'int'
@@ -13,8 +103,41 @@ V_FLOAT = 'float'
 V_BOOL = 'bool'
 V_EMAIL = 'email'
 V_URL = 'url'
+V_PORT = 'port'
+V_MATCH = 'match'
+
+RE_SCHEMA_ELEMENT = re.compile(
+    r"^(?:"
+    r"|str|bool|email|url|port"
+    r"|int(?:\((?P<i_min>\d+)?,(?P<i_max>\d+)?\))?"
+    r"|float(?:\((?P<f_min>[\d\.]+)?,(?P<f_max>[\d\.]+)?\))?"
+    r"|match\((?P<match>.*)\)"
+    r")\??$"
+)
+
+RE_DOCKER_IMAGE = re.compile(
+    r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)$")
+RE_DOCKER_IMAGE_BUILD = re.compile(
+    r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)(:[\.\-\w{}]+)?$")
+
+SCHEMA_ELEMENT = vol.Match(RE_SCHEMA_ELEMENT)
+
+
+MACHINE_ALL = [
+    'intel-nuc', 'odroid-c2', 'odroid-xu', 'orangepi-prime', 'qemux86',
+    'qemux86-64', 'qemuarm', 'qemuarm-64', 'raspberrypi', 'raspberrypi2',
+    'raspberrypi3', 'raspberrypi3-64', 'tinker',
+]
+
+
+def _simple_startup(value):
+    """Simple startup schema."""
+    if value == "before":
+        return STARTUP_SERVICES
+    if value == "after":
+        return STARTUP_APPLICATION
+    return value
 
-ADDON_ELEMENT = vol.In([V_STR, V_INT, V_FLOAT, V_BOOL, V_EMAIL, V_URL])
 
 # pylint: disable=no-value-for-parameter
 SCHEMA_ADDON_CONFIG = vol.Schema({
@@ -22,91 +145,239 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     vol.Required(ATTR_VERSION): vol.Coerce(str),
     vol.Required(ATTR_SLUG): vol.Coerce(str),
     vol.Required(ATTR_DESCRIPTON): vol.Coerce(str),
+    vol.Required(ATTR_ARCH): [vol.In(ARCH_ALL)],
+    vol.Optional(ATTR_MACHINE): [vol.In(MACHINE_ALL)],
+    vol.Optional(ATTR_URL): vol.Url(),
     vol.Required(ATTR_STARTUP):
-        vol.In([STARTUP_BEFORE, STARTUP_AFTER, STARTUP_ONCE]),
+        vol.All(_simple_startup, vol.In(STARTUP_ALL)),
     vol.Required(ATTR_BOOT):
         vol.In([BOOT_AUTO, BOOT_MANUAL]),
-    vol.Optional(ATTR_PORTS): dict,
-    vol.Optional(ATTR_MAP_CONFIG, default=False): vol.Boolean(),
-    vol.Optional(ATTR_MAP_SSL, default=False): vol.Boolean(),
+    vol.Optional(ATTR_PORTS): DOCKER_PORTS,
+    vol.Optional(ATTR_PORTS_DESCRIPTION): DOCKER_PORTS_DESCRIPTION,
+    vol.Optional(ATTR_WEBUI):
+        vol.Match(r"^(?:https?|\[PROTO:\w+\]):\/\/\[HOST\]:\[PORT:\d+\].*$"),
+    vol.Optional(ATTR_INGRESS, default=False): vol.Boolean(),
+    vol.Optional(ATTR_INGRESS_PORT, default=8099): vol.Any(NETWORK_PORT, vol.Equal(0)),
+    vol.Optional(ATTR_INGRESS_ENTRY): vol.Coerce(str),
+    vol.Optional(ATTR_HOMEASSISTANT): vol.Maybe(vol.Coerce(str)),
+    vol.Optional(ATTR_HOST_NETWORK, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HOST_PID, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HOST_IPC, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HOST_DBUS, default=False): vol.Boolean(),
+    vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
+    vol.Optional(ATTR_AUTO_UART, default=False): vol.Boolean(),
+    vol.Optional(ATTR_TMPFS):
+        vol.Match(r"^size=(\d)*[kmg](,uid=\d{1,4})?(,rw)?$"),
+    vol.Optional(ATTR_MAP, default=list): [vol.Match(RE_VOLUME)],
+    vol.Optional(ATTR_ENVIRONMENT): {vol.Match(r"\w*"): vol.Coerce(str)},
+    vol.Optional(ATTR_PRIVILEGED): [vol.In(PRIVILEGED_ALL)],
+    vol.Optional(ATTR_APPARMOR, default=True): vol.Boolean(),
+    vol.Optional(ATTR_FULL_ACCESS, default=False): vol.Boolean(),
+    vol.Optional(ATTR_AUDIO, default=False): vol.Boolean(),
+    vol.Optional(ATTR_GPIO, default=False): vol.Boolean(),
+    vol.Optional(ATTR_DEVICETREE, default=False): vol.Boolean(),
+    vol.Optional(ATTR_KERNEL_MODULES, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HASSIO_API, default=False): vol.Boolean(),
+    vol.Optional(ATTR_HASSIO_ROLE, default=ROLE_DEFAULT): vol.In(ROLE_ALL),
+    vol.Optional(ATTR_HOMEASSISTANT_API, default=False): vol.Boolean(),
+    vol.Optional(ATTR_STDIN, default=False): vol.Boolean(),
+    vol.Optional(ATTR_LEGACY, default=False): vol.Boolean(),
+    vol.Optional(ATTR_DOCKER_API, default=False): vol.Boolean(),
+    vol.Optional(ATTR_AUTH_API, default=False): vol.Boolean(),
+    vol.Optional(ATTR_SERVICES): [vol.Match(RE_SERVICE)],
+    vol.Optional(ATTR_DISCOVERY): [valid_discovery_service],
     vol.Required(ATTR_OPTIONS): dict,
-    vol.Required(ATTR_SCHEMA): {
-        vol.Coerce(str): vol.Any(ADDON_ELEMENT, [
-            vol.Any(ADDON_ELEMENT, {vol.Coerce(str): ADDON_ELEMENT})
-        ])
-    },
-    vol.Optional(ATTR_IMAGE): vol.Match(r"\w*/\w*"),
+    vol.Required(ATTR_SCHEMA): vol.Any(vol.Schema({
+        vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [
+            vol.Any(
+                SCHEMA_ELEMENT,
+                {vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [SCHEMA_ELEMENT])}
+            ),
+        ], vol.Schema({
+            vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [SCHEMA_ELEMENT])
+        }))
+    }), False),
+    vol.Optional(ATTR_IMAGE):
+        vol.Match(RE_DOCKER_IMAGE),
+    vol.Optional(ATTR_TIMEOUT, default=10):
+        vol.All(vol.Coerce(int), vol.Range(min=10, max=120)),
+}, extra=vol.REMOVE_EXTRA)
+
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_REPOSITORY_CONFIG = vol.Schema({
+    vol.Required(ATTR_NAME): vol.Coerce(str),
+    vol.Optional(ATTR_URL): vol.Url(),
+    vol.Optional(ATTR_MAINTAINER): vol.Coerce(str),
+}, extra=vol.REMOVE_EXTRA)
+
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_BUILD_CONFIG = vol.Schema({
+    vol.Optional(ATTR_BUILD_FROM, default=dict): vol.Schema({
+        vol.In(ARCH_ALL): vol.Match(RE_DOCKER_IMAGE_BUILD),
+    }),
+    vol.Optional(ATTR_SQUASH, default=False): vol.Boolean(),
+    vol.Optional(ATTR_ARGS, default=dict): vol.Schema({
+        vol.Coerce(str): vol.Coerce(str)
+    }),
+}, extra=vol.REMOVE_EXTRA)
+
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_ADDON_USER = vol.Schema({
+    vol.Required(ATTR_VERSION): vol.Coerce(str),
+    vol.Optional(ATTR_IMAGE): vol.Coerce(str),
+    vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex): UUID_MATCH,
+    vol.Optional(ATTR_ACCESS_TOKEN): TOKEN,
+    vol.Optional(ATTR_INGRESS_TOKEN, default=secrets.token_urlsafe): vol.Coerce(str),
+    vol.Optional(ATTR_OPTIONS, default=dict): 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,
+    vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_DEVICE,
+    vol.Optional(ATTR_AUDIO_INPUT): ALSA_DEVICE,
+    vol.Optional(ATTR_PROTECTED, default=True): vol.Boolean(),
+}, extra=vol.REMOVE_EXTRA)
+
+
+SCHEMA_ADDON_SYSTEM = SCHEMA_ADDON_CONFIG.extend({
+    vol.Required(ATTR_LOCATON): vol.Coerce(str),
+    vol.Required(ATTR_REPOSITORY): vol.Coerce(str),
 })
 
 
+SCHEMA_ADDONS_FILE = vol.Schema({
+    vol.Optional(ATTR_USER, default=dict): {
+        vol.Coerce(str): SCHEMA_ADDON_USER,
+    },
+    vol.Optional(ATTR_SYSTEM, default=dict): {
+        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),
+}, extra=vol.REMOVE_EXTRA)
+
+
 def validate_options(raw_schema):
     """Validate schema."""
     def validate(struct):
-        """Create schema validator for addons options."""
+        """Create schema validator for add-ons options."""
         options = {}
 
         # read options
         for key, value in struct.items():
+            # Ignore unknown options / remove from list
             if key not in raw_schema:
-                raise vol.Invalid("Unknown options {}.".format(key))
+                _LOGGER.warning("Unknown options %s", key)
+                continue
 
             typ = raw_schema[key]
             try:
                 if isinstance(typ, list):
-                    # nested value
-                    options[key] = _nested_validate(typ[0], value)
+                    # nested value list
+                    options[key] = _nested_validate_list(typ[0], value, key)
+                elif isinstance(typ, dict):
+                    # nested value dict
+                    options[key] = _nested_validate_dict(typ, value, key)
                 else:
                     # normal value
-                    options[key] = _single_validate(typ, value)
+                    options[key] = _single_validate(typ, value, key)
             except (IndexError, KeyError):
-                raise vol.Invalid(
-                    "Type error for {}.".format(key)) from None
+                raise vol.Invalid(f"Type error for {key}") from None
 
+        _check_missing_options(raw_schema, options, 'root')
         return options
 
     return validate
 
 
 # pylint: disable=no-value-for-parameter
-def _single_validate(typ, value):
+# pylint: disable=inconsistent-return-statements
+def _single_validate(typ, value, key):
     """Validate a single element."""
-    try:
-        if typ == V_STR:
-            return str(value)
-        elif typ == V_INT:
-            return int(value)
-        elif typ == V_FLOAT:
-            return float(value)
-        elif typ == V_BOOL:
-            return vol.Boolean()(value)
-        elif typ == V_EMAIL:
-            return vol.Email()(value)
-        elif typ == V_URL:
-            return vol.Url()(value)
+    # if required argument
+    if value is None:
+        raise vol.Invalid(f"Missing required option '{key}'")
 
-        raise vol.Invalid("Fatal error for {}.".format(value))
-    except TypeError:
-        raise vol.Invalid(
-            "Type {} error for {}.".format(typ, value)) from None
+    # parse extend data from type
+    match = RE_SCHEMA_ELEMENT.match(typ)
+
+    # prepare range
+    range_args = {}
+    for group_name in ('i_min', 'i_max', 'f_min', 'f_max'):
+        group_value = match.group(group_name)
+        if group_value:
+            range_args[group_name[2:]] = float(group_value)
+
+    if typ.startswith(V_STR):
+        return str(value)
+    elif typ.startswith(V_INT):
+        return vol.All(vol.Coerce(int), vol.Range(**range_args))(value)
+    elif typ.startswith(V_FLOAT):
+        return vol.All(vol.Coerce(float), vol.Range(**range_args))(value)
+    elif typ.startswith(V_BOOL):
+        return vol.Boolean()(value)
+    elif typ.startswith(V_EMAIL):
+        return vol.Email()(value)
+    elif typ.startswith(V_URL):
+        return vol.Url()(value)
+    elif typ.startswith(V_PORT):
+        return NETWORK_PORT(value)
+    elif typ.startswith(V_MATCH):
+        return vol.Match(match.group('match'))(str(value))
+
+    raise vol.Invalid(f"Fatal error for {key} type {typ}")
 
 
-def _nested_validate(typ, data_list):
+def _nested_validate_list(typ, data_list, key):
     """Validate nested items."""
     options = []
 
     for element in data_list:
-        # dict list
+        # Nested?
         if isinstance(typ, dict):
-            c_options = {}
-            for c_key, c_value in element.items():
-                if c_key not in typ:
-                    raise vol.Invalid(
-                        "Unknown nested options {}.".format(c_key))
-
-                c_options[c_key] = _single_validate(typ[c_key], c_value)
+            c_options = _nested_validate_dict(typ, element, key)
             options.append(c_options)
-        # normal list
         else:
-            options.append(_single_validate(typ, element))
+            options.append(_single_validate(typ, element, key))
 
     return options
+
+
+def _nested_validate_dict(typ, data_dict, key):
+    """Validate nested items."""
+    options = {}
+
+    for c_key, c_value in data_dict.items():
+        # Ignore unknown options / remove from list
+        if c_key not in typ:
+            _LOGGER.warning("Unknown options %s", c_key)
+            continue
+
+        # Nested?
+        if isinstance(typ[c_key], list):
+            options[c_key] = _nested_validate_list(typ[c_key][0],
+                                                   c_value, c_key)
+        else:
+            options[c_key] = _single_validate(typ[c_key], c_value, c_key)
+
+    _check_missing_options(typ, options, key)
+    return options
+
+
+def _check_missing_options(origin, exists, root):
+    """Check if all options are exists."""
+    missing = set(origin) - set(exists)
+    for miss_opt in missing:
+        if isinstance(origin[miss_opt], str) and \
+                origin[miss_opt].endswith("?"):
+            continue
+        raise vol.Invalid(f"Missing option {miss_opt} in {root}")

hassio/api/__init__.py

@@ -1,101 +1,296 @@
-"""Init file for HassIO rest api."""
+"""Init file for Hass.io RESTful API."""
 import logging
+from pathlib import Path
+from typing import Optional
 
 from aiohttp import web
 
+from ..coresys import CoreSys, CoreSysAttributes
 from .addons import APIAddons
+from .auth import APIAuth
+from .discovery import APIDiscovery
+from .hardware import APIHardware
+from .hassos import APIHassOS
 from .homeassistant import APIHomeAssistant
 from .host import APIHost
-from .network import APINetwork
+from .info import APIInfo
+from .ingress import APIIngress
+from .proxy import APIProxy
+from .security import SecurityMiddleware
+from .services import APIServices
+from .snapshots import APISnapshots
 from .supervisor import APISupervisor
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class RestAPI(object):
-    """Handle rest api for hassio."""
+class RestAPI(CoreSysAttributes):
+    """Handle RESTful API for Hass.io."""
 
-    def __init__(self, config, loop):
-        """Initialize docker base wrapper."""
-        self.config = config
-        self.loop = loop
-        self.webapp = web.Application(loop=self.loop)
+    def __init__(self, coresys: CoreSys):
+        """Initialize Docker base wrapper."""
+        self.coresys: CoreSys = coresys
+        self.security: SecurityMiddleware = SecurityMiddleware(coresys)
+        self.webapp: web.Application = web.Application(
+            middlewares=[self.security.token_validation])
 
         # service stuff
-        self._handler = None
-        self.server = None
+        self._runner: web.AppRunner = web.AppRunner(self.webapp)
+        self._site: Optional[web.TCPSite] = None
 
-    def register_host(self, host_controll):
-        """Register hostcontroll function."""
-        api_host = APIHost(self.config, self.loop, host_controll)
+    async def load(self) -> None:
+        """Register REST API Calls."""
+        self._register_supervisor()
+        self._register_host()
+        self._register_hassos()
+        self._register_hardware()
+        self._register_homeassistant()
+        self._register_proxy()
+        self._register_panel()
+        self._register_addons()
+        self._register_ingress()
+        self._register_snapshots()
+        self._register_discovery()
+        self._register_services()
+        self._register_info()
+        self._register_auth()
 
-        self.webapp.router.add_get('/host/info', api_host.info)
-        self.webapp.router.add_get('/host/reboot', api_host.reboot)
-        self.webapp.router.add_get('/host/shutdown', api_host.shutdown)
-        self.webapp.router.add_get('/host/update', api_host.update)
+    def _register_host(self) -> None:
+        """Register hostcontrol functions."""
+        api_host = APIHost()
+        api_host.coresys = self.coresys
 
-    def register_network(self, host_controll):
-        """Register network function."""
-        api_net = APINetwork(self.config, self.loop, host_controll)
+        self.webapp.add_routes([
+            web.get('/host/info', api_host.info),
+            web.post('/host/reboot', api_host.reboot),
+            web.post('/host/shutdown', api_host.shutdown),
+            web.post('/host/reload', api_host.reload),
+            web.post('/host/options', api_host.options),
+            web.get('/host/services', api_host.services),
+            web.post('/host/services/{service}/stop', api_host.service_stop),
+            web.post('/host/services/{service}/start', api_host.service_start),
+            web.post('/host/services/{service}/restart',
+                     api_host.service_restart),
+            web.post('/host/services/{service}/reload',
+                     api_host.service_reload),
+        ])
 
-        self.webapp.router.add_get('/network/info', api_net.info)
-        self.webapp.router.add_get('/network/options', api_net.options)
+    def _register_hassos(self) -> None:
+        """Register HassOS functions."""
+        api_hassos = APIHassOS()
+        api_hassos.coresys = self.coresys
 
-    def register_supervisor(self, supervisor, addons):
-        """Register supervisor function."""
-        api_supervisor = APISupervisor(
-            self.config, self.loop, supervisor, addons)
+        self.webapp.add_routes([
+            web.get('/hassos/info', api_hassos.info),
+            web.post('/hassos/update', api_hassos.update),
+            web.post('/hassos/update/cli', api_hassos.update_cli),
+            web.post('/hassos/config/sync', api_hassos.config_sync),
+        ])
 
-        self.webapp.router.add_get('/supervisor/ping', api_supervisor.ping)
-        self.webapp.router.add_get('/supervisor/info', api_supervisor.info)
-        self.webapp.router.add_get('/supervisor/update', api_supervisor.update)
-        self.webapp.router.add_get('/supervisor/reload', api_supervisor.reload)
-        self.webapp.router.add_get(
-            '/supervisor/options', api_supervisor.options)
-        self.webapp.router.add_get('/supervisor/logs', api_supervisor.logs)
+    def _register_hardware(self) -> None:
+        """Register hardware functions."""
+        api_hardware = APIHardware()
+        api_hardware.coresys = self.coresys
 
-    def register_homeassistant(self, dock_homeassistant):
-        """Register homeassistant function."""
-        api_hass = APIHomeAssistant(self.config, self.loop, dock_homeassistant)
+        self.webapp.add_routes([
+            web.get('/hardware/info', api_hardware.info),
+            web.get('/hardware/audio', api_hardware.audio),
+        ])
 
-        self.webapp.router.add_get('/homeassistant/info', api_hass.info)
-        self.webapp.router.add_get('/homeassistant/update', api_hass.update)
-        self.webapp.router.add_get('/homeassistant/logs', api_hass.logs)
+    def _register_info(self) -> None:
+        """Register info functions."""
+        api_info = APIInfo()
+        api_info.coresys = self.coresys
 
-    def register_addons(self, addons):
-        """Register homeassistant function."""
-        api_addons = APIAddons(self.config, self.loop, addons)
+        self.webapp.add_routes([
+            web.get('/info', api_info.info),
+        ])
 
-        self.webapp.router.add_get('/addons/{addon}/info', api_addons.info)
-        self.webapp.router.add_get(
-            '/addons/{addon}/install', api_addons.install)
-        self.webapp.router.add_get(
-            '/addons/{addon}/uninstall', api_addons.uninstall)
-        self.webapp.router.add_get('/addons/{addon}/start', api_addons.start)
-        self.webapp.router.add_get('/addons/{addon}/stop', api_addons.stop)
-        self.webapp.router.add_get('/addons/{addon}/update', api_addons.update)
-        self.webapp.router.add_get(
-            '/addons/{addon}/options', api_addons.options)
-        self.webapp.router.add_get('/addons/{addon}/logs', api_addons.logs)
+    def _register_auth(self) -> None:
+        """Register auth functions."""
+        api_auth = APIAuth()
+        api_auth.coresys = self.coresys
 
-    async def start(self):
-        """Run rest api webserver."""
-        self._handler = self.webapp.make_handler(loop=self.loop)
+        self.webapp.add_routes([
+            web.post('/auth', api_auth.auth),
+        ])
+
+    def _register_supervisor(self) -> None:
+        """Register Supervisor functions."""
+        api_supervisor = APISupervisor()
+        api_supervisor.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/supervisor/ping', api_supervisor.ping),
+            web.get('/supervisor/info', api_supervisor.info),
+            web.get('/supervisor/stats', api_supervisor.stats),
+            web.get('/supervisor/logs', api_supervisor.logs),
+            web.post('/supervisor/update', api_supervisor.update),
+            web.post('/supervisor/reload', api_supervisor.reload),
+            web.post('/supervisor/options', api_supervisor.options),
+        ])
+
+    def _register_homeassistant(self) -> None:
+        """Register Home Assistant functions."""
+        api_hass = APIHomeAssistant()
+        api_hass.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/homeassistant/info', api_hass.info),
+            web.get('/homeassistant/logs', api_hass.logs),
+            web.get('/homeassistant/stats', api_hass.stats),
+            web.post('/homeassistant/options', api_hass.options),
+            web.post('/homeassistant/update', api_hass.update),
+            web.post('/homeassistant/restart', api_hass.restart),
+            web.post('/homeassistant/stop', api_hass.stop),
+            web.post('/homeassistant/start', api_hass.start),
+            web.post('/homeassistant/check', api_hass.check),
+            web.post('/homeassistant/rebuild', api_hass.rebuild),
+        ])
+
+    def _register_proxy(self) -> None:
+        """Register Home Assistant API Proxy."""
+        api_proxy = APIProxy()
+        api_proxy.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/homeassistant/api/websocket', api_proxy.websocket),
+            web.get('/homeassistant/websocket', api_proxy.websocket),
+            web.get('/homeassistant/api/stream', api_proxy.stream),
+            web.post('/homeassistant/api/{path:.+}', api_proxy.api),
+            web.get('/homeassistant/api/{path:.+}', api_proxy.api),
+            web.get('/homeassistant/api/', api_proxy.api),
+        ])
+
+    def _register_addons(self) -> None:
+        """Register Add-on functions."""
+        api_addons = APIAddons()
+        api_addons.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/addons', api_addons.list),
+            web.post('/addons/reload', api_addons.reload),
+            web.get('/addons/{addon}/info', api_addons.info),
+            web.post('/addons/{addon}/install', api_addons.install),
+            web.post('/addons/{addon}/uninstall', api_addons.uninstall),
+            web.post('/addons/{addon}/start', api_addons.start),
+            web.post('/addons/{addon}/stop', api_addons.stop),
+            web.post('/addons/{addon}/restart', api_addons.restart),
+            web.post('/addons/{addon}/update', api_addons.update),
+            web.post('/addons/{addon}/options', api_addons.options),
+            web.post('/addons/{addon}/rebuild', api_addons.rebuild),
+            web.get('/addons/{addon}/logs', api_addons.logs),
+            web.get('/addons/{addon}/icon', api_addons.icon),
+            web.get('/addons/{addon}/logo', api_addons.logo),
+            web.get('/addons/{addon}/changelog', api_addons.changelog),
+            web.post('/addons/{addon}/stdin', api_addons.stdin),
+            web.post('/addons/{addon}/security', api_addons.security),
+            web.get('/addons/{addon}/stats', api_addons.stats),
+        ])
+
+    def _register_ingress(self) -> None:
+        """Register Ingress functions."""
+        api_ingress = APIIngress()
+        api_ingress.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.post('/ingress/session', api_ingress.create_session),
+            web.view('/ingress/{token}/{path:.*}', api_ingress.handler),
+        ])
+
+    def _register_snapshots(self) -> None:
+        """Register snapshots functions."""
+        api_snapshots = APISnapshots()
+        api_snapshots.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/snapshots', api_snapshots.list),
+            web.post('/snapshots/reload', api_snapshots.reload),
+            web.post('/snapshots/new/full', api_snapshots.snapshot_full),
+            web.post('/snapshots/new/partial', api_snapshots.snapshot_partial),
+            web.post('/snapshots/new/upload', api_snapshots.upload),
+            web.get('/snapshots/{snapshot}/info', api_snapshots.info),
+            web.post('/snapshots/{snapshot}/remove', api_snapshots.remove),
+            web.post('/snapshots/{snapshot}/restore/full',
+                     api_snapshots.restore_full),
+            web.post('/snapshots/{snapshot}/restore/partial',
+                     api_snapshots.restore_partial),
+            web.get('/snapshots/{snapshot}/download', api_snapshots.download),
+        ])
+
+    def _register_services(self) -> None:
+        """Register services functions."""
+        api_services = APIServices()
+        api_services.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/services', api_services.list),
+            web.get('/services/{service}', api_services.get_service),
+            web.post('/services/{service}', api_services.set_service),
+            web.delete('/services/{service}', api_services.del_service),
+        ])
+
+    def _register_discovery(self) -> None:
+        """Register discovery functions."""
+        api_discovery = APIDiscovery()
+        api_discovery.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/discovery', api_discovery.list),
+            web.get('/discovery/{uuid}', api_discovery.get_discovery),
+            web.delete('/discovery/{uuid}', api_discovery.del_discovery),
+            web.post('/discovery', api_discovery.set_discovery),
+        ])
+
+    def _register_panel(self) -> None:
+        """Register panel for Home Assistant."""
+        panel_dir = Path(__file__).parent.joinpath("panel")
+
+        def create_response(panel_file):
+            """Create a function to generate a response."""
+            path = panel_dir.joinpath(f"{panel_file!s}.html")
+            return lambda request: web.FileResponse(path)
+
+        # This route is for backwards compatibility with HA < 0.58
+        self.webapp.add_routes(
+            [web.get('/panel', create_response('hassio-main-es5'))])
+
+        # This route is for backwards compatibility with HA 0.58 - 0.61
+        self.webapp.add_routes([
+            web.get('/panel_es5', create_response('hassio-main-es5')),
+            web.get('/panel_latest', create_response('hassio-main-latest')),
+        ])
+
+        # This route is for backwards compatibility with HA 0.62 - 0.70
+        self.webapp.add_routes([
+            web.get('/app-es5/index.html', create_response('index')),
+            web.get('/app-es5/hassio-app.html', create_response('hassio-app')),
+        ])
+
+        # This route is for HA > 0.70
+        self.webapp.add_routes([web.static('/app', panel_dir)])
+
+    async def start(self) -> None:
+        """Run RESTful API webserver."""
+        await self._runner.setup()
+        self._site = web.TCPSite(
+            self._runner, host="0.0.0.0", port=80, shutdown_timeout=5)
 
         try:
-            self.server = await self.loop.create_server(
-                self._handler, "0.0.0.0", "80")
+            await self._site.start()
         except OSError as err:
-            _LOGGER.fatal(
-                "Failed to create HTTP server at 0.0.0.0:80 -> %s", err)
+            _LOGGER.fatal("Failed to create HTTP server at 0.0.0.0:80 -> %s",
+                          err)
+        else:
+            _LOGGER.info("Start API on %s", self.sys_docker.network.supervisor)
 
-    async def stop(self):
-        """Stop rest api webserver."""
-        if self.server:
-            self.server.close()
-            await self.server.wait_closed()
-        await self.webapp.shutdown()
+    async def stop(self) -> None:
+        """Stop RESTful API webserver."""
+        if not self._site:
+            return
 
-        if self._handler:
-            await self._handler.finish_connections(60)
-        await self.webapp.cleanup()
+        # Shutdown running API
+        await self._site.stop()
+        await self._runner.cleanup()
+
+        _LOGGER.info("Stop API on %s", self.sys_docker.network.supervisor)

hassio/api/addons.py

@@ -1,14 +1,91 @@
-"""Init file for HassIO homeassistant rest api."""
+"""Init file for Hass.io Home Assistant RESTful API."""
 import asyncio
 import logging
+from typing import Any, Awaitable, Dict, List
 
+from aiohttp import web
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
-from .util import api_process, api_process_raw, api_validate
+from ..addons.addon import Addon
+from ..addons.utils import rating_security
 from ..const import (
-    ATTR_VERSION, ATTR_CURRENT, ATTR_STATE, ATTR_BOOT, ATTR_OPTIONS,
-    STATE_STOPPED, STATE_STARTED, BOOT_AUTO, BOOT_MANUAL)
+    ATTR_ADDONS,
+    ATTR_APPARMOR,
+    ATTR_ARCH,
+    ATTR_AUDIO,
+    ATTR_AUDIO_INPUT,
+    ATTR_AUDIO_OUTPUT,
+    ATTR_AUTH_API,
+    ATTR_AUTO_UPDATE,
+    ATTR_AVAILABLE,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_BOOT,
+    ATTR_BUILD,
+    ATTR_CHANGELOG,
+    ATTR_CPU_PERCENT,
+    ATTR_DESCRIPTON,
+    ATTR_DETACHED,
+    ATTR_DEVICES,
+    ATTR_DEVICETREE,
+    ATTR_DISCOVERY,
+    ATTR_DOCKER_API,
+    ATTR_FULL_ACCESS,
+    ATTR_GPIO,
+    ATTR_HASSIO_API,
+    ATTR_HASSIO_ROLE,
+    ATTR_HOMEASSISTANT,
+    ATTR_HOMEASSISTANT_API,
+    ATTR_HOST_DBUS,
+    ATTR_HOST_IPC,
+    ATTR_HOST_NETWORK,
+    ATTR_HOST_PID,
+    ATTR_ICON,
+    ATTR_INGRESS,
+    ATTR_INGRESS_ENTRY,
+    ATTR_INGRESS_PORT,
+    ATTR_INGRESS_URL,
+    ATTR_INSTALLED,
+    ATTR_IP_ADDRESS,
+    ATTR_KERNEL_MODULES,
+    ATTR_LAST_VERSION,
+    ATTR_LOGO,
+    ATTR_LONG_DESCRIPTION,
+    ATTR_MACHINE,
+    ATTR_MAINTAINER,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_USAGE,
+    ATTR_NAME,
+    ATTR_NETWORK,
+    ATTR_NETWORK_DESCRIPTION,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+    ATTR_OPTIONS,
+    ATTR_PRIVILEGED,
+    ATTR_PROTECTED,
+    ATTR_RATING,
+    ATTR_REPOSITORIES,
+    ATTR_REPOSITORY,
+    ATTR_SERVICES,
+    ATTR_SLUG,
+    ATTR_SOURCE,
+    ATTR_STATE,
+    ATTR_STDIN,
+    ATTR_URL,
+    ATTR_VERSION,
+    ATTR_WEBUI,
+    BOOT_AUTO,
+    BOOT_MANUAL,
+    CONTENT_TYPE_BINARY,
+    CONTENT_TYPE_PNG,
+    CONTENT_TYPE_TEXT,
+    REQUEST_FROM,
+)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
+from ..validate import ALSA_DEVICE, DOCKER_PORTS
+from .utils import api_process, api_process_raw, api_validate
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -16,130 +93,310 @@ 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(),
+    vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_DEVICE,
+    vol.Optional(ATTR_AUDIO_INPUT): ALSA_DEVICE,
+})
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_SECURITY = vol.Schema({
+    vol.Optional(ATTR_PROTECTED): vol.Boolean(),
 })
 
 
-class APIAddons(object):
-    """Handle rest api for addons functions."""
+class APIAddons(CoreSysAttributes):
+    """Handle RESTful API for add-on functions."""
 
-    def __init__(self, config, loop, addons):
-        """Initialize homeassistant rest api part."""
-        self.config = config
-        self.loop = loop
-        self.addons = addons
+    def _extract_addon(self, request: web.Request, check_installed: bool = True) -> Addon:
+        """Return addon, throw an exception it it doesn't exist."""
+        addon_slug = request.match_info.get('addon')
 
-    def _extract_addon(self, request, check_installed=True):
-        """Return addon and if not exists trow a exception."""
-        addon = request.match_info.get('addon')
+        # Lookup itself
+        if addon_slug == 'self':
+            return request.get(REQUEST_FROM)
 
-        # check data
-        if not self.addons.exists_addon(addon):
-            raise RuntimeError("Addon not exists")
-        if check_installed and not self.addons.is_installed(addon):
-            raise RuntimeError("Addon is not installed")
+        addon = self.sys_addons.get(addon_slug)
+        if not addon:
+            raise APIError("Addon does not exist")
+
+        if check_installed and not addon.is_installed:
+            raise APIError("Addon is not installed")
 
         return addon
 
     @api_process
-    async def info(self, request):
-        """Return addon information."""
-        addon = self._extract_addon(request)
+    async def list(self, request: web.Request) -> Dict[str, Any]:
+        """Return all add-ons or repositories."""
+        data_addons = []
+        for addon in self.sys_addons.list_addons:
+            data_addons.append({
+                ATTR_NAME: addon.name,
+                ATTR_SLUG: addon.slug,
+                ATTR_DESCRIPTON: addon.description,
+                ATTR_VERSION: addon.latest_version,
+                ATTR_INSTALLED: addon.version_installed,
+                ATTR_AVAILABLE: addon.available,
+                ATTR_DETACHED: addon.is_detached,
+                ATTR_REPOSITORY: addon.repository,
+                ATTR_BUILD: addon.need_build,
+                ATTR_URL: addon.url,
+                ATTR_ICON: addon.with_icon,
+                ATTR_LOGO: addon.with_logo,
+            })
 
-        info = {
-            ATTR_VERSION: self.addons.version_installed(addon),
-            ATTR_CURRENT: self.addons.get_version(addon),
-            ATTR_STATE: await self.addons.state(addon),
-            ATTR_BOOT: self.addons.get_boot(addon),
-            ATTR_OPTIONS: self.addons.get_options(addon),
+        data_repositories = []
+        for repository in self.sys_addons.list_repositories:
+            data_repositories.append({
+                ATTR_SLUG: repository.slug,
+                ATTR_NAME: repository.name,
+                ATTR_SOURCE: repository.source,
+                ATTR_URL: repository.url,
+                ATTR_MAINTAINER: repository.maintainer,
+            })
+
+        return {
+            ATTR_ADDONS: data_addons,
+            ATTR_REPOSITORIES: data_repositories,
         }
-        return info
 
     @api_process
-    async def options(self, request):
-        """Store user options for addon."""
+    async def reload(self, request: web.Request) -> None:
+        """Reload all add-on data."""
+        await asyncio.shield(self.sys_addons.reload())
+
+    @api_process
+    async def info(self, request: web.Request) -> Dict[str, Any]:
+        """Return add-on information."""
+        addon = self._extract_addon(request, check_installed=False)
+
+        return {
+            ATTR_NAME: addon.name,
+            ATTR_SLUG: addon.slug,
+            ATTR_DESCRIPTON: addon.description,
+            ATTR_LONG_DESCRIPTION: addon.long_description,
+            ATTR_VERSION: addon.version_installed,
+            ATTR_AUTO_UPDATE: addon.auto_update,
+            ATTR_REPOSITORY: addon.repository,
+            ATTR_LAST_VERSION: addon.latest_version,
+            ATTR_STATE: await addon.state(),
+            ATTR_PROTECTED: addon.protected,
+            ATTR_RATING: rating_security(addon),
+            ATTR_BOOT: addon.boot,
+            ATTR_OPTIONS: addon.options,
+            ATTR_ARCH: addon.supported_arch,
+            ATTR_MACHINE: addon.supported_machine,
+            ATTR_HOMEASSISTANT: addon.homeassistant_version,
+            ATTR_URL: addon.url,
+            ATTR_DETACHED: addon.is_detached,
+            ATTR_AVAILABLE: addon.available,
+            ATTR_BUILD: addon.need_build,
+            ATTR_NETWORK: addon.ports,
+            ATTR_NETWORK_DESCRIPTION: addon.ports_description,
+            ATTR_HOST_NETWORK: addon.host_network,
+            ATTR_HOST_PID: addon.host_pid,
+            ATTR_HOST_IPC: addon.host_ipc,
+            ATTR_HOST_DBUS: addon.host_dbus,
+            ATTR_PRIVILEGED: addon.privileged,
+            ATTR_FULL_ACCESS: addon.with_full_access,
+            ATTR_APPARMOR: addon.apparmor,
+            ATTR_DEVICES: _pretty_devices(addon),
+            ATTR_ICON: addon.with_icon,
+            ATTR_LOGO: addon.with_logo,
+            ATTR_CHANGELOG: addon.with_changelog,
+            ATTR_WEBUI: addon.webui,
+            ATTR_STDIN: addon.with_stdin,
+            ATTR_HASSIO_API: addon.access_hassio_api,
+            ATTR_HASSIO_ROLE: addon.hassio_role,
+            ATTR_AUTH_API: addon.access_auth_api,
+            ATTR_HOMEASSISTANT_API: addon.access_homeassistant_api,
+            ATTR_GPIO: addon.with_gpio,
+            ATTR_KERNEL_MODULES: addon.with_kernel_modules,
+            ATTR_DEVICETREE: addon.with_devicetree,
+            ATTR_DOCKER_API: addon.access_docker_api,
+            ATTR_AUDIO: addon.with_audio,
+            ATTR_AUDIO_INPUT: addon.audio_input,
+            ATTR_AUDIO_OUTPUT: addon.audio_output,
+            ATTR_SERVICES: _pretty_services(addon),
+            ATTR_DISCOVERY: addon.discovery,
+            ATTR_IP_ADDRESS: str(addon.ip_address),
+            ATTR_INGRESS: addon.with_ingress,
+            ATTR_INGRESS_ENTRY: addon.ingress_entry,
+            ATTR_INGRESS_URL: addon.ingress_url,
+            ATTR_INGRESS_PORT: addon.ingress_port,
+        }
+
+    @api_process
+    async def options(self, request: web.Request) -> None:
+        """Store user options for add-on."""
         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): vol.Any(None, addon.schema),
         })
+        body = await api_validate(addon_schema, request)
 
-        addon_config = await api_validate(addon_schema, request)
+        if ATTR_OPTIONS in body:
+            addon.options = body[ATTR_OPTIONS]
+        if ATTR_BOOT in body:
+            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]
+        if ATTR_AUDIO_INPUT in body:
+            addon.audio_input = body[ATTR_AUDIO_INPUT]
+        if ATTR_AUDIO_OUTPUT in body:
+            addon.audio_output = body[ATTR_AUDIO_OUTPUT]
 
-        if ATTR_OPTIONS in addon_config:
-            self.addons.set_options(addon, addon_config[ATTR_OPTIONS])
-        if ATTR_BOOT in addon_config:
-            self.addons.set_options(addon, addon_config[ATTR_BOOT])
-
-        return True
+        addon.save_data()
 
     @api_process
-    async def install(self, request):
-        """Install addon."""
-        body = await api_validate(SCHEMA_VERSION, request)
+    async def security(self, request: web.Request) -> None:
+        """Store security options for add-on."""
+        addon = self._extract_addon(request)
+        body = await api_validate(SCHEMA_SECURITY, request)
+
+        if ATTR_PROTECTED in body:
+            _LOGGER.warning("Protected flag changing for %s!", addon.slug)
+            addon.protected = body[ATTR_PROTECTED]
+
+        addon.save_data()
+
+    @api_process
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
+        """Return resource information."""
+        addon = self._extract_addon(request)
+        stats = await addon.stats()
+
+        return {
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
+        }
+
+    @api_process
+    def install(self, request: web.Request) -> Awaitable[None]:
+        """Install add-on."""
         addon = self._extract_addon(request, check_installed=False)
-        version = body.get(
-            ATTR_VERSION, self.addons.get_version(addon))
-
-        return await asyncio.shield(
-            self.addons.install(addon, version), loop=self.loop)
+        return asyncio.shield(addon.install())
 
     @api_process
-    async def uninstall(self, request):
-        """Uninstall addon."""
+    def uninstall(self, request: web.Request) -> Awaitable[None]:
+        """Uninstall add-on."""
         addon = self._extract_addon(request)
-
-        return await asyncio.shield(
-            self.addons.uninstall(addon), loop=self.loop)
+        return asyncio.shield(addon.uninstall())
 
     @api_process
-    async def start(self, request):
-        """Start addon."""
+    def start(self, request: web.Request) -> Awaitable[None]:
+        """Start add-on."""
         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
+            raise APIError(humanize_error(options, ex)) from None
 
-        return await asyncio.shield(
-            self.addons.start(addon), loop=self.loop)
+        return asyncio.shield(addon.start())
 
     @api_process
-    async def stop(self, request):
-        """Stop addon."""
+    def stop(self, request: web.Request) -> Awaitable[None]:
+        """Stop add-on."""
         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 asyncio.shield(addon.stop())
 
     @api_process
-    async def update(self, request):
-        """Update addon."""
-        body = await api_validate(SCHEMA_VERSION, request)
+    def update(self, request: web.Request) -> Awaitable[None]:
+        """Update add-on."""
         addon = self._extract_addon(request)
-        version = body.get(
-            ATTR_VERSION, self.addons.get_version(addon))
 
-        if version == self.addons.version_installed(addon):
-            raise RuntimeError("Version is already in use")
+        if addon.latest_version == addon.version_installed:
+            raise APIError("No update available!")
 
-        return await asyncio.shield(
-            self.addons.update(addon, version), loop=self.loop)
+        return asyncio.shield(addon.update())
 
-    @api_process_raw
-    def logs(self, request):
-        """Return logs from addon."""
+    @api_process
+    def restart(self, request: web.Request) -> Awaitable[None]:
+        """Restart add-on."""
         addon = self._extract_addon(request)
-        return self.addons.logs(addon)
+        return asyncio.shield(addon.restart())
+
+    @api_process
+    def rebuild(self, request: web.Request) -> Awaitable[None]:
+        """Rebuild local build add-on."""
+        addon = self._extract_addon(request)
+        if not addon.need_build:
+            raise APIError("Only local build addons are supported")
+
+        return asyncio.shield(addon.rebuild())
+
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return logs from add-on."""
+        addon = self._extract_addon(request)
+        return addon.logs()
+
+    @api_process_raw(CONTENT_TYPE_PNG)
+    async def icon(self, request: web.Request) -> bytes:
+        """Return icon from add-on."""
+        addon = self._extract_addon(request, check_installed=False)
+        if not addon.with_icon:
+            raise APIError("No icon found!")
+
+        with addon.path_icon.open('rb') as png:
+            return png.read()
+
+    @api_process_raw(CONTENT_TYPE_PNG)
+    async def logo(self, request: web.Request) -> bytes:
+        """Return logo from add-on."""
+        addon = self._extract_addon(request, check_installed=False)
+        if not addon.with_logo:
+            raise APIError("No logo found!")
+
+        with addon.path_logo.open('rb') as png:
+            return png.read()
+
+    @api_process_raw(CONTENT_TYPE_TEXT)
+    async def changelog(self, request: web.Request) -> str:
+        """Return changelog from add-on."""
+        addon = self._extract_addon(request, check_installed=False)
+        if not addon.with_changelog:
+            raise APIError("No changelog found!")
+
+        with addon.path_changelog.open('r') as changelog:
+            return changelog.read()
+
+    @api_process
+    async def stdin(self, request: web.Request) -> None:
+        """Write to stdin of add-on."""
+        addon = self._extract_addon(request)
+        if not addon.with_stdin:
+            raise APIError("STDIN not supported by add-on")
+
+        data = await request.read()
+        await asyncio.shield(addon.write_stdin(data))
+
+
+def _pretty_devices(addon: Addon) -> List[str]:
+    """Return a simplified device list."""
+    dev_list = addon.devices
+    if not dev_list:
+        return None
+    return [row.split(':')[0] for row in dev_list]
+
+
+def _pretty_services(addon: Addon) -> List[str]:
+    """Return a simplified services role list."""
+    services = []
+    for name, access in addon.services_role.items():
+        services.append(f"{name}:{access}")
+    return services

hassio/api/auth.py

@@ -0,0 +1,61 @@
+"""Init file for Hass.io auth/SSO RESTful API."""
+import logging
+
+from aiohttp import BasicAuth
+from aiohttp.web_exceptions import HTTPUnauthorized
+from aiohttp.hdrs import CONTENT_TYPE, AUTHORIZATION, WWW_AUTHENTICATE
+
+from .utils import api_process
+from ..const import REQUEST_FROM, CONTENT_TYPE_JSON, CONTENT_TYPE_URL
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIForbidden
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIAuth(CoreSysAttributes):
+    """Handle RESTful API for auth functions."""
+
+    def _process_basic(self, request, addon):
+        """Process login request with basic auth.
+
+        Return a coroutine.
+        """
+        auth = BasicAuth.decode(request.headers[AUTHORIZATION])
+        return self.sys_auth.check_login(addon, auth.login, auth.password)
+
+    def _process_dict(self, request, addon, data):
+        """Process login with dict data.
+
+        Return a coroutine.
+        """
+        username = data.get('username') or data.get('user')
+        password = data.get('password')
+
+        return self.sys_auth.check_login(addon, username, password)
+
+    @api_process
+    async def auth(self, request):
+        """Process login request."""
+        addon = request[REQUEST_FROM]
+
+        if not addon.access_auth_api:
+            raise APIForbidden("Can't use Home Assistant auth!")
+
+        # BasicAuth
+        if AUTHORIZATION in request.headers:
+            return await self._process_basic(request, addon)
+
+        # Json
+        if request.headers.get(CONTENT_TYPE) == CONTENT_TYPE_JSON:
+            data = await request.json()
+            return await self._process_dict(request, addon, data)
+
+        # URL encoded
+        if request.headers.get(CONTENT_TYPE) == CONTENT_TYPE_URL:
+            data = await request.post()
+            return await self._process_dict(request, addon, data)
+
+        raise HTTPUnauthorized(headers={
+            WWW_AUTHENTICATE: "Basic realm=\"Hass.io Authentication\""
+        })

hassio/api/discovery.py

@@ -0,0 +1,100 @@
+"""Init file for Hass.io network RESTful API."""
+import voluptuous as vol
+
+from .utils import api_process, api_validate
+from ..const import (
+    ATTR_ADDON,
+    ATTR_UUID,
+    ATTR_CONFIG,
+    ATTR_DISCOVERY,
+    ATTR_SERVICE,
+    REQUEST_FROM,
+)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError, APIForbidden
+from ..discovery.validate import valid_discovery_service
+
+
+SCHEMA_DISCOVERY = vol.Schema(
+    {
+        vol.Required(ATTR_SERVICE): valid_discovery_service,
+        vol.Optional(ATTR_CONFIG): vol.Maybe(dict),
+    }
+)
+
+
+class APIDiscovery(CoreSysAttributes):
+    """Handle RESTful API for discovery functions."""
+
+    def _extract_message(self, request):
+        """Extract discovery message from URL."""
+        message = self.sys_discovery.get(request.match_info.get("uuid"))
+        if not message:
+            raise APIError("Discovery message not found")
+        return message
+
+    def _check_permission_ha(self, request):
+        """Check permission for API call / Home Assistant."""
+        if request[REQUEST_FROM] != self.sys_homeassistant:
+            raise APIForbidden("Only HomeAssistant can use this API!")
+
+    @api_process
+    async def list(self, request):
+        """Show register services."""
+        self._check_permission_ha(request)
+
+        discovery = []
+        for message in self.sys_discovery.list_messages:
+            discovery.append(
+                {
+                    ATTR_ADDON: message.addon,
+                    ATTR_SERVICE: message.service,
+                    ATTR_UUID: message.uuid,
+                    ATTR_CONFIG: message.config,
+                }
+            )
+
+        return {ATTR_DISCOVERY: discovery}
+
+    @api_process
+    async def set_discovery(self, request):
+        """Write data into a discovery pipeline."""
+        body = await api_validate(SCHEMA_DISCOVERY, request)
+        addon = request[REQUEST_FROM]
+
+        # Access?
+        if body[ATTR_SERVICE] not in addon.discovery:
+            raise APIForbidden(f"Can't use discovery!")
+
+        # Process discovery message
+        message = self.sys_discovery.send(addon, **body)
+
+        return {ATTR_UUID: message.uuid}
+
+    @api_process
+    async def get_discovery(self, request):
+        """Read data into a discovery message."""
+        message = self._extract_message(request)
+
+        # HomeAssistant?
+        self._check_permission_ha(request)
+
+        return {
+            ATTR_ADDON: message.addon,
+            ATTR_SERVICE: message.service,
+            ATTR_UUID: message.uuid,
+            ATTR_CONFIG: message.config,
+        }
+
+    @api_process
+    async def del_discovery(self, request):
+        """Delete data into a discovery message."""
+        message = self._extract_message(request)
+        addon = request[REQUEST_FROM]
+
+        # Permission
+        if message.addon != addon.slug:
+            raise APIForbidden(f"Can't remove discovery message")
+
+        self.sys_discovery.remove(message)
+        return True

hassio/api/hardware.py

@@ -0,0 +1,34 @@
+"""Init file for Hass.io hardware RESTful API."""
+import logging
+
+from .utils import api_process
+from ..const import (
+    ATTR_SERIAL, ATTR_DISK, ATTR_GPIO, ATTR_AUDIO, ATTR_INPUT, ATTR_OUTPUT)
+from ..coresys import CoreSysAttributes
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIHardware(CoreSysAttributes):
+    """Handle RESTful API for hardware functions."""
+
+    @api_process
+    async def info(self, request):
+        """Show hardware info."""
+        return {
+            ATTR_SERIAL: list(self.sys_hardware.serial_devices),
+            ATTR_INPUT: list(self.sys_hardware.input_devices),
+            ATTR_DISK: list(self.sys_hardware.disk_devices),
+            ATTR_GPIO: list(self.sys_hardware.gpio_devices),
+            ATTR_AUDIO: self.sys_hardware.audio_devices,
+        }
+
+    @api_process
+    async def audio(self, request):
+        """Show ALSA audio devices."""
+        return {
+            ATTR_AUDIO: {
+                ATTR_INPUT: self.sys_host.alsa.input_devices,
+                ATTR_OUTPUT: self.sys_host.alsa.output_devices,
+            }
+        }

hassio/api/hassos.py

@@ -0,0 +1,57 @@
+"""Init file for Hass.io HassOS RESTful API."""
+import asyncio
+import logging
+from typing import Any, Awaitable, Dict
+
+import voluptuous as vol
+from aiohttp import web
+
+from ..const import (
+    ATTR_BOARD,
+    ATTR_VERSION,
+    ATTR_VERSION_CLI,
+    ATTR_VERSION_CLI_LATEST,
+    ATTR_VERSION_LATEST,
+)
+from ..coresys import CoreSysAttributes
+from .utils import api_process, api_validate
+
+_LOGGER = logging.getLogger(__name__)
+
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
+
+
+class APIHassOS(CoreSysAttributes):
+    """Handle RESTful API for HassOS functions."""
+
+    @api_process
+    async def info(self, request: web.Request) -> Dict[str, Any]:
+        """Return HassOS information."""
+        return {
+            ATTR_VERSION: self.sys_hassos.version,
+            ATTR_VERSION_CLI: self.sys_hassos.version_cli,
+            ATTR_VERSION_LATEST: self.sys_hassos.version_latest,
+            ATTR_VERSION_CLI_LATEST: self.sys_hassos.version_cli_latest,
+            ATTR_BOARD: self.sys_hassos.board,
+        }
+
+    @api_process
+    async def update(self, request: web.Request) -> None:
+        """Update HassOS."""
+        body = await api_validate(SCHEMA_VERSION, request)
+        version = body.get(ATTR_VERSION, self.sys_hassos.version_latest)
+
+        await asyncio.shield(self.sys_hassos.update(version))
+
+    @api_process
+    async def update_cli(self, request: web.Request) -> None:
+        """Update HassOS CLI."""
+        body = await api_validate(SCHEMA_VERSION, request)
+        version = body.get(ATTR_VERSION, self.sys_hassos.version_cli_latest)
+
+        await asyncio.shield(self.sys_hassos.update_cli(version))
+
+    @api_process
+    def config_sync(self, request: web.Request) -> Awaitable[None]:
+        """Trigger config reload on HassOS."""
+        return asyncio.shield(self.sys_hassos.config_sync())

hassio/api/homeassistant.py

@@ -1,57 +1,167 @@
-"""Init file for HassIO homeassistant rest api."""
+"""Init file for Hass.io Home Assistant RESTful API."""
 import asyncio
 import logging
+from typing import Coroutine, Dict, Any
 
 import voluptuous as vol
+from aiohttp import web
 
-from .util import api_process, api_process_raw, api_validate
-from ..const import ATTR_VERSION, ATTR_CURRENT
+from ..const import (
+    ATTR_ARCH,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_BOOT,
+    ATTR_CPU_PERCENT,
+    ATTR_CUSTOM,
+    ATTR_IMAGE,
+    ATTR_LAST_VERSION,
+    ATTR_MACHINE,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_USAGE,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+    ATTR_PASSWORD,
+    ATTR_PORT,
+    ATTR_REFRESH_TOKEN,
+    ATTR_SSL,
+    ATTR_VERSION,
+    ATTR_WAIT_BOOT,
+    ATTR_WATCHDOG,
+    ATTR_IP_ADDRESS,
+    CONTENT_TYPE_BINARY,
+)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
+from ..validate import DOCKER_IMAGE, NETWORK_PORT
+from .utils import api_process, api_process_raw, api_validate
 
 _LOGGER = logging.getLogger(__name__)
 
-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.Boolean(),
+        vol.Inclusive(ATTR_IMAGE, "custom_hass"): vol.Maybe(vol.Coerce(str)),
+        vol.Inclusive(ATTR_LAST_VERSION, "custom_hass"): vol.Any(None, DOCKER_IMAGE),
+        vol.Optional(ATTR_PORT): NETWORK_PORT,
+        vol.Optional(ATTR_PASSWORD): vol.Maybe(vol.Coerce(str)),
+        vol.Optional(ATTR_SSL): vol.Boolean(),
+        vol.Optional(ATTR_WATCHDOG): vol.Boolean(),
+        vol.Optional(ATTR_WAIT_BOOT): vol.All(vol.Coerce(int), vol.Range(min=60)),
+        vol.Optional(ATTR_REFRESH_TOKEN): vol.Maybe(vol.Coerce(str)),
+    }
+)
+
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 
 
-class APIHomeAssistant(object):
-    """Handle rest api for homeassistant functions."""
-
-    def __init__(self, config, loop, homeassistant):
-        """Initialize homeassistant rest api part."""
-        self.config = config
-        self.loop = loop
-        self.homeassistant = homeassistant
+class APIHomeAssistant(CoreSysAttributes):
+    """Handle RESTful API for Home Assistant functions."""
 
     @api_process
-    async def info(self, request):
+    async def info(self, request: web.Request) -> Dict[str, Any]:
         """Return host information."""
-        info = {
-            ATTR_VERSION: self.homeassistant.version,
-            ATTR_CURRENT: self.config.current_homeassistant,
+        return {
+            ATTR_VERSION: self.sys_homeassistant.version,
+            ATTR_LAST_VERSION: self.sys_homeassistant.latest_version,
+            ATTR_MACHINE: self.sys_homeassistant.machine,
+            ATTR_IP_ADDRESS: str(self.sys_homeassistant.ip_address),
+            ATTR_ARCH: self.sys_homeassistant.arch,
+            ATTR_IMAGE: self.sys_homeassistant.image,
+            ATTR_CUSTOM: self.sys_homeassistant.is_custom_image,
+            ATTR_BOOT: self.sys_homeassistant.boot,
+            ATTR_PORT: self.sys_homeassistant.api_port,
+            ATTR_SSL: self.sys_homeassistant.api_ssl,
+            ATTR_WATCHDOG: self.sys_homeassistant.watchdog,
+            ATTR_WAIT_BOOT: self.sys_homeassistant.wait_boot,
         }
 
-        return info
+    @api_process
+    async def options(self, request: web.Request) -> None:
+        """Set Home Assistant options."""
+        body = await api_validate(SCHEMA_OPTIONS, request)
+
+        if ATTR_IMAGE in body and ATTR_LAST_VERSION in body:
+            self.sys_homeassistant.image = body[ATTR_IMAGE]
+            self.sys_homeassistant.latest_version = body[ATTR_LAST_VERSION]
+
+        if ATTR_BOOT in body:
+            self.sys_homeassistant.boot = body[ATTR_BOOT]
+
+        if ATTR_PORT in body:
+            self.sys_homeassistant.api_port = body[ATTR_PORT]
+
+        if ATTR_PASSWORD in body:
+            self.sys_homeassistant.api_password = body[ATTR_PASSWORD]
+            self.sys_homeassistant.refresh_token = None
+
+        if ATTR_SSL in body:
+            self.sys_homeassistant.api_ssl = body[ATTR_SSL]
+
+        if ATTR_WATCHDOG in body:
+            self.sys_homeassistant.watchdog = body[ATTR_WATCHDOG]
+
+        if ATTR_WAIT_BOOT in body:
+            self.sys_homeassistant.wait_boot = body[ATTR_WAIT_BOOT]
+
+        if ATTR_REFRESH_TOKEN in body:
+            self.sys_homeassistant.refresh_token = body[ATTR_REFRESH_TOKEN]
+
+        self.sys_homeassistant.save_data()
 
     @api_process
-    async def update(self, request):
-        """Update host OS."""
+    async def stats(self, request: web.Request) -> Dict[Any, str]:
+        """Return resource information."""
+        stats = await self.sys_homeassistant.stats()
+        if not stats:
+            raise APIError("No stats available")
+
+        return {
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
+        }
+
+    @api_process
+    async def update(self, request: web.Request) -> None:
+        """Update Home Assistant."""
         body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self.config.current_homeassistant)
+        version = body.get(ATTR_VERSION, self.sys_homeassistant.latest_version)
 
-        if self.homeassistant.in_progress:
-            raise RuntimeError("Other task is in progress")
+        await asyncio.shield(self.sys_homeassistant.update(version))
 
-        if version == self.homeassistant.version:
-            raise RuntimeError("Version is already in use")
+    @api_process
+    def stop(self, request: web.Request) -> Coroutine:
+        """Stop Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.stop())
 
-        return await asyncio.shield(
-            self.homeassistant.update(version), loop=self.loop)
+    @api_process
+    def start(self, request: web.Request) -> Coroutine:
+        """Start Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.start())
 
-    @api_process_raw
-    def logs(self, request):
-        """Return homeassistant docker logs.
+    @api_process
+    def restart(self, request: web.Request) -> Coroutine:
+        """Restart Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.restart())
 
-        Return a coroutine.
-        """
-        return self.homeassistant.logs()
+    @api_process
+    def rebuild(self, request: web.Request) -> Coroutine:
+        """Rebuild Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.rebuild())
+
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Coroutine:
+        """Return Home Assistant Docker logs."""
+        return self.sys_homeassistant.logs()
+
+    @api_process
+    async def check(self, request: web.Request) -> None:
+        """Check configuration of Home Assistant."""
+        result = await self.sys_homeassistant.check_config()
+        if not result.valid:
+            raise APIError(result.log)

hassio/api/host.py

@@ -1,61 +1,101 @@
-"""Init file for HassIO host rest api."""
+"""Init file for Hass.io host RESTful API."""
+import asyncio
 import logging
 
 import voluptuous as vol
 
-from .util import api_process_hostcontroll, api_process, api_validate
-from ..const import ATTR_VERSION
+from .utils import api_process, api_validate
+from ..const import (
+    ATTR_HOSTNAME, ATTR_FEATURES, ATTR_KERNEL, ATTR_OPERATING_SYSTEM,
+    ATTR_CHASSIS, ATTR_DEPLOYMENT, ATTR_STATE, ATTR_NAME, ATTR_DESCRIPTON,
+    ATTR_SERVICES, ATTR_CPE)
+from ..coresys import CoreSysAttributes
 
 _LOGGER = logging.getLogger(__name__)
 
-UNKNOWN = 'unknown'
+SERVICE = 'service'
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
+SCHEMA_OPTIONS = vol.Schema({
+    vol.Optional(ATTR_HOSTNAME): vol.Coerce(str),
 })
 
 
-class APIHost(object):
-    """Handle rest api for host functions."""
-
-    def __init__(self, config, loop, host_controll):
-        """Initialize host rest api part."""
-        self.config = config
-        self.loop = loop
-        self.host_controll = host_controll
+class APIHost(CoreSysAttributes):
+    """Handle RESTful API for host functions."""
 
     @api_process
     async def info(self, request):
         """Return host information."""
-        if not self.host_controll.active:
-            info = {
-                'os': UNKNOWN,
-                'version': UNKNOWN,
-                'current': UNKNOWN,
-                'level': 0,
-                'hostname': UNKNOWN,
-            }
-            return info
+        return {
+            ATTR_CHASSIS: self.sys_host.info.chassis,
+            ATTR_CPE: self.sys_host.info.cpe,
+            ATTR_FEATURES: self.sys_host.supperted_features,
+            ATTR_HOSTNAME: self.sys_host.info.hostname,
+            ATTR_OPERATING_SYSTEM: self.sys_host.info.operating_system,
+            ATTR_DEPLOYMENT: self.sys_host.info.deployment,
+            ATTR_KERNEL: self.sys_host.info.kernel,
+        }
 
-        return await self.host_controll.info()
+    @api_process
+    async def options(self, request):
+        """Edit host settings."""
+        body = await api_validate(SCHEMA_OPTIONS, request)
 
-    @api_process_hostcontroll
+        # hostname
+        if ATTR_HOSTNAME in body:
+            await asyncio.shield(
+                self.sys_host.control.set_hostname(body[ATTR_HOSTNAME]))
+
+    @api_process
     def reboot(self, request):
         """Reboot host."""
-        return self.host_controll.reboot()
+        return asyncio.shield(self.sys_host.control.reboot())
 
-    @api_process_hostcontroll
+    @api_process
     def shutdown(self, request):
         """Poweroff host."""
-        return self.host_controll.shutdown()
+        return asyncio.shield(self.sys_host.control.shutdown())
 
-    @api_process_hostcontroll
-    async def update(self, request):
-        """Update host OS."""
-        body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION)
+    @api_process
+    def reload(self, request):
+        """Reload host data."""
+        return asyncio.shield(self.sys_host.reload())
 
-        if version == self.host_controll.version:
-            raise RuntimeError("Version is already in use")
+    @api_process
+    async def services(self, request):
+        """Return list of available services."""
+        services = []
+        for unit in self.sys_host.services:
+            services.append({
+                ATTR_NAME: unit.name,
+                ATTR_DESCRIPTON: unit.description,
+                ATTR_STATE: unit.state,
+            })
 
-        return await self.host_controll.host_update(version=version)
+        return {
+            ATTR_SERVICES: services
+        }
+
+    @api_process
+    def service_start(self, request):
+        """Start a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.start(unit))
+
+    @api_process
+    def service_stop(self, request):
+        """Stop a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.stop(unit))
+
+    @api_process
+    def service_reload(self, request):
+        """Reload a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.reload(unit))
+
+    @api_process
+    def service_restart(self, request):
+        """Restart a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.restart(unit))

hassio/api/info.py

@@ -0,0 +1,28 @@
+"""Init file for Hass.io info RESTful API."""
+import logging
+
+from ..const import (ATTR_ARCH, ATTR_CHANNEL, ATTR_HASSOS, ATTR_HOMEASSISTANT,
+                     ATTR_HOSTNAME, ATTR_MACHINE, ATTR_SUPERVISOR,
+                     ATTR_SUPPORTED_ARCH)
+from ..coresys import CoreSysAttributes
+from .utils import api_process
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIInfo(CoreSysAttributes):
+    """Handle RESTful API for info functions."""
+
+    @api_process
+    async def info(self, request):
+        """Show system info."""
+        return {
+            ATTR_SUPERVISOR: self.sys_supervisor.version,
+            ATTR_HOMEASSISTANT: self.sys_homeassistant.version,
+            ATTR_HASSOS: self.sys_hassos.version,
+            ATTR_HOSTNAME: self.sys_host.info.hostname,
+            ATTR_MACHINE: self.sys_machine,
+            ATTR_ARCH: self.sys_arch.default,
+            ATTR_SUPPORTED_ARCH: self.sys_arch.supported,
+            ATTR_CHANNEL: self.sys_updater.channel,
+        }

hassio/api/ingress.py

@@ -0,0 +1,234 @@
+"""Hass.io Add-on ingress service."""
+import asyncio
+from ipaddress import ip_address
+import logging
+from typing import Any, Dict, Union
+
+import aiohttp
+from aiohttp import hdrs, web
+from aiohttp.web_exceptions import (
+    HTTPBadGateway,
+    HTTPServiceUnavailable,
+    HTTPUnauthorized,
+)
+from multidict import CIMultiDict, istr
+
+from ..addons.addon import Addon
+from ..const import ATTR_SESSION, HEADER_TOKEN, REQUEST_FROM, COOKIE_INGRESS
+from ..coresys import CoreSysAttributes
+from .utils import api_process
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIIngress(CoreSysAttributes):
+    """Ingress view to handle add-on webui routing."""
+
+    def _extract_addon(self, request: web.Request) -> Addon:
+        """Return addon, throw an exception it it doesn't exist."""
+        token = request.match_info.get("token")
+
+        # Find correct add-on
+        addon = self.sys_ingress.get(token)
+        if not addon:
+            _LOGGER.warning("Ingress for %s not available", token)
+            raise HTTPServiceUnavailable()
+
+        return addon
+
+    def _check_ha_access(self, request: web.Request) -> None:
+        if request[REQUEST_FROM] != self.sys_homeassistant:
+            _LOGGER.warning("Ingress is only available behind Home Assistant")
+            raise HTTPUnauthorized()
+
+    def _create_url(self, addon: Addon, path: str) -> str:
+        """Create URL to container."""
+        return f"http://{addon.ip_address}:{addon.ingress_port}/{path}"
+
+    @api_process
+    async def create_session(self, request: web.Request) -> Dict[str, Any]:
+        """Create a new session."""
+        self._check_ha_access(request)
+
+        session = self.sys_ingress.create_session()
+        return {ATTR_SESSION: session}
+
+    async def handler(
+        self, request: web.Request
+    ) -> Union[web.Response, web.StreamResponse, web.WebSocketResponse]:
+        """Route data to Hass.io ingress service."""
+        self._check_ha_access(request)
+
+        # Check Ingress Session
+        session = request.cookies.get(COOKIE_INGRESS)
+        if not self.sys_ingress.validate_session(session):
+            _LOGGER.warning("No valid ingress session %s", session)
+            raise HTTPUnauthorized()
+
+        # Process requests
+        addon = self._extract_addon(request)
+        path = request.match_info.get("path")
+        try:
+            # Websocket
+            if _is_websocket(request):
+                return await self._handle_websocket(request, addon, path)
+
+            # Request
+            return await self._handle_request(request, addon, path)
+
+        except aiohttp.ClientError as err:
+            _LOGGER.error("Ingress error: %s", err)
+
+        raise HTTPBadGateway() from None
+
+    async def _handle_websocket(
+        self, request: web.Request, addon: Addon, path: str
+    ) -> web.WebSocketResponse:
+        """Ingress route for websocket."""
+        if hdrs.SEC_WEBSOCKET_PROTOCOL in request.headers:
+            req_protocols = [
+                str(proto.strip())
+                for proto in request.headers[hdrs.SEC_WEBSOCKET_PROTOCOL].split(",")
+            ]
+        else:
+            req_protocols = ()
+
+        ws_server = web.WebSocketResponse(
+            protocols=req_protocols, autoclose=False, autoping=False
+        )
+        await ws_server.prepare(request)
+
+        # Preparing
+        url = self._create_url(addon, path)
+        source_header = _init_header(request, addon)
+
+        # Support GET query
+        if request.query_string:
+            url = "{}?{}".format(url, request.query_string)
+
+        # Start proxy
+        async with self.sys_websession.ws_connect(
+            url,
+            headers=source_header,
+            protocols=req_protocols,
+            autoclose=False,
+            autoping=False,
+        ) as ws_client:
+            # Proxy requests
+            await asyncio.wait(
+                [
+                    _websocket_forward(ws_server, ws_client),
+                    _websocket_forward(ws_client, ws_server),
+                ],
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+
+        return ws_server
+
+    async def _handle_request(
+        self, request: web.Request, addon: Addon, path: str
+    ) -> Union[web.Response, web.StreamResponse]:
+        """Ingress route for request."""
+        url = self._create_url(addon, path)
+        data = await request.read()
+        source_header = _init_header(request, addon)
+
+        async with self.sys_websession.request(
+            request.method, url, headers=source_header, params=request.query, data=data
+        ) as result:
+            headers = _response_header(result)
+
+            # Simple request
+            if (
+                hdrs.CONTENT_LENGTH in result.headers
+                and int(result.headers.get(hdrs.CONTENT_LENGTH, 0)) < 4_194_000
+            ):
+                # Return Response
+                body = await result.read()
+                return web.Response(
+                    headers=headers,
+                    status=result.status,
+                    content_type=result.content_type,
+                    body=body,
+                )
+
+            # Stream response
+            response = web.StreamResponse(status=result.status, headers=headers)
+            response.content_type = result.content_type
+
+            try:
+                await response.prepare(request)
+                async for data in result.content.iter_chunked(4096):
+                    await response.write(data)
+
+            except (aiohttp.ClientError, aiohttp.ClientPayloadError) as err:
+                _LOGGER.error("Stream error with %s: %s", url, err)
+
+            return response
+
+
+def _init_header(
+    request: web.Request, addon: str
+) -> Union[CIMultiDict, Dict[str, str]]:
+    """Create initial header."""
+    headers = {}
+
+    # filter flags
+    for name, value in request.headers.items():
+        if name in (hdrs.CONTENT_LENGTH, hdrs.CONTENT_ENCODING, istr(HEADER_TOKEN)):
+            continue
+        headers[name] = value
+
+    # Update X-Forwarded-For
+    forward_for = request.headers.get(hdrs.X_FORWARDED_FOR)
+    connected_ip = ip_address(request.transport.get_extra_info("peername")[0])
+    headers[hdrs.X_FORWARDED_FOR] = f"{forward_for}, {connected_ip!s}"
+
+    return headers
+
+
+def _response_header(response: aiohttp.ClientResponse) -> Dict[str, str]:
+    """Create response header."""
+    headers = {}
+
+    for name, value in response.headers.items():
+        if name in (
+            hdrs.TRANSFER_ENCODING,
+            hdrs.CONTENT_LENGTH,
+            hdrs.CONTENT_TYPE,
+            hdrs.CONTENT_ENCODING,
+        ):
+            continue
+        headers[name] = value
+
+    return headers
+
+
+def _is_websocket(request: web.Request) -> bool:
+    """Return True if request is a websocket."""
+    headers = request.headers
+
+    if (
+        headers.get(hdrs.CONNECTION) == "Upgrade"
+        and headers.get(hdrs.UPGRADE) == "websocket"
+    ):
+        return True
+    return False
+
+
+async def _websocket_forward(ws_from, ws_to):
+    """Handle websocket message directly."""
+    try:
+        async for msg in ws_from:
+            if msg.type == aiohttp.WSMsgType.TEXT:
+                await ws_to.send_str(msg.data)
+            elif msg.type == aiohttp.WSMsgType.BINARY:
+                await ws_to.send_bytes(msg.data)
+            elif msg.type == aiohttp.WSMsgType.PING:
+                await ws_to.ping()
+            elif msg.type == aiohttp.WSMsgType.PONG:
+                await ws_to.pong()
+            elif ws_to.closed:
+                await ws_to.close(code=ws_to.close_code, message=msg.extra)
+    except RuntimeError:
+        _LOGGER.warning("Ingress Websocket runtime error")

hassio/api/network.py

@@ -1,26 +0,0 @@
-"""Init file for HassIO network rest api."""
-import logging
-
-from .util import api_process_hostcontroll
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class APINetwork(object):
-    """Handle rest api for network functions."""
-
-    def __init__(self, config, loop, host_controll):
-        """Initialize network rest api part."""
-        self.config = config
-        self.loop = loop
-        self.host_controll = host_controll
-
-    @api_process_hostcontroll
-    def info(self, request):
-        """Show network settings."""
-        pass
-
-    @api_process_hostcontroll
-    def options(self, request):
-        """Edit network settings."""
-        pass

hassio/api/panel/chunk.3a63ad36bccf4ea567fa.js

@@ -0,0 +1 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[7],{102:function(n,r,t){"use strict";t.r(r),t.d(r,"marked",function(){return a}),t.d(r,"filterXSS",function(){return c});var e=t(121),i=t.n(e),o=t(123),u=t.n(o),a=i.a,c=u.a}}]);

hassio/api/panel/chunk.510634470d399e194ace.js.LICENSE

@@ -0,0 +1,10 @@
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/

hassio/api/panel/chunk.510634470d399e194ace.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk.510634470d399e194ace.js","sourceRoot":""}

hassio/api/panel/chunk.564a2f7b1c38ddaa4ce0.js.LICENSE

@@ -0,0 +1,21 @@
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/

hassio/api/panel/chunk.564a2f7b1c38ddaa4ce0.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk.564a2f7b1c38ddaa4ce0.js","sourceRoot":""}

hassio/api/panel/chunk.659084fef4e3b7b66a76.js.LICENSE

@@ -0,0 +1,32 @@
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+ * @fileoverview
+ * @suppress {checkPrototypalTypes}
+ * @license Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt The complete set of authors may be found
+ * at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
+ * be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
+ * Google as part of the polymer project is also subject to an additional IP
+ * rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/

hassio/api/panel/chunk.659084fef4e3b7b66a76.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk.659084fef4e3b7b66a76.js","sourceRoot":""}

hassio/api/panel/chunk.6e9c87e51920a9c354e5.js.LICENSE

@@ -0,0 +1,31 @@
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/

hassio/api/panel/chunk.6e9c87e51920a9c354e5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk.6e9c87e51920a9c354e5.js","sourceRoot":""}

hassio/api/panel/chunk.a7e5fb452cd1b3a5faef.js.LICENSE

@@ -0,0 +1,180 @@
+/**
+ * @license
+ * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+
+/**
+@license
+Copyright (c) 2019 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright 2018 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+/**
+ * @license
+ * Copyright 2016 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * @license
+ * Copyright 2018 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * @license
+ * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at
+ * http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at
+ * http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+
+/**
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+*/
+
+/**
+@license
+Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/

hassio/api/panel/chunk.a7e5fb452cd1b3a5faef.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk.a7e5fb452cd1b3a5faef.js","sourceRoot":""}

hassio/api/panel/chunk.f15d7f41c0d302cbbc7a.js.LICENSE

@@ -0,0 +1,10 @@
+/**
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at
+http://polymer.github.io/LICENSE.txt The complete set of authors may be found at
+http://polymer.github.io/AUTHORS.txt The complete set of contributors may be
+found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by Google as
+part of the polymer project is also subject to an additional IP rights grant
+found at http://polymer.github.io/PATENTS.txt
+*/

hassio/api/panel/chunk.f15d7f41c0d302cbbc7a.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk.f15d7f41c0d302cbbc7a.js","sourceRoot":""}

hassio/api/panel/entrypoint.js

@@ -0,0 +1 @@
+!function(e){function n(n){for(var t,o,a=n[0],i=n[1],c=0,u=[];c<a.length;c++)o=a[c],r[o]&&u.push(r[o][0]),r[o]=0;for(t in i)Object.prototype.hasOwnProperty.call(i,t)&&(e[t]=i[t]);for(f&&f(n);u.length;)u.shift()()}var t={},r={4:0};function o(n){if(t[n])return t[n].exports;var r=t[n]={i:n,l:!1,exports:{}};return e[n].call(r.exports,r,r.exports,o),r.l=!0,r.exports}o.e=function(e){var n=[],t=r[e];if(0!==t)if(t)n.push(t[2]);else{var a=new Promise(function(n,o){t=r[e]=[n,o]});n.push(t[2]=a);var i,c=document.createElement("script");c.charset="utf-8",c.timeout=120,o.nc&&c.setAttribute("nonce",o.nc),c.src=function(e){return o.p+"chunk."+{0:"564a2f7b1c38ddaa4ce0",1:"659084fef4e3b7b66a76",2:"510634470d399e194ace",3:"f15d7f41c0d302cbbc7a",5:"5d31a1778f717ac8b063",6:"feb68d852b3f6d67d970",7:"3a63ad36bccf4ea567fa",8:"a571dfa106202cc57af6",9:"a7e5fb452cd1b3a5faef",10:"b3340b3df270d20af4a1",11:"6e9c87e51920a9c354e5",12:"183d719f6ced86001f8e",13:"739b67c99ab56cdbd75d"}[e]+".js"}(e),i=function(n){c.onerror=c.onload=null,clearTimeout(f);var t=r[e];if(0!==t){if(t){var o=n&&("load"===n.type?"missing":n.type),a=n&&n.target&&n.target.src,i=new Error("Loading chunk "+e+" failed.\n("+o+": "+a+")");i.type=o,i.request=a,t[1](i)}r[e]=void 0}};var f=setTimeout(function(){i({type:"timeout",target:c})},12e4);c.onerror=c.onload=i,document.head.appendChild(c)}return Promise.all(n)},o.m=e,o.c=t,o.d=function(e,n,t){o.o(e,n)||Object.defineProperty(e,n,{enumerable:!0,get:t})},o.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},o.t=function(e,n){if(1&n&&(e=o(e)),8&n)return e;if(4&n&&"object"==typeof e&&e&&e.__esModule)return e;var t=Object.create(null);if(o.r(t),Object.defineProperty(t,"default",{enumerable:!0,value:e}),2&n&&"string"!=typeof e)for(var r in e)o.d(t,r,function(n){return e[n]}.bind(null,r));return t},o.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return o.d(n,"a",n),n},o.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},o.p="/api/hassio/app/",o.oe=function(e){throw console.error(e),e};var a=window.webpackJsonp=window.webpackJsonp||[],i=a.push.bind(a);a.push=n,a=a.slice();for(var c=0;c<a.length;c++)n(a[c]);var f=i;o(o.s=0)}([function(e,n,t){window.loadES5Adapter().then(function(){Promise.all([t.e(1),t.e(5)]).then(t.bind(null,2)),Promise.all([t.e(1),t.e(9),t.e(6)]).then(t.bind(null,1))});var r=document.createElement("style");r.innerHTML="\nbody {\n  font-family: Roboto, sans-serif;\n  -moz-osx-font-smoothing: grayscale;\n  -webkit-font-smoothing: antialiased;\n  font-weight: 400;\n  margin: 0;\n  padding: 0;\n  height: 100vh;\n}\n",document.head.appendChild(r)}]);

hassio/api/panel/index.html

@@ -0,0 +1,38 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Hass.io</title>
+    <meta name='viewport' content='width=device-width, user-scalable=no'>
+    <style>
+      body {
+        height: 100vh;
+        margin: 0;
+        padding: 0;
+      }
+    </style>
+    <script src='/frontend_es5/custom-elements-es5-adapter.js'></script>
+  </head>
+  <body>
+    <hassio-app></hassio-app>
+    <script>
+    function addScript(src) {
+      var e = document.createElement('script');
+      e.src = src;
+      document.write(e.outerHTML);
+    }
+    var webComponentsSupported = (
+      'customElements' in window &&
+      'import' in document.createElement('link') &&
+      'content' in document.createElement('template'));
+    if (!webComponentsSupported) {
+      addScript('/static/webcomponents-lite.js');
+    }
+    </script>
+    <!--
+      Disabled while we make Home Assistant able to serve the right files.
+      <script src="./app.js"></script>
+    -->
+    <link rel='import' href='./hassio-app.html'>
+  </body>
+</html>

hassio/api/proxy.py

@@ -0,0 +1,253 @@
+"""Utils for Home Assistant Proxy."""
+import asyncio
+from contextlib import asynccontextmanager
+import logging
+
+import aiohttp
+from aiohttp import web
+from aiohttp.web_exceptions import HTTPBadGateway, HTTPUnauthorized
+from aiohttp.client_exceptions import ClientConnectorError
+from aiohttp.hdrs import CONTENT_TYPE, AUTHORIZATION
+import async_timeout
+
+from ..const import HEADER_HA_ACCESS
+from ..coresys import CoreSysAttributes
+from ..exceptions import (
+    HomeAssistantAuthError, HomeAssistantAPIError, APIError)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class APIProxy(CoreSysAttributes):
+    """API Proxy for Home Assistant."""
+
+    def _check_access(self, request):
+        """Check the Hass.io token."""
+        if AUTHORIZATION in request.headers:
+            bearer = request.headers[AUTHORIZATION]
+            hassio_token = bearer.split(' ')[-1]
+        else:
+            hassio_token = request.headers.get(HEADER_HA_ACCESS)
+
+        addon = self.sys_addons.from_token(hassio_token)
+        if not addon:
+            _LOGGER.warning("Unknown Home Assistant API access!")
+        elif not addon.access_homeassistant_api:
+            _LOGGER.warning("Not permitted API access: %s", addon.slug)
+        else:
+            _LOGGER.debug("%s access from %s", request.path, addon.slug)
+            return
+
+        raise HTTPUnauthorized()
+
+    @asynccontextmanager
+    async def _api_client(self, request, path, timeout=300):
+        """Return a client request with proxy origin for Home Assistant."""
+        try:
+            # read data
+            with async_timeout.timeout(30):
+                data = await request.read()
+
+            if data:
+                content_type = request.content_type
+            else:
+                content_type = None
+
+            async with self.sys_homeassistant.make_request(
+                    request.method.lower(), f'api/{path}',
+                    content_type=content_type,
+                    data=data,
+                    timeout=timeout,
+            ) as resp:
+                yield resp
+                return
+
+        except HomeAssistantAuthError:
+            _LOGGER.error("Authenticate error on API for request %s", path)
+        except HomeAssistantAPIError:
+            _LOGGER.error("Error on API for request %s", path)
+        except aiohttp.ClientError as err:
+            _LOGGER.error("Client error on API %s request %s", path, err)
+        except asyncio.TimeoutError:
+            _LOGGER.error("Client timeout error on API request %s", path)
+
+        raise HTTPBadGateway()
+
+    async def stream(self, request):
+        """Proxy HomeAssistant EventStream Requests."""
+        self._check_access(request)
+
+        _LOGGER.info("Home Assistant EventStream start")
+        async with self._api_client(request, 'stream', timeout=None) as client:
+            response = web.StreamResponse()
+            response.content_type = request.headers.get(CONTENT_TYPE)
+            try:
+                await response.prepare(request)
+                async for data in client.content:
+                    await response.write(data)
+
+            except (aiohttp.ClientError, aiohttp.ClientPayloadError):
+                pass
+
+            _LOGGER.info("Home Assistant EventStream close")
+            return response
+
+    async def api(self, request):
+        """Proxy Home Assistant API Requests."""
+        self._check_access(request)
+
+        # Normal request
+        path = request.match_info.get('path', '')
+        async with self._api_client(request, path) as client:
+            data = await client.read()
+            return web.Response(
+                body=data,
+                status=client.status,
+                content_type=client.content_type
+            )
+
+    async def _websocket_client(self):
+        """Initialize a WebSocket API connection."""
+        url = f"{self.sys_homeassistant.api_url}/api/websocket"
+
+        try:
+            client = await self.sys_websession_ssl.ws_connect(
+                url, heartbeat=30, verify_ssl=False)
+
+            # Handle authentication
+            data = await client.receive_json()
+
+            if data.get('type') == 'auth_ok':
+                return client
+
+            if data.get('type') != 'auth_required':
+                # Invalid protocol
+                _LOGGER.error(
+                    "Got unexpected response from HA WebSocket: %s", data)
+                raise APIError()
+
+            if self.sys_homeassistant.refresh_token:
+                await self.sys_homeassistant.ensure_access_token()
+                await client.send_json({
+                    'type': 'auth',
+                    'access_token': self.sys_homeassistant.access_token,
+                })
+            else:
+                await client.send_json({
+                    'type': 'auth',
+                    'api_password': self.sys_homeassistant.api_password,
+                })
+
+            data = await client.receive_json()
+
+            if data.get('type') == 'auth_ok':
+                return client
+
+            # Renew the Token is invalid
+            if data.get('type') == 'invalid_auth' and self.sys_homeassistant.refresh_token:
+                self.sys_homeassistant.access_token = None
+                return await self._websocket_client()
+
+            raise HomeAssistantAuthError()
+
+        except (RuntimeError, ValueError, ClientConnectorError) as err:
+            _LOGGER.error("Client error on WebSocket API %s.", err)
+        except HomeAssistantAuthError:
+            _LOGGER.error("Failed authentication to Home Assistant WebSocket")
+
+        raise APIError()
+
+    async def websocket(self, request):
+        """Initialize a WebSocket API connection."""
+        _LOGGER.info("Home Assistant WebSocket API request initialize")
+
+        # init server
+        server = web.WebSocketResponse(heartbeat=30)
+        await server.prepare(request)
+
+        # handle authentication
+        try:
+            await server.send_json({
+                'type': 'auth_required',
+                'ha_version': self.sys_homeassistant.version,
+            })
+
+            # Check API access
+            response = await server.receive_json()
+            hassio_token = response.get('api_password') or response.get('access_token')
+            addon = self.sys_addons.from_token(hassio_token)
+
+            if not addon or not addon.access_homeassistant_api:
+                _LOGGER.warning("Unauthorized WebSocket access!")
+                await server.send_json({
+                    'type': 'auth_invalid',
+                    'message': 'Invalid access',
+                })
+                return server
+
+            _LOGGER.info("WebSocket access from %s", addon.slug)
+
+            await server.send_json({
+                'type': 'auth_ok',
+                'ha_version': self.sys_homeassistant.version,
+            })
+        except (RuntimeError, ValueError) as err:
+            _LOGGER.error("Can't initialize handshake: %s", err)
+            return server
+
+        # init connection to hass
+        try:
+            client = await self._websocket_client()
+        except APIError:
+            return server
+
+        _LOGGER.info("Home Assistant WebSocket API request running")
+        try:
+            client_read = None
+            server_read = None
+            while not server.closed and not client.closed:
+                if not client_read:
+                    client_read = self.sys_create_task(
+                        client.receive_str())
+                if not server_read:
+                    server_read = self.sys_create_task(
+                        server.receive_str())
+
+                # wait until data need to be processed
+                await asyncio.wait(
+                    [client_read, server_read],
+                    return_when=asyncio.FIRST_COMPLETED
+                )
+
+                # server
+                if server_read.done() and not client.closed:
+                    server_read.exception()
+                    await client.send_str(server_read.result())
+                    server_read = None
+
+                # client
+                if client_read.done() and not server.closed:
+                    client_read.exception()
+                    await server.send_str(client_read.result())
+                    client_read = None
+
+        except asyncio.CancelledError:
+            pass
+
+        except (RuntimeError, ConnectionError, TypeError) as err:
+            _LOGGER.info("Home Assistant WebSocket API error: %s", err)
+
+        finally:
+            if client_read:
+                client_read.cancel()
+            if server_read:
+                server_read.cancel()
+
+            # close connections
+            if not client.closed:
+                await client.close()
+            if not server.closed:
+                await server.close()
+
+        _LOGGER.info("Home Assistant WebSocket API connection is closed")
+        return server

hassio/api/security.py

@@ -0,0 +1,147 @@
+"""Handle security part of this API."""
+import logging
+import re
+
+from aiohttp.web import middleware
+from aiohttp.web_exceptions import HTTPUnauthorized, HTTPForbidden
+
+from ..const import (
+    HEADER_TOKEN,
+    REQUEST_FROM,
+    ROLE_ADMIN,
+    ROLE_DEFAULT,
+    ROLE_HOMEASSISTANT,
+    ROLE_MANAGER,
+    ROLE_BACKUP,
+)
+from ..coresys import CoreSysAttributes
+
+_LOGGER = logging.getLogger(__name__)
+
+# fmt: off
+
+# Block Anytime
+BLACKLIST = re.compile(
+    r"^(?:"
+    r"|/homeassistant/api/hassio/.*"
+    r")$"
+)
+
+# Free to call or have own security concepts
+NO_SECURITY_CHECK = re.compile(
+    r"^(?:"
+    r"|/homeassistant/api/.*"
+    r"|/homeassistant/websocket"
+    r"|/supervisor/ping"
+    r")$"
+)
+
+# Can called by every add-on
+ADDONS_API_BYPASS = re.compile(
+    r"^(?:"
+    r"|/addons/self/(?!security|update)[^/]+"
+    r"|/info"
+    r"|/services.*"
+    r"|/discovery.*"
+    r"|/auth"
+    r")$"
+)
+
+# Policy role add-on API access
+ADDONS_ROLE_ACCESS = {
+    ROLE_DEFAULT: re.compile(
+        r"^(?:"
+        r"|/[^/]+/info"
+        r"|/addons"
+        r")$"
+    ),
+    ROLE_HOMEASSISTANT: re.compile(
+        r"^(?:"
+        r"|/homeassistant/.+"
+        r")$"
+    ),
+    ROLE_BACKUP: re.compile(
+        r"^(?:"
+        r"|/snapshots.*"
+        r")$"
+    ),
+    ROLE_MANAGER: re.compile(
+        r"^(?:"
+        r"|/homeassistant/.+"
+        r"|/host/.+"
+        r"|/hardware/.+"
+        r"|/hassos/.+"
+        r"|/supervisor/.+"
+        r"|/addons(?:/[^/]+/(?!security).+|/reload)?"
+        r"|/snapshots.*"
+        r")$"
+    ),
+    ROLE_ADMIN: re.compile(
+        r".*"
+    ),
+}
+
+# fmt: off
+
+
+class SecurityMiddleware(CoreSysAttributes):
+    """Security middleware functions."""
+
+    def __init__(self, coresys):
+        """Initialize security middleware."""
+        self.coresys = coresys
+
+    @middleware
+    async def token_validation(self, request, handler):
+        """Check security access of this layer."""
+        request_from = None
+        hassio_token = request.headers.get(HEADER_TOKEN)
+
+        # Blacklist
+        if BLACKLIST.match(request.path):
+            _LOGGER.warning("%s is blacklisted!", request.path)
+            raise HTTPForbidden()
+
+        # Ignore security check
+        if NO_SECURITY_CHECK.match(request.path):
+            _LOGGER.debug("Passthrough %s", request.path)
+            return await handler(request)
+
+        # Not token
+        if not hassio_token:
+            _LOGGER.warning("No API token provided for %s", request.path)
+            raise HTTPUnauthorized()
+
+        # Home-Assistant
+        if hassio_token == self.sys_homeassistant.hassio_token:
+            _LOGGER.debug("%s access from Home Assistant", request.path)
+            request_from = self.sys_homeassistant
+
+        # Host
+        if hassio_token == self.sys_machine_id:
+            _LOGGER.debug("%s access from Host", request.path)
+            request_from = self.sys_host
+
+        # Add-on
+        addon = None
+        if hassio_token and not request_from:
+            addon = self.sys_addons.from_token(hassio_token)
+
+        # Check Add-on API access
+        if addon and ADDONS_API_BYPASS.match(request.path):
+            _LOGGER.debug("Passthrough %s from %s", request.path, addon.slug)
+            request_from = addon
+        elif addon and addon.access_hassio_api:
+            # Check Role
+            if ADDONS_ROLE_ACCESS[addon.hassio_role].match(request.path):
+                _LOGGER.info("%s access from %s", request.path, addon.slug)
+                request_from = addon
+            else:
+                _LOGGER.warning("%s no role for %s", request.path, addon.slug)
+
+        if request_from:
+            request[REQUEST_FROM] = request_from
+            return await handler(request)
+
+        _LOGGER.error("Invalid token for access %s", request.path)
+        raise HTTPForbidden()

hassio/api/services.py

@@ -0,0 +1,75 @@
+"""Init file for Hass.io network RESTful API."""
+
+from .utils import api_process, api_validate
+from ..const import (
+    ATTR_AVAILABLE, ATTR_PROVIDERS, ATTR_SLUG, ATTR_SERVICES, REQUEST_FROM,
+    PROVIDE_SERVICE)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError, APIForbidden
+
+
+class APIServices(CoreSysAttributes):
+    """Handle RESTful API for services functions."""
+
+    def _extract_service(self, request):
+        """Return service, throw an exception if it doesn't exist."""
+        service = self.sys_services.get(request.match_info.get('service'))
+        if not service:
+            raise APIError("Service does not exist")
+
+        return service
+
+    @api_process
+    async def list(self, request):
+        """Show register services."""
+        services = []
+        for service in self.sys_services.list_services:
+            services.append({
+                ATTR_SLUG: service.slug,
+                ATTR_AVAILABLE: service.enabled,
+                ATTR_PROVIDERS: service.providers,
+            })
+
+        return {ATTR_SERVICES: services}
+
+    @api_process
+    async def set_service(self, request):
+        """Write data into a service."""
+        service = self._extract_service(request)
+        body = await api_validate(service.schema, request)
+        addon = request[REQUEST_FROM]
+
+        _check_access(request, service.slug)
+        service.set_service_data(addon, body)
+
+    @api_process
+    async def get_service(self, request):
+        """Read data into a service."""
+        service = self._extract_service(request)
+
+        # Access
+        _check_access(request, service.slug)
+
+        if not service.enabled:
+            raise APIError("Service not enabled")
+        return service.get_service_data()
+
+    @api_process
+    async def del_service(self, request):
+        """Delete data into a service."""
+        service = self._extract_service(request)
+        addon = request[REQUEST_FROM]
+
+        # Access
+        _check_access(request, service.slug, True)
+        service.del_service_data(addon)
+
+
+def _check_access(request, service, provide=False):
+    """Raise error if the rights are wrong."""
+    addon = request[REQUEST_FROM]
+    if not addon.services_role.get(service):
+        raise APIForbidden(f"No access to {service} service!")
+
+    if provide and addon.services_role.get(service) != PROVIDE_SERVICE:
+        raise APIForbidden(f"No access to write {service} service!")

hassio/api/snapshots.py

@@ -0,0 +1,187 @@
+"""Init file for Hass.io snapshot RESTful API."""
+import asyncio
+import logging
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from aiohttp import web
+import voluptuous as vol
+
+from .utils 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_SNAPSHOTS, ATTR_PASSWORD, ATTR_PROTECTED, CONTENT_TYPE_TAR)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_RESTORE_PARTIAL = vol.Schema({
+    vol.Optional(ATTR_PASSWORD): vol.Any(None, vol.Coerce(str)),
+    vol.Optional(ATTR_HOMEASSISTANT): vol.Boolean(),
+    vol.Optional(ATTR_ADDONS):
+        vol.All([vol.Coerce(str)], vol.Unique()),
+    vol.Optional(ATTR_FOLDERS):
+        vol.All([vol.In(ALL_FOLDERS)], vol.Unique()),
+})
+
+SCHEMA_RESTORE_FULL = vol.Schema({
+    vol.Optional(ATTR_PASSWORD): vol.Any(None, vol.Coerce(str)),
+})
+
+SCHEMA_SNAPSHOT_FULL = vol.Schema({
+    vol.Optional(ATTR_NAME): vol.Coerce(str),
+    vol.Optional(ATTR_PASSWORD): vol.Any(None, vol.Coerce(str)),
+})
+
+SCHEMA_SNAPSHOT_PARTIAL = SCHEMA_SNAPSHOT_FULL.extend({
+    vol.Optional(ATTR_ADDONS):
+        vol.All([vol.Coerce(str)], vol.Unique()),
+    vol.Optional(ATTR_FOLDERS):
+        vol.All([vol.In(ALL_FOLDERS)], vol.Unique()),
+})
+
+
+class APISnapshots(CoreSysAttributes):
+    """Handle RESTful API for snapshot functions."""
+
+    def _extract_snapshot(self, request):
+        """Return snapshot, throw an exception if it doesn't exist."""
+        snapshot = self.sys_snapshots.get(request.match_info.get('snapshot'))
+        if not snapshot:
+            raise APIError("Snapshot does not exist")
+        return snapshot
+
+    @api_process
+    async def list(self, request):
+        """Return snapshot list."""
+        data_snapshots = []
+        for snapshot in self.sys_snapshots.list_snapshots:
+            data_snapshots.append({
+                ATTR_SLUG: snapshot.slug,
+                ATTR_NAME: snapshot.name,
+                ATTR_DATE: snapshot.date,
+                ATTR_TYPE: snapshot.sys_type,
+                ATTR_PROTECTED: snapshot.protected,
+            })
+
+        return {
+            ATTR_SNAPSHOTS: data_snapshots,
+        }
+
+    @api_process
+    async def reload(self, request):
+        """Reload snapshot list."""
+        await asyncio.shield(self.sys_snapshots.reload())
+        return True
+
+    @api_process
+    async def info(self, request):
+        """Return snapshot info."""
+        snapshot = self._extract_snapshot(request)
+
+        data_addons = []
+        for addon_data in snapshot.addons:
+            data_addons.append({
+                ATTR_SLUG: addon_data[ATTR_SLUG],
+                ATTR_NAME: addon_data[ATTR_NAME],
+                ATTR_VERSION: addon_data[ATTR_VERSION],
+                ATTR_SIZE: addon_data[ATTR_SIZE],
+            })
+
+        return {
+            ATTR_SLUG: snapshot.slug,
+            ATTR_TYPE: snapshot.sys_type,
+            ATTR_NAME: snapshot.name,
+            ATTR_DATE: snapshot.date,
+            ATTR_SIZE: snapshot.size,
+            ATTR_PROTECTED: snapshot.protected,
+            ATTR_HOMEASSISTANT: snapshot.homeassistant_version,
+            ATTR_ADDONS: data_addons,
+            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)
+        snapshot = await asyncio.shield(
+            self.sys_snapshots.do_snapshot_full(**body))
+
+        if snapshot:
+            return {ATTR_SLUG: snapshot.slug}
+        return False
+
+    @api_process
+    async def snapshot_partial(self, request):
+        """Partial-Snapshot a snapshot."""
+        body = await api_validate(SCHEMA_SNAPSHOT_PARTIAL, request)
+        snapshot = await asyncio.shield(
+            self.sys_snapshots.do_snapshot_partial(**body))
+
+        if snapshot:
+            return {ATTR_SLUG: snapshot.slug}
+        return False
+
+    @api_process
+    async def restore_full(self, request):
+        """Full-Restore a snapshot."""
+        snapshot = self._extract_snapshot(request)
+        body = await api_validate(SCHEMA_RESTORE_FULL, request)
+
+        return await asyncio.shield(
+            self.sys_snapshots.do_restore_full(snapshot, **body))
+
+    @api_process
+    async def restore_partial(self, request):
+        """Partial-Restore a snapshot."""
+        snapshot = self._extract_snapshot(request)
+        body = await api_validate(SCHEMA_RESTORE_PARTIAL, request)
+
+        return await asyncio.shield(
+            self.sys_snapshots.do_restore_partial(snapshot, **body))
+
+    @api_process
+    async def remove(self, request):
+        """Remove a snapshot."""
+        snapshot = self._extract_snapshot(request)
+        return self.sys_snapshots.remove(snapshot)
+
+    async def download(self, request):
+        """Download a snapshot file."""
+        snapshot = self._extract_snapshot(request)
+
+        _LOGGER.info("Download snapshot %s", snapshot.slug)
+        response = web.FileResponse(snapshot.tarfile)
+        response.content_type = CONTENT_TYPE_TAR
+        return response
+
+    @api_process
+    async def upload(self, request):
+        """Upload a snapshot file."""
+        with TemporaryDirectory(dir=str(self.sys_config.path_tmp)) as temp_dir:
+            tar_file = Path(temp_dir, f"snapshot.tar")
+
+            try:
+                with tar_file.open('wb') as snapshot:
+                    async for data in request.content.iter_any():
+                        snapshot.write(data)
+
+            except OSError as err:
+                _LOGGER.error("Can't write new snapshot file: %s", err)
+                return False
+
+            except asyncio.CancelledError:
+                return False
+
+            snapshot = await asyncio.shield(
+                self.sys_snapshots.import_snapshot(tar_file))
+
+            if snapshot:
+                return {ATTR_SLUG: snapshot.slug}
+            return False

hassio/api/supervisor.py

@@ -1,90 +1,151 @@
-"""Init file for HassIO supervisor rest api."""
+"""Init file for Hass.io Supervisor RESTful API."""
 import asyncio
 import logging
+from typing import Any, Awaitable, Dict
 
+from aiohttp import web
 import voluptuous as vol
 
-from .util import api_process, api_process_raw, api_validate
 from ..const import (
-    ATTR_ADDONS, ATTR_VERSION, ATTR_CURRENT, ATTR_BETA, HASSIO_VERSION)
+    ATTR_ADDONS,
+    ATTR_ADDONS_REPOSITORIES,
+    ATTR_ARCH,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_CHANNEL,
+    ATTR_CPU_PERCENT,
+    ATTR_DESCRIPTON,
+    ATTR_ICON,
+    ATTR_INSTALLED,
+    ATTR_LAST_VERSION,
+    ATTR_LOGO,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_USAGE,
+    ATTR_NAME,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+    ATTR_REPOSITORY,
+    ATTR_SLUG,
+    ATTR_STATE,
+    ATTR_TIMEZONE,
+    ATTR_VERSION,
+    ATTR_WAIT_BOOT,
+    ATTR_IP_ADDRESS,
+    CONTENT_TYPE_BINARY,
+    HASSIO_VERSION,
+)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
+from ..utils.validate import validate_timezone
+from ..validate import CHANNELS, REPOSITORIES, WAIT_BOOT
+from .utils import api_process, api_process_raw, api_validate
 
 _LOGGER = logging.getLogger(__name__)
 
-SCHEMA_OPTIONS = vol.Schema({
-    # pylint: disable=no-value-for-parameter
-    vol.Optional(ATTR_BETA): vol.Boolean(),
-})
+SCHEMA_OPTIONS = vol.Schema(
+    {
+        vol.Optional(ATTR_CHANNEL): CHANNELS,
+        vol.Optional(ATTR_ADDONS_REPOSITORIES): REPOSITORIES,
+        vol.Optional(ATTR_TIMEZONE): validate_timezone,
+        vol.Optional(ATTR_WAIT_BOOT): WAIT_BOOT,
+    }
+)
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
-})
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 
 
-class APISupervisor(object):
-    """Handle rest api for supervisor functions."""
-
-    def __init__(self, config, loop, supervisor, addons):
-        """Initialize supervisor rest api part."""
-        self.config = config
-        self.loop = loop
-        self.supervisor = supervisor
-        self.addons = addons
+class APISupervisor(CoreSysAttributes):
+    """Handle RESTful API for Supervisor functions."""
 
     @api_process
     async def ping(self, request):
-        """Return ok for signal that the api is ready."""
+        """Return ok for signal that the API is ready."""
         return True
 
     @api_process
-    async def info(self, request):
+    async def info(self, request: web.Request) -> Dict[str, Any]:
         """Return host information."""
-        info = {
+        list_addons = []
+        for addon in self.sys_addons.list_addons:
+            if addon.is_installed:
+                list_addons.append(
+                    {
+                        ATTR_NAME: addon.name,
+                        ATTR_SLUG: addon.slug,
+                        ATTR_DESCRIPTON: addon.description,
+                        ATTR_STATE: await addon.state(),
+                        ATTR_VERSION: addon.latest_version,
+                        ATTR_INSTALLED: addon.version_installed,
+                        ATTR_REPOSITORY: addon.repository,
+                        ATTR_ICON: addon.with_icon,
+                        ATTR_LOGO: addon.with_logo,
+                    }
+                )
+
+        return {
             ATTR_VERSION: HASSIO_VERSION,
-            ATTR_CURRENT: self.config.current_hassio,
-            ATTR_BETA: self.config.upstream_beta,
-            ATTR_ADDONS: self.addons.list,
+            ATTR_LAST_VERSION: self.sys_updater.version_hassio,
+            ATTR_CHANNEL: self.sys_updater.channel,
+            ATTR_ARCH: self.sys_supervisor.arch,
+            ATTR_IP_ADDRESS: str(self.sys_supervisor.ip_address),
+            ATTR_WAIT_BOOT: self.sys_config.wait_boot,
+            ATTR_TIMEZONE: self.sys_config.timezone,
+            ATTR_ADDONS: list_addons,
+            ATTR_ADDONS_REPOSITORIES: self.sys_config.addons_repositories,
         }
-        return info
 
     @api_process
-    async def options(self, request):
-        """Set supervisor options."""
+    async def options(self, request: web.Request) -> None:
+        """Set Supervisor options."""
         body = await api_validate(SCHEMA_OPTIONS, request)
 
-        if ATTR_BETA in body:
-            self.config.upstream_beta = body[ATTR_BETA]
+        if ATTR_CHANNEL in body:
+            self.sys_updater.channel = body[ATTR_CHANNEL]
 
-        return self.config.save()
+        if ATTR_TIMEZONE in body:
+            self.sys_config.timezone = body[ATTR_TIMEZONE]
+
+        if ATTR_WAIT_BOOT in body:
+            self.sys_config.wait_boot = body[ATTR_WAIT_BOOT]
+
+        if ATTR_ADDONS_REPOSITORIES in body:
+            new = set(body[ATTR_ADDONS_REPOSITORIES])
+            await asyncio.shield(self.sys_addons.load_repositories(new))
+
+        self.sys_updater.save_data()
+        self.sys_config.save_data()
 
     @api_process
-    async def update(self, request):
-        """Update supervisor OS."""
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
+        """Return resource information."""
+        stats = await self.sys_supervisor.stats()
+
+        return {
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
+        }
+
+    @api_process
+    async def update(self, request: web.Request) -> None:
+        """Update Supervisor OS."""
         body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self.config.current_hassio)
+        version = body.get(ATTR_VERSION, self.sys_updater.version_hassio)
 
-        if version == self.supervisor.version:
-            raise RuntimeError("Version is already in use")
-
-        return await asyncio.shield(
-            self.supervisor.update(version), loop=self.loop)
+        if version == self.sys_supervisor.version:
+            raise APIError("Version {} is already in use".format(version))
+        await asyncio.shield(self.sys_supervisor.update(version))
 
     @api_process
-    async def reload(self, request):
-        """Reload addons, config ect."""
-        tasks = [self.addons.reload(), self.config.fetch_update_infos()]
-        results, _ = await asyncio.shield(
-            asyncio.wait(tasks, loop=self.loop), loop=self.loop)
+    def reload(self, request: web.Request) -> Awaitable[None]:
+        """Reload add-ons, configuration, etc."""
+        return asyncio.shield(self.sys_updater.reload())
 
-        for result in results:
-            if result.exception() is not None:
-                raise RuntimeError("Some reload task fails!")
-
-        return True
-
-    @api_process_raw
-    def logs(self, request):
-        """Return supervisor docker logs.
-
-        Return a coroutine.
-        """
-        return self.supervisor.logs()
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return supervisor Docker logs."""
+        return self.sys_supervisor.logs()

hassio/api/util.py

@@ -1,103 +0,0 @@
-"""Init file for HassIO util for rest api."""
-import json
-import logging
-
-from aiohttp import web
-from aiohttp.web_exceptions import HTTPServiceUnavailable
-import voluptuous as vol
-from voluptuous.humanize import humanize_error
-
-from ..const import (
-    JSON_RESULT, JSON_DATA, JSON_MESSAGE, RESULT_OK, RESULT_ERROR)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def json_loads(data):
-    """Extract json from string with support for '' and None."""
-    try:
-        return json.loads(data)
-    except json.JSONDecodeError:
-        return {}
-
-
-def api_process(method):
-    """Wrap function with true/false calls to rest api."""
-    async def wrap_api(api, *args, **kwargs):
-        """Return api information."""
-        try:
-            answer = await method(api, *args, **kwargs)
-        except RuntimeError as err:
-            return api_return_error(message=str(err))
-
-        if isinstance(answer, dict):
-            return api_return_ok(data=answer)
-        elif answer:
-            return api_return_ok()
-        return api_return_error()
-
-    return wrap_api
-
-
-def api_process_hostcontroll(method):
-    """Wrap HostControll calls to rest api."""
-    async def wrap_hostcontroll(api, *args, **kwargs):
-        """Return host information."""
-        if not api.host_controll.active:
-            raise HTTPServiceUnavailable()
-
-        try:
-            answer = await method(api, *args, **kwargs)
-        except RuntimeError as err:
-            return api_return_error(message=str(err))
-
-        if isinstance(answer, dict):
-            return api_return_ok(data=answer)
-        elif answer is None:
-            return api_return_error("Function is not supported")
-        elif answer:
-            return api_return_ok()
-        return api_return_error()
-
-    return wrap_hostcontroll
-
-
-def api_process_raw(method):
-    """Wrap function with raw output to rest api."""
-    async def wrap_api(api, *args, **kwargs):
-        """Return api information."""
-        try:
-            message = await method(api, *args, **kwargs)
-        except RuntimeError as err:
-            message = str(err).encode()
-
-        return web.Response(body=message)
-
-    return wrap_api
-
-
-def api_return_error(message=None):
-    """Return a API error message."""
-    return web.json_response({
-        JSON_RESULT: RESULT_ERROR,
-        JSON_MESSAGE: message,
-    })
-
-
-def api_return_ok(data=None):
-    """Return a API ok answer."""
-    return web.json_response({
-        JSON_RESULT: RESULT_OK,
-        JSON_DATA: data or {},
-    })
-
-
-async def api_validate(schema, request):
-    """Validate request data with schema."""
-    data = await request.json(loads=json_loads)
-    try:
-        data = schema(data)
-    except vol.Invalid as ex:
-        raise RuntimeError(humanize_error(data, ex)) from None
-
-    return data

hassio/api/utils.py

@@ -0,0 +1,95 @@
+"""Init file for Hass.io util for RESTful API."""
+import json
+import logging
+
+from aiohttp import web
+import voluptuous as vol
+from voluptuous.humanize import humanize_error
+
+from ..const import (
+    JSON_RESULT, JSON_DATA, JSON_MESSAGE, RESULT_OK, RESULT_ERROR,
+    CONTENT_TYPE_BINARY)
+from ..exceptions import HassioError, APIError, APIForbidden
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def json_loads(data):
+    """Extract json from string with support for '' and None."""
+    if not data:
+        return {}
+    try:
+        return json.loads(data)
+    except json.JSONDecodeError:
+        raise APIError("Invalid json")
+
+
+def api_process(method):
+    """Wrap function with true/false calls to rest api."""
+    async def wrap_api(api, *args, **kwargs):
+        """Return API information."""
+        try:
+            answer = await method(api, *args, **kwargs)
+        except (APIError, APIForbidden) as err:
+            return api_return_error(message=str(err))
+        except HassioError:
+            return api_return_error(message="Unknown Error, see logs")
+
+        if isinstance(answer, dict):
+            return api_return_ok(data=answer)
+        if isinstance(answer, web.Response):
+            return answer
+        elif isinstance(answer, bool) and not answer:
+            return api_return_error()
+        return api_return_ok()
+
+    return wrap_api
+
+
+def api_process_raw(content):
+    """Wrap content_type into function."""
+    def wrap_method(method):
+        """Wrap function with raw output to rest api."""
+        async def wrap_api(api, *args, **kwargs):
+            """Return api information."""
+            try:
+                msg_data = await method(api, *args, **kwargs)
+                msg_type = content
+            except (APIError, APIForbidden) as err:
+                msg_data = str(err).encode()
+                msg_type = CONTENT_TYPE_BINARY
+            except HassioError:
+                msg_data = b''
+                msg_type = CONTENT_TYPE_BINARY
+
+            return web.Response(body=msg_data, content_type=msg_type)
+
+        return wrap_api
+    return wrap_method
+
+
+def api_return_error(message=None):
+    """Return an API error message."""
+    return web.json_response({
+        JSON_RESULT: RESULT_ERROR,
+        JSON_MESSAGE: message,
+    }, status=400)
+
+
+def api_return_ok(data=None):
+    """Return an API ok answer."""
+    return web.json_response({
+        JSON_RESULT: RESULT_OK,
+        JSON_DATA: data or {},
+    })
+
+
+async def api_validate(schema, request):
+    """Validate request data with schema."""
+    data = await request.json(loads=json_loads)
+    try:
+        data = schema(data)
+    except vol.Invalid as ex:
+        raise APIError(humanize_error(data, ex)) from None
+
+    return data

hassio/arch.json

@@ -0,0 +1,49 @@
+{
+    "raspberrypi": [
+        "armhf"
+    ],
+    "raspberrypi2": [
+        "armv7",
+        "armhf"
+    ],
+    "raspberrypi3": [
+        "armv7",
+        "armhf"
+    ],
+    "raspberrypi3-64": [
+        "aarch64",
+        "armv7",
+        "armhf"
+    ],
+    "tinker": [
+        "armv7",
+        "armhf"
+    ],
+    "odroid-c2": [
+        "aarch64"
+    ],
+    "odroid-xu": [
+        "armv7",
+        "armhf"
+    ],
+    "orangepi-prime": [
+        "aarch64"
+    ],
+    "qemux86": [
+        "i386"
+    ],
+    "qemux86-64": [
+        "amd64",
+        "i386"
+    ],
+    "qemuarm": [
+        "armhf"
+    ],
+    "qemuarm-64": [
+        "aarch64"
+    ],
+    "intel-nuc": [
+        "amd64",
+        "i386"
+    ]
+}

hassio/arch.py

@@ -0,0 +1,65 @@
+"""Handle Arch for underlay maschine/platforms."""
+import logging
+from typing import List
+from pathlib import Path
+
+from .coresys import CoreSysAttributes, CoreSys
+from .exceptions import HassioArchNotFound, JsonFileError
+from .utils.json import read_json_file
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CpuArch(CoreSysAttributes):
+    """Manage available architectures."""
+
+    def __init__(self, coresys: CoreSys) -> None:
+        """Initialize CPU Architecture handler."""
+        self.coresys = coresys
+        self._supported_arch: List[str] = []
+        self._default_arch: str
+
+    @property
+    def default(self) -> str:
+        """Return system default arch."""
+        return self._default_arch
+
+    @property
+    def supervisor(self) -> str:
+        """Return supervisor arch."""
+        return self.sys_supervisor.arch
+
+    @property
+    def supported(self) -> List[str]:
+        """Return support arch by CPU/Machine."""
+        return self._supported_arch
+
+    async def load(self) -> None:
+        """Load data and initialize default arch."""
+        try:
+            arch_data = read_json_file(Path(__file__).parent.joinpath("arch.json"))
+        except JsonFileError:
+            _LOGGER.warning("Can't read arch json")
+            return
+
+        # Evaluate current CPU/Platform
+        if not self.sys_machine or self.sys_machine not in arch_data:
+            _LOGGER.warning("Can't detect underlay machine type!")
+            self._default_arch = self.sys_supervisor.arch
+            self._supported_arch.append(self.default)
+            return
+
+        # Use configs from arch.json
+        self._supported_arch.extend(arch_data[self.sys_machine])
+        self._default_arch = self.supported[0]
+
+    def is_supported(self, arch_list: List[str]) -> bool:
+        """Return True if there is a supported arch by this platform."""
+        return not set(self.supported).isdisjoint(set(arch_list))
+
+    def match(self, arch_list: List[str]) -> str:
+        """Return best match for this CPU/Platform."""
+        for self_arch in self.supported:
+            if self_arch in arch_list:
+                return self_arch
+        raise HassioArchNotFound()

hassio/auth.py

@@ -0,0 +1,95 @@
+"""Manage SSO for Add-ons with Home Assistant user."""
+import logging
+import hashlib
+
+from .const import (
+    FILE_HASSIO_AUTH, ATTR_PASSWORD, ATTR_USERNAME, ATTR_ADDON)
+from .coresys import CoreSysAttributes
+from .utils.json import JsonConfig
+from .validate import SCHEMA_AUTH_CONFIG
+from .exceptions import AuthError, HomeAssistantAPIError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Auth(JsonConfig, CoreSysAttributes):
+    """Manage SSO for Add-ons with Home Assistant user."""
+
+    def __init__(self, coresys):
+        """Initialize updater."""
+        super().__init__(FILE_HASSIO_AUTH, SCHEMA_AUTH_CONFIG)
+        self.coresys = coresys
+
+    def _check_cache(self, username, password):
+        """Check password in cache."""
+        username_h = _rehash(username)
+        password_h = _rehash(password, username)
+
+        if self._data.get(username_h) == password_h:
+            _LOGGER.info("Cache hit for %s", username)
+            return True
+
+        _LOGGER.warning("No cache hit for %s", username)
+        return False
+
+    def _update_cache(self, username, password):
+        """Cache a username, password."""
+        username_h = _rehash(username)
+        password_h = _rehash(password, username)
+
+        if self._data.get(username_h) == password_h:
+            return
+
+        self._data[username_h] = password_h
+        self.save_data()
+
+    def _dismatch_cache(self, username, password):
+        """Remove user from cache."""
+        username_h = _rehash(username)
+        password_h = _rehash(password, username)
+
+        if self._data.get(username_h) != password_h:
+            return
+
+        self._data.pop(username_h, None)
+        self.save_data()
+
+    async def check_login(self, addon, username, password):
+        """Check username login."""
+        if password is None:
+            _LOGGER.error("None as password is not supported!")
+            raise AuthError()
+        _LOGGER.info("Auth request from %s for %s", addon.slug, username)
+
+        # Check API state
+        if not await self.sys_homeassistant.check_api_state():
+            _LOGGER.info("Home Assistant not running, check cache")
+            return self._check_cache(username, password)
+
+        try:
+            async with self.sys_homeassistant.make_request(
+                    'post', 'api/hassio_auth', json={
+                        ATTR_USERNAME: username,
+                        ATTR_PASSWORD: password,
+                        ATTR_ADDON: addon.slug,
+                    }) as req:
+
+                if req.status == 200:
+                    _LOGGER.info("Success login from %s", username)
+                    self._update_cache(username, password)
+                    return True
+
+                _LOGGER.warning("Wrong login from %s", username)
+                self._dismatch_cache(username, password)
+                return False
+        except HomeAssistantAPIError:
+            _LOGGER.error("Can't request auth on Home Assistant!")
+
+        raise AuthError()
+
+
+def _rehash(value, salt2=""):
+    """Rehash a value."""
+    for idx in range(1, 20):
+        value = hashlib.sha256(f"{value}{idx}{salt2}".encode()).hexdigest()
+    return value

hassio/bootstrap.py

@@ -1,105 +1,208 @@
-"""Bootstrap HassIO."""
+"""Bootstrap Hass.io."""
 import logging
 import os
-import stat
+from pathlib import Path
+import shutil
 import signal
 
 from colorlog import ColoredFormatter
 
+from .addons import AddonManager
+from .api import RestAPI
+from .arch import CpuArch
+from .auth import Auth
 from .const import SOCKET_DOCKER
-from .config import CoreConfig
+from .core import HassIO
+from .coresys import CoreSys
+from .dbus import DBusManager
+from .discovery import Discovery
+from .hassos import HassOS
+from .homeassistant import HomeAssistant
+from .host import HostManager
+from .ingress import Ingress
+from .services import ServiceManager
+from .snapshots import SnapshotManager
+from .supervisor import Supervisor
+from .tasks import Tasks
+from .updater import Updater
 
 _LOGGER = logging.getLogger(__name__)
 
+ENV_SHARE = "SUPERVISOR_SHARE"
+ENV_NAME = "SUPERVISOR_NAME"
+ENV_REPO = "HOMEASSISTANT_REPOSITORY"
 
-def initialize_system_data(websession):
-    """Setup default config and create folders."""
-    config = CoreConfig(websession)
+MACHINE_ID = Path("/etc/machine-id")
 
-    # homeassistant config folder
-    if not os.path.isdir(config.path_config):
+
+async def initialize_coresys():
+    """Initialize HassIO coresys/objects."""
+    coresys = CoreSys()
+
+    # Initialize core objects
+    coresys.core = HassIO(coresys)
+    coresys.arch = CpuArch(coresys)
+    coresys.auth = Auth(coresys)
+    coresys.updater = Updater(coresys)
+    coresys.api = RestAPI(coresys)
+    coresys.supervisor = Supervisor(coresys)
+    coresys.homeassistant = HomeAssistant(coresys)
+    coresys.addons = AddonManager(coresys)
+    coresys.snapshots = SnapshotManager(coresys)
+    coresys.host = HostManager(coresys)
+    coresys.ingress = Ingress(coresys)
+    coresys.tasks = Tasks(coresys)
+    coresys.services = ServiceManager(coresys)
+    coresys.discovery = Discovery(coresys)
+    coresys.dbus = DBusManager(coresys)
+    coresys.hassos = HassOS(coresys)
+
+    # bootstrap config
+    initialize_system_data(coresys)
+
+    # Set Machine/Host ID
+    if MACHINE_ID.exists():
+        coresys.machine_id = MACHINE_ID.read_text().strip()
+
+    return coresys
+
+
+def initialize_system_data(coresys):
+    """Set up the default configuration and create folders."""
+    config = coresys.config
+
+    # Home Assistant configuration folder
+    if not config.path_homeassistant.is_dir():
         _LOGGER.info(
-            "Create Home-Assistant config folder %s", config.path_config)
-        os.mkdir(config.path_config)
+            "Create Home Assistant configuration folder %s", config.path_homeassistant
+        )
+        config.path_homeassistant.mkdir()
 
-    # homeassistant ssl folder
-    if not os.path.isdir(config.path_ssl):
-        _LOGGER.info("Create Home-Assistant ssl folder %s", config.path_ssl)
-        os.mkdir(config.path_ssl)
+    # hassio ssl folder
+    if not config.path_ssl.is_dir():
+        _LOGGER.info("Create Hass.io SSL/TLS folder %s", config.path_ssl)
+        config.path_ssl.mkdir()
 
-    # homeassistant addon data folder
-    if not os.path.isdir(config.path_addons_data):
-        _LOGGER.info("Create Home-Assistant addon data folder %s",
-                     config.path_addons_data)
-        os.mkdir(config.path_addons_data)
+    # hassio addon data folder
+    if not config.path_addons_data.is_dir():
+        _LOGGER.info("Create Hass.io Add-on data folder %s", config.path_addons_data)
+        config.path_addons_data.mkdir(parents=True)
 
-    if not os.path.isdir(config.path_addons_custom):
-        _LOGGER.info("Create Home-Assistant addon custom folder %s",
-                     config.path_addons_custom)
-        os.mkdir(config.path_addons_custom)
+    if not config.path_addons_local.is_dir():
+        _LOGGER.info(
+            "Create Hass.io Add-on local repository folder %s", config.path_addons_local
+        )
+        config.path_addons_local.mkdir(parents=True)
+
+    if not config.path_addons_git.is_dir():
+        _LOGGER.info(
+            "Create Hass.io Add-on git repositories folder %s", config.path_addons_git
+        )
+        config.path_addons_git.mkdir(parents=True)
+
+    # hassio tmp folder
+    if not config.path_tmp.is_dir():
+        _LOGGER.info("Create Hass.io temp folder %s", config.path_tmp)
+        config.path_tmp.mkdir(parents=True)
+
+    # hassio backup folder
+    if not config.path_backup.is_dir():
+        _LOGGER.info("Create Hass.io backup folder %s", config.path_backup)
+        config.path_backup.mkdir()
+
+    # share folder
+    if not config.path_share.is_dir():
+        _LOGGER.info("Create Hass.io share folder %s", config.path_share)
+        config.path_share.mkdir()
+
+    # apparmor folder
+    if not config.path_apparmor.is_dir():
+        _LOGGER.info("Create Hass.io Apparmor folder %s", config.path_apparmor)
+        config.path_apparmor.mkdir()
 
     return config
 
 
+def migrate_system_env(coresys):
+    """Cleanup some stuff after update."""
+    config = coresys.config
+
+    # 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 Add-on build directory")
+
+
 def initialize_logging():
     """Setup the logging."""
     logging.basicConfig(level=logging.INFO)
-    fmt = ("%(asctime)s %(levelname)s (%(threadName)s) "
-           "[%(name)s] %(message)s")
-    colorfmt = "%(log_color)s{}%(reset)s".format(fmt)
-    datefmt = '%y-%m-%d %H:%M:%S'
+    fmt = "%(asctime)s %(levelname)s (%(threadName)s) [%(name)s] %(message)s"
+    colorfmt = f"%(log_color)s{fmt}%(reset)s"
+    datefmt = "%y-%m-%d %H:%M:%S"
 
     # suppress overly verbose logs from libraries that aren't helpful
     logging.getLogger("aiohttp.access").setLevel(logging.WARNING)
 
-    logging.getLogger().handlers[0].setFormatter(ColoredFormatter(
-        colorfmt,
-        datefmt=datefmt,
-        reset=True,
-        log_colors={
-            'DEBUG': 'cyan',
-            'INFO': 'green',
-            'WARNING': 'yellow',
-            'ERROR': 'red',
-            'CRITICAL': 'red',
-        }
-    ))
+    logging.getLogger().handlers[0].setFormatter(
+        ColoredFormatter(
+            colorfmt,
+            datefmt=datefmt,
+            reset=True,
+            log_colors={
+                "DEBUG": "cyan",
+                "INFO": "green",
+                "WARNING": "yellow",
+                "ERROR": "red",
+                "CRITICAL": "red",
+            },
+        )
+    )
 
 
 def check_environment():
     """Check if all environment are exists."""
-    for key in ('SUPERVISOR_SHARE', 'SUPERVISOR_NAME',
-                'HOMEASSISTANT_REPOSITORY'):
+    # check environment variables
+    for key in (ENV_SHARE, ENV_NAME, ENV_REPO):
         try:
             os.environ[key]
         except KeyError:
             _LOGGER.fatal("Can't find %s in env!", key)
             return False
 
-    mode = os.stat(SOCKET_DOCKER)[stat.ST_MODE]
-    if not stat.S_ISSOCK(mode):
-        _LOGGER.fatal("Can't find docker socket!")
+    # check docker socket
+    if not SOCKET_DOCKER.is_socket():
+        _LOGGER.fatal("Can't find Docker socket!")
+        return False
+
+    # check socat exec
+    if not shutil.which("socat"):
+        _LOGGER.fatal("Can't find socat!")
+        return False
+
+    # check socat exec
+    if not shutil.which("gdbus"):
+        _LOGGER.fatal("Can't find gdbus!")
         return False
 
     return True
 
 
-def reg_signal(loop, hassio):
-    """Register SIGTERM, SIGKILL to stop system."""
+def reg_signal(loop):
+    """Register SIGTERM and SIGKILL to stop system."""
     try:
-        loop.add_signal_handler(
-            signal.SIGTERM, lambda: loop.create_task(hassio.stop()))
+        loop.add_signal_handler(signal.SIGTERM, lambda: loop.call_soon(loop.stop))
     except (ValueError, RuntimeError):
         _LOGGER.warning("Could not bind to SIGTERM")
 
     try:
-        loop.add_signal_handler(
-            signal.SIGHUP, lambda: loop.create_task(hassio.stop()))
+        loop.add_signal_handler(signal.SIGHUP, lambda: loop.call_soon(loop.stop))
     except (ValueError, RuntimeError):
         _LOGGER.warning("Could not bind to SIGHUP")
 
     try:
-        loop.add_signal_handler(
-            signal.SIGINT, lambda: loop.create_task(hassio.stop()))
+        loop.add_signal_handler(signal.SIGINT, lambda: loop.call_soon(loop.stop))
     except (ValueError, RuntimeError):
         _LOGGER.warning("Could not bind to SIGINT")

hassio/config.py

@@ -1,175 +1,206 @@
-"""Bootstrap HassIO."""
+"""Bootstrap Hass.io."""
+from datetime import datetime
 import logging
 import os
+import re
+from pathlib import Path, PurePath
 
-from .const import FILE_HASSIO_CONFIG, HASSIO_SHARE
-from .tools import (
-    fetch_current_versions, write_json_file, read_json_file)
+import pytz
+
+from .const import (
+    FILE_HASSIO_CONFIG, HASSIO_DATA, ATTR_TIMEZONE, ATTR_ADDONS_CUSTOM_LIST,
+    ATTR_LAST_BOOT, ATTR_WAIT_BOOT)
+from .utils.dt import parse_datetime
+from .utils.json import JsonConfig
+from .validate import SCHEMA_HASSIO_CONFIG
 
 _LOGGER = logging.getLogger(__name__)
 
-HOMEASSISTANT_CONFIG = "{}/homeassistant"
-HOMEASSISTANT_IMAGE = 'homeassistant_image'
-HOMEASSISTANT_CURRENT = 'homeassistant_current'
+HOMEASSISTANT_CONFIG = PurePath('homeassistant')
 
-HASSIO_SSL = "{}/ssl"
-HASSIO_CURRENT = 'hassio_current'
-HASSIO_CLEANUP = 'hassio_cleanup'
+HASSIO_SSL = PurePath("ssl")
 
-ADDONS_REPO = "{}/addons"
-ADDONS_DATA = "{}/addons_data"
-ADDONS_CUSTOM = "{}/addons_custom"
+ADDONS_CORE = PurePath("addons/core")
+ADDONS_LOCAL = PurePath("addons/local")
+ADDONS_GIT = PurePath("addons/git")
+ADDONS_DATA = PurePath("addons/data")
 
-UPSTREAM_BETA = 'upstream_beta'
+BACKUP_DATA = PurePath("backup")
+SHARE_DATA = PurePath("share")
+TMP_DATA = PurePath("tmp")
+APPARMOR_DATA = PurePath("apparmor")
 
-API_ENDPOINT = 'api_endpoint'
+DEFAULT_BOOT_TIME = datetime.utcfromtimestamp(0).isoformat()
+
+RE_TIMEZONE = re.compile(r"time_zone: (?P<timezone>[\w/\-+]+)")
 
 
-class Config(object):
-    """Hold all config data."""
-
-    def __init__(self, config_file):
-        """Initialize config object."""
-        self._filename = config_file
-        self._data = {}
-
-        # init or load data
-        if os.path.isfile(self._filename):
-            try:
-                self._data = read_json_file(self._filename)
-            except OSError:
-                _LOGGER.warning("Can't read %s", self._filename)
-
-    def save(self):
-        """Store data to config file."""
-        if not write_json_file(self._filename, self._data):
-            _LOGGER.exception("Can't store config in %s", self._filename)
-            return False
-        return True
-
-
-class CoreConfig(Config):
+class CoreConfig(JsonConfig):
     """Hold all core config data."""
 
-    def __init__(self, websession):
+    def __init__(self):
         """Initialize config object."""
-        self.websession = websession
-
-        super().__init__(FILE_HASSIO_CONFIG)
-
-        # init data
-        if not self._data:
-            self._data.update({
-                HOMEASSISTANT_IMAGE: os.environ['HOMEASSISTANT_REPOSITORY'],
-                UPSTREAM_BETA: False,
-            })
-            self.save()
-
-    async def fetch_update_infos(self):
-        """Read current versions from web."""
-        current = await fetch_current_versions(
-            self.websession, beta=self.upstream_beta)
-
-        if current:
-            self._data.update({
-                HOMEASSISTANT_CURRENT: current.get('homeassistant_tag'),
-                HASSIO_CURRENT: current.get('hassio_tag'),
-            })
-            self.save()
-            return True
-
-        return False
+        super().__init__(FILE_HASSIO_CONFIG, SCHEMA_HASSIO_CONFIG)
 
     @property
-    def api_endpoint(self):
-        """Return IP address of api endpoint."""
-        return self._data[API_ENDPOINT]
+    def timezone(self):
+        """Return system timezone."""
+        config_file = Path(self.path_homeassistant, 'configuration.yaml')
+        try:
+            assert config_file.exists()
+            configuration = config_file.read_text()
 
-    @api_endpoint.setter
-    def api_endpoint(self, value):
-        """Store IP address of api endpoint."""
-        self._data[API_ENDPOINT] = value
+            data = RE_TIMEZONE.search(configuration)
+            assert data
+
+            timezone = data.group('timezone')
+            pytz.timezone(timezone)
+        except (pytz.exceptions.UnknownTimeZoneError, OSError, AssertionError):
+            _LOGGER.debug("Can't parse Home Assistant timezone")
+            return self._data[ATTR_TIMEZONE]
+
+        return timezone
+
+    @timezone.setter
+    def timezone(self, value):
+        """Set system timezone."""
+        self._data[ATTR_TIMEZONE] = value
 
     @property
-    def upstream_beta(self):
-        """Return True if we run in beta upstream."""
-        return self._data.get(UPSTREAM_BETA, False)
+    def wait_boot(self):
+        """Return wait time for auto boot stages."""
+        return self._data[ATTR_WAIT_BOOT]
 
-    @upstream_beta.setter
-    def upstream_beta(self, value):
-        """Set beta upstream mode."""
-        self._data[UPSTREAM_BETA] = bool(value)
+    @wait_boot.setter
+    def wait_boot(self, value):
+        """Set wait boot time."""
+        self._data[ATTR_WAIT_BOOT] = value
 
     @property
-    def hassio_cleanup(self):
-        """Return Version they need to cleanup."""
-        return self._data.get(HASSIO_CLEANUP)
+    def last_boot(self):
+        """Return last boot datetime."""
+        boot_str = self._data.get(ATTR_LAST_BOOT, DEFAULT_BOOT_TIME)
 
-    @hassio_cleanup.setter
-    def hassio_cleanup(self, version):
-        """Set or remove cleanup flag."""
-        if version is None:
-            self._data.pop(HASSIO_CLEANUP, None)
-        else:
-            self._data[HASSIO_CLEANUP] = version
-        self.save()
+        boot_time = parse_datetime(boot_str)
+        if not boot_time:
+            return datetime.utcfromtimestamp(1)
+        return boot_time
+
+    @last_boot.setter
+    def last_boot(self, value):
+        """Set last boot datetime."""
+        self._data[ATTR_LAST_BOOT] = value.isoformat()
 
     @property
-    def homeassistant_image(self):
-        """Return docker homeassistant repository."""
-        return self._data.get(HOMEASSISTANT_IMAGE)
+    def path_hassio(self):
+        """Return Hass.io data path."""
+        return HASSIO_DATA
 
     @property
-    def current_homeassistant(self):
-        """Actual version of homeassistant."""
-        return self._data.get(HOMEASSISTANT_CURRENT)
+    def path_extern_hassio(self):
+        """Return Hass.io data path external for Docker."""
+        return PurePath(os.environ['SUPERVISOR_SHARE'])
 
     @property
-    def current_hassio(self):
-        """Actual version of hassio."""
-        return self._data.get(HASSIO_CURRENT)
+    def path_extern_homeassistant(self):
+        """Return config path external for Docker."""
+        return str(PurePath(self.path_extern_hassio, HOMEASSISTANT_CONFIG))
 
     @property
-    def path_hassio_docker(self):
-        """Return hassio data path extern for docker."""
-        return os.environ['SUPERVISOR_SHARE']
-
-    @property
-    def path_config_docker(self):
-        """Return config path extern for docker."""
-        return HOMEASSISTANT_CONFIG.format(self.path_hassio_docker)
-
-    @property
-    def path_config(self):
+    def path_homeassistant(self):
         """Return config path inside supervisor."""
-        return HOMEASSISTANT_CONFIG.format(HASSIO_SHARE)
+        return Path(HASSIO_DATA, HOMEASSISTANT_CONFIG)
 
     @property
-    def path_ssl_docker(self):
-        """Return SSL path extern for docker."""
-        return HASSIO_SSL.format(self.path_hassio_docker)
+    def path_extern_ssl(self):
+        """Return SSL path external for Docker."""
+        return str(PurePath(self.path_extern_hassio, HASSIO_SSL))
 
     @property
     def path_ssl(self):
         """Return SSL path inside supervisor."""
-        return HASSIO_SSL.format(HASSIO_SHARE)
+        return Path(HASSIO_DATA, HASSIO_SSL)
 
     @property
-    def path_addons_repo(self):
-        """Return git repo path for addons."""
-        return ADDONS_REPO.format(HASSIO_SHARE)
+    def path_addons_core(self):
+        """Return git path for core Add-ons."""
+        return Path(HASSIO_DATA, ADDONS_CORE)
 
     @property
-    def path_addons_custom(self):
-        """Return path for customs addons."""
-        return ADDONS_CUSTOM.format(HASSIO_SHARE)
+    def path_addons_git(self):
+        """Return path for Git Add-on."""
+        return Path(HASSIO_DATA, ADDONS_GIT)
+
+    @property
+    def path_addons_local(self):
+        """Return path for custom Add-ons."""
+        return Path(HASSIO_DATA, ADDONS_LOCAL)
+
+    @property
+    def path_extern_addons_local(self):
+        """Return path for custom Add-ons."""
+        return PurePath(self.path_extern_hassio, ADDONS_LOCAL)
 
     @property
     def path_addons_data(self):
-        """Return root addon data folder."""
-        return ADDONS_DATA.format(HASSIO_SHARE)
+        """Return root Add-on data folder."""
+        return Path(HASSIO_DATA, ADDONS_DATA)
 
     @property
-    def path_addons_data_docker(self):
-        """Return root addon data folder extern for docker."""
-        return ADDONS_DATA.format(self.path_hassio_docker)
+    def path_extern_addons_data(self):
+        """Return root add-on data folder external for Docker."""
+        return PurePath(self.path_extern_hassio, ADDONS_DATA)
+
+    @property
+    def path_tmp(self):
+        """Return Hass.io temp folder."""
+        return Path(HASSIO_DATA, TMP_DATA)
+
+    @property
+    def path_extern_tmp(self):
+        """Return Hass.io temp folder for Docker."""
+        return PurePath(self.path_extern_hassio, TMP_DATA)
+
+    @property
+    def path_backup(self):
+        """Return root backup data folder."""
+        return Path(HASSIO_DATA, BACKUP_DATA)
+
+    @property
+    def path_extern_backup(self):
+        """Return root backup data folder external for Docker."""
+        return PurePath(self.path_extern_hassio, BACKUP_DATA)
+
+    @property
+    def path_share(self):
+        """Return root share data folder."""
+        return Path(HASSIO_DATA, SHARE_DATA)
+
+    @property
+    def path_apparmor(self):
+        """Return root Apparmor profile folder."""
+        return Path(HASSIO_DATA, APPARMOR_DATA)
+
+    @property
+    def path_extern_share(self):
+        """Return root share data folder external for Docker."""
+        return PurePath(self.path_extern_hassio, SHARE_DATA)
+
+    @property
+    def addons_repositories(self):
+        """Return list of custom Add-on repositories."""
+        return self._data[ATTR_ADDONS_CUSTOM_LIST]
+
+    def add_addon_repository(self, repo):
+        """Add a custom repository to list."""
+        if repo in self._data[ATTR_ADDONS_CUSTOM_LIST]:
+            return
+
+        self._data[ATTR_ADDONS_CUSTOM_LIST].append(repo)
+
+    def drop_addon_repository(self, repo):
+        """Remove a custom repository from list."""
+        if repo not in self._data[ATTR_ADDONS_CUSTOM_LIST]:
+            return
+
+        self._data[ATTR_ADDONS_CUSTOM_LIST].remove(repo)

hassio/const.py

@@ -1,61 +1,302 @@
-"""Const file for HassIO."""
-HASSIO_VERSION = '0.13'
+"""Constants file for Hass.io."""
+from pathlib import Path
+from ipaddress import ip_network
 
-URL_HASSIO_VERSION = \
-    'https://raw.githubusercontent.com/pvizeli/hassio/master/version.json'
-URL_HASSIO_VERSION_BETA = \
-    'https://raw.githubusercontent.com/pvizeli/hassio/master/version_beta.json'
 
-URL_HASSIO_ADDONS = 'https://github.com/pvizeli/hassio-addons'
+HASSIO_VERSION = "156"
 
-DOCKER_REPO = "pvizeli"
+URL_HASSIO_ADDONS = "https://github.com/home-assistant/hassio-addons"
+URL_HASSIO_VERSION = "https://s3.amazonaws.com/hassio-version/{channel}.json"
+URL_HASSIO_APPARMOR = "https://s3.amazonaws.com/hassio-version/apparmor.txt"
 
-HASSIO_SHARE = "/data"
+URL_HASSOS_OTA = (
+    "https://github.com/home-assistant/hassos/releases/download/"
+    "{version}/hassos_{board}-{version}.raucb"
+)
 
-RUN_UPDATE_INFO_TASKS = 28800
-RUN_UPDATE_SUPERVISOR_TASKS = 29100
-RUN_RELOAD_ADDONS_TASKS = 28800
+HASSIO_DATA = Path("/data")
 
-RESTART_EXIT_CODE = 100
+FILE_HASSIO_AUTH = Path(HASSIO_DATA, "auth.json")
+FILE_HASSIO_ADDONS = Path(HASSIO_DATA, "addons.json")
+FILE_HASSIO_CONFIG = Path(HASSIO_DATA, "config.json")
+FILE_HASSIO_HOMEASSISTANT = Path(HASSIO_DATA, "homeassistant.json")
+FILE_HASSIO_UPDATER = Path(HASSIO_DATA, "updater.json")
+FILE_HASSIO_SERVICES = Path(HASSIO_DATA, "services.json")
+FILE_HASSIO_DISCOVERY = Path(HASSIO_DATA, "discovery.json")
+FILE_HASSIO_INGRESS = Path(HASSIO_DATA, "ingress.json")
 
-FILE_HASSIO_ADDONS = "{}/addons.json".format(HASSIO_SHARE)
-FILE_HASSIO_CONFIG = "{}/config.json".format(HASSIO_SHARE)
+SOCKET_DOCKER = Path("/var/run/docker.sock")
 
-SOCKET_DOCKER = "/var/run/docker.sock"
-SOCKET_HC = "/var/run/hassio-hc.sock"
+DOCKER_NETWORK = "hassio"
+DOCKER_NETWORK_MASK = ip_network("172.30.32.0/23")
+DOCKER_NETWORK_RANGE = ip_network("172.30.33.0/24")
 
-JSON_RESULT = 'result'
-JSON_DATA = 'data'
-JSON_MESSAGE = 'message'
+LABEL_VERSION = "io.hass.version"
+LABEL_ARCH = "io.hass.arch"
+LABEL_TYPE = "io.hass.type"
+LABEL_MACHINE = "io.hass.machine"
 
-RESULT_ERROR = 'error'
-RESULT_OK = 'ok'
+META_ADDON = "addon"
+META_SUPERVISOR = "supervisor"
+META_HOMEASSISTANT = "homeassistant"
 
-ATTR_ADDONS = 'addons'
-ATTR_VERSION = 'version'
-ATTR_CURRENT = 'current'
-ATTR_BETA = 'beta'
-ATTR_NAME = 'name'
-ATTR_SLUG = 'slug'
-ATTR_DESCRIPTON = 'description'
-ATTR_STARTUP = 'startup'
-ATTR_BOOT = 'boot'
-ATTR_PORTS = 'ports'
-ATTR_MAP_CONFIG = 'map_config'
-ATTR_MAP_SSL = 'map_ssl'
-ATTR_OPTIONS = 'options'
-ATTR_INSTALLED = 'installed'
-ATTR_DEDICATED = 'dedicated'
-ATTR_STATE = 'state'
-ATTR_SCHEMA = 'schema'
-ATTR_IMAGE = 'image'
+JSON_RESULT = "result"
+JSON_DATA = "data"
+JSON_MESSAGE = "message"
 
-STARTUP_BEFORE = 'before'
-STARTUP_AFTER = 'after'
-STARTUP_ONCE = 'once'
+RESULT_ERROR = "error"
+RESULT_OK = "ok"
 
-BOOT_AUTO = 'auto'
-BOOT_MANUAL = 'manual'
+CONTENT_TYPE_BINARY = "application/octet-stream"
+CONTENT_TYPE_PNG = "image/png"
+CONTENT_TYPE_JSON = "application/json"
+CONTENT_TYPE_TEXT = "text/plain"
+CONTENT_TYPE_TAR = "application/tar"
+CONTENT_TYPE_URL = "application/x-www-form-urlencoded"
+HEADER_HA_ACCESS = "X-Ha-Access"
+HEADER_TOKEN = "X-Hassio-Key"
+COOKIE_INGRESS = "ingress_session"
 
-STATE_STARTED = 'started'
-STATE_STOPPED = 'stopped'
+ENV_TOKEN = "HASSIO_TOKEN"
+ENV_TIME = "TZ"
+
+REQUEST_FROM = "HASSIO_FROM"
+
+ATTR_MACHINE = "machine"
+ATTR_WAIT_BOOT = "wait_boot"
+ATTR_DEPLOYMENT = "deployment"
+ATTR_WATCHDOG = "watchdog"
+ATTR_CHANGELOG = "changelog"
+ATTR_DATE = "date"
+ATTR_ARCH = "arch"
+ATTR_LONG_DESCRIPTION = "long_description"
+ATTR_HOSTNAME = "hostname"
+ATTR_TIMEZONE = "timezone"
+ATTR_ARGS = "args"
+ATTR_OPERATING_SYSTEM = "operating_system"
+ATTR_CHASSIS = "chassis"
+ATTR_TYPE = "type"
+ATTR_SOURCE = "source"
+ATTR_FEATURES = "features"
+ATTR_ADDONS = "addons"
+ATTR_PROVIDERS = "providers"
+ATTR_VERSION = "version"
+ATTR_VERSION_LATEST = "version_latest"
+ATTR_AUTO_UART = "auto_uart"
+ATTR_LAST_BOOT = "last_boot"
+ATTR_LAST_VERSION = "last_version"
+ATTR_CHANNEL = "channel"
+ATTR_NAME = "name"
+ATTR_SLUG = "slug"
+ATTR_DESCRIPTON = "description"
+ATTR_STARTUP = "startup"
+ATTR_BOOT = "boot"
+ATTR_PORTS = "ports"
+ATTR_PORTS_DESCRIPTION = "ports_description"
+ATTR_PORT = "port"
+ATTR_SSL = "ssl"
+ATTR_MAP = "map"
+ATTR_WEBUI = "webui"
+ATTR_OPTIONS = "options"
+ATTR_INSTALLED = "installed"
+ATTR_DETACHED = "detached"
+ATTR_STATE = "state"
+ATTR_SCHEMA = "schema"
+ATTR_IMAGE = "image"
+ATTR_ICON = "icon"
+ATTR_LOGO = "logo"
+ATTR_STDIN = "stdin"
+ATTR_ADDONS_REPOSITORIES = "addons_repositories"
+ATTR_REPOSITORY = "repository"
+ATTR_REPOSITORIES = "repositories"
+ATTR_URL = "url"
+ATTR_MAINTAINER = "maintainer"
+ATTR_PASSWORD = "password"
+ATTR_TOTP = "totp"
+ATTR_INITIALIZE = "initialize"
+ATTR_LOCATON = "location"
+ATTR_BUILD = "build"
+ATTR_DEVICES = "devices"
+ATTR_ENVIRONMENT = "environment"
+ATTR_HOST_NETWORK = "host_network"
+ATTR_HOST_PID = "host_pid"
+ATTR_HOST_IPC = "host_ipc"
+ATTR_HOST_DBUS = "host_dbus"
+ATTR_NETWORK = "network"
+ATTR_NETWORK_DESCRIPTION = "network_description"
+ATTR_TMPFS = "tmpfs"
+ATTR_PRIVILEGED = "privileged"
+ATTR_USER = "user"
+ATTR_SYSTEM = "system"
+ATTR_SNAPSHOTS = "snapshots"
+ATTR_HOMEASSISTANT = "homeassistant"
+ATTR_HASSIO = "hassio"
+ATTR_HASSIO_API = "hassio_api"
+ATTR_HOMEASSISTANT_API = "homeassistant_api"
+ATTR_UUID = "uuid"
+ATTR_FOLDERS = "folders"
+ATTR_SIZE = "size"
+ATTR_TYPE = "type"
+ATTR_TIMEOUT = "timeout"
+ATTR_AUTO_UPDATE = "auto_update"
+ATTR_CUSTOM = "custom"
+ATTR_AUDIO = "audio"
+ATTR_AUDIO_INPUT = "audio_input"
+ATTR_AUDIO_OUTPUT = "audio_output"
+ATTR_INPUT = "input"
+ATTR_OUTPUT = "output"
+ATTR_DISK = "disk"
+ATTR_SERIAL = "serial"
+ATTR_SECURITY = "security"
+ATTR_BUILD_FROM = "build_from"
+ATTR_SQUASH = "squash"
+ATTR_GPIO = "gpio"
+ATTR_LEGACY = "legacy"
+ATTR_ADDONS_CUSTOM_LIST = "addons_custom_list"
+ATTR_CPU_PERCENT = "cpu_percent"
+ATTR_NETWORK_RX = "network_rx"
+ATTR_NETWORK_TX = "network_tx"
+ATTR_MEMORY_LIMIT = "memory_limit"
+ATTR_MEMORY_USAGE = "memory_usage"
+ATTR_BLK_READ = "blk_read"
+ATTR_BLK_WRITE = "blk_write"
+ATTR_ADDON = "addon"
+ATTR_AVAILABLE = "available"
+ATTR_HOST = "host"
+ATTR_USERNAME = "username"
+ATTR_DISCOVERY = "discovery"
+ATTR_CONFIG = "config"
+ATTR_SERVICES = "services"
+ATTR_SERVICE = "service"
+ATTR_DISCOVERY = "discovery"
+ATTR_PROTECTED = "protected"
+ATTR_CRYPTO = "crypto"
+ATTR_BRANCH = "branch"
+ATTR_KERNEL = "kernel"
+ATTR_APPARMOR = "apparmor"
+ATTR_DEVICETREE = "devicetree"
+ATTR_CPE = "cpe"
+ATTR_BOARD = "board"
+ATTR_HASSOS = "hassos"
+ATTR_HASSOS_CLI = "hassos_cli"
+ATTR_VERSION_CLI = "version_cli"
+ATTR_VERSION_CLI_LATEST = "version_cli_latest"
+ATTR_REFRESH_TOKEN = "refresh_token"
+ATTR_ACCESS_TOKEN = "access_token"
+ATTR_DOCKER_API = "docker_api"
+ATTR_FULL_ACCESS = "full_access"
+ATTR_PROTECTED = "protected"
+ATTR_RATING = "rating"
+ATTR_HASSIO_ROLE = "hassio_role"
+ATTR_SUPERVISOR = "supervisor"
+ATTR_AUTH_API = "auth_api"
+ATTR_KERNEL_MODULES = "kernel_modules"
+ATTR_SUPPORTED_ARCH = "supported_arch"
+ATTR_INGRESS = "ingress"
+ATTR_INGRESS_PORT = "ingress_port"
+ATTR_INGRESS_ENTRY = "ingress_entry"
+ATTR_INGRESS_TOKEN = "ingress_token"
+ATTR_INGRESS_URL = "ingress_url"
+ATTR_IP_ADDRESS = "ip_address"
+ATTR_SESSION = "session"
+
+PROVIDE_SERVICE = "provide"
+NEED_SERVICE = "need"
+WANT_SERVICE = "want"
+
+STARTUP_INITIALIZE = "initialize"
+STARTUP_SYSTEM = "system"
+STARTUP_SERVICES = "services"
+STARTUP_APPLICATION = "application"
+STARTUP_ONCE = "once"
+
+STARTUP_ALL = [
+    STARTUP_ONCE,
+    STARTUP_INITIALIZE,
+    STARTUP_SYSTEM,
+    STARTUP_SERVICES,
+    STARTUP_APPLICATION,
+]
+
+BOOT_AUTO = "auto"
+BOOT_MANUAL = "manual"
+
+STATE_STARTED = "started"
+STATE_STOPPED = "stopped"
+STATE_NONE = "none"
+
+MAP_CONFIG = "config"
+MAP_SSL = "ssl"
+MAP_ADDONS = "addons"
+MAP_BACKUP = "backup"
+MAP_SHARE = "share"
+
+ARCH_ARMHF = "armhf"
+ARCH_ARMV7 = "armv7"
+ARCH_AARCH64 = "aarch64"
+ARCH_AMD64 = "amd64"
+ARCH_I386 = "i386"
+
+ARCH_ALL = [ARCH_ARMHF, ARCH_ARMV7, ARCH_AARCH64, ARCH_AMD64, ARCH_I386]
+
+CHANNEL_STABLE = "stable"
+CHANNEL_BETA = "beta"
+CHANNEL_DEV = "dev"
+
+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"
+
+CRYPTO_AES128 = "aes128"
+
+SECURITY_PROFILE = "profile"
+SECURITY_DEFAULT = "default"
+SECURITY_DISABLE = "disable"
+
+PRIVILEGED_NET_ADMIN = "NET_ADMIN"
+PRIVILEGED_SYS_ADMIN = "SYS_ADMIN"
+PRIVILEGED_SYS_RAWIO = "SYS_RAWIO"
+PRIVILEGED_IPC_LOCK = "IPC_LOCK"
+PRIVILEGED_SYS_TIME = "SYS_TIME"
+PRIVILEGED_SYS_NICE = "SYS_NICE"
+PRIVILEGED_SYS_MODULE = "SYS_MODULE"
+PRIVILEGED_SYS_RESOURCE = "SYS_RESOURCE"
+PRIVILEGED_SYS_PTRACE = "SYS_PTRACE"
+PRIVILEGED_DAC_READ_SEARCH = "DAC_READ_SEARCH"
+
+PRIVILEGED_ALL = [
+    PRIVILEGED_NET_ADMIN,
+    PRIVILEGED_SYS_ADMIN,
+    PRIVILEGED_SYS_RAWIO,
+    PRIVILEGED_IPC_LOCK,
+    PRIVILEGED_SYS_TIME,
+    PRIVILEGED_SYS_NICE,
+    PRIVILEGED_SYS_RESOURCE,
+    PRIVILEGED_SYS_PTRACE,
+    PRIVILEGED_SYS_MODULE,
+    PRIVILEGED_DAC_READ_SEARCH,
+]
+
+FEATURES_SHUTDOWN = "shutdown"
+FEATURES_REBOOT = "reboot"
+FEATURES_HASSOS = "hassos"
+FEATURES_HOSTNAME = "hostname"
+FEATURES_SERVICES = "services"
+
+ROLE_DEFAULT = "default"
+ROLE_HOMEASSISTANT = "homeassistant"
+ROLE_BACKUP = "backup"
+ROLE_MANAGER = "manager"
+ROLE_ADMIN = "admin"
+
+ROLE_ALL = [ROLE_DEFAULT, ROLE_HOMEASSISTANT, ROLE_BACKUP, ROLE_MANAGER, ROLE_ADMIN]
+
+CHAN_ID = "chan_id"
+CHAN_TYPE = "chan_type"

hassio/core.py

@@ -1,152 +1,155 @@
-"""Main file for HassIO."""
+"""Main file for Hass.io."""
+from contextlib import suppress
 import asyncio
 import logging
 
-import aiohttp
-import docker
+import async_timeout
 
-from . import bootstrap
-from .addons import AddonManager
-from .api import RestAPI
-from .host_controll import HostControll
+from .coresys import CoreSysAttributes
 from .const import (
-    SOCKET_DOCKER, RUN_UPDATE_INFO_TASKS, RUN_RELOAD_ADDONS_TASKS,
-    RUN_UPDATE_SUPERVISOR_TASKS, STARTUP_AFTER, STARTUP_BEFORE)
-from .scheduler import Scheduler
-from .dock.homeassistant import DockerHomeAssistant
-from .dock.supervisor import DockerSupervisor
-from .tools import get_arch_from_image, get_local_ip
+    STARTUP_SYSTEM,
+    STARTUP_SERVICES,
+    STARTUP_APPLICATION,
+    STARTUP_INITIALIZE,
+)
+from .exceptions import HassioError, HomeAssistantError
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class HassIO(object):
-    """Main object of hassio."""
+class HassIO(CoreSysAttributes):
+    """Main object of Hass.io."""
 
-    def __init__(self, loop):
-        """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.dock = docker.DockerClient(
-            base_url="unix:/{}".format(SOCKET_DOCKER), version='auto')
-
-        # init basic docker container
-        self.supervisor = DockerSupervisor(
-            self.config, self.loop, self.dock, self)
-        self.homeassistant = DockerHomeAssistant(
-            self.config, self.loop, self.dock)
-
-        # init HostControll
-        self.host_controll = HostControll(self.loop)
-
-        # init addon system
-        self.addons = AddonManager(self.config, self.loop, self.dock)
+    def __init__(self, coresys):
+        """Initialize Hass.io object."""
+        self.coresys = coresys
 
     async def setup(self):
         """Setup HassIO orchestration."""
-        # supervisor
-        await self.supervisor.attach()
-        await self.supervisor.cleanup()
+        # Load Supervisor
+        await self.sys_supervisor.load()
 
-        # set api endpoint
-        self.config.api_endpoint = await get_local_ip(self.loop)
+        # Load DBus
+        await self.sys_dbus.load()
 
-        # hostcontroll
-        host_info = await self.host_controll.info()
-        if host_info:
-            self.host_controll.version = host_info.get('version')
-            _LOGGER.info(
-                "Connected to HostControll. OS: %s Version: %s Hostname: %s "
-                "Feature-lvl: %d", host_info.get('os'),
-                host_info.get('version'), host_info.get('hostname'),
-                host_info.get('level', 0))
+        # Load Host
+        await self.sys_host.load()
+
+        # Load Home Assistant
+        await self.sys_homeassistant.load()
+
+        # Load CPU/Arch
+        await self.sys_arch.load()
+
+        # Load HassOS
+        await self.sys_hassos.load()
+
+        # Load Add-ons
+        await self.sys_addons.load()
 
         # rest api views
-        self.api.register_host(self.host_controll)
-        self.api.register_network(self.host_controll)
-        self.api.register_supervisor(self.supervisor, self.addons)
-        self.api.register_homeassistant(self.homeassistant)
-        self.api.register_addons(self.addons)
+        await self.sys_api.load()
 
-        # schedule update info tasks
-        self.scheduler.register_task(
-            self.config.fetch_update_infos, RUN_UPDATE_INFO_TASKS,
-            now=True)
+        # load last available data
+        await self.sys_updater.load()
 
-        # first start of supervisor?
-        if not await self.homeassistant.exists():
-            _LOGGER.info("No HomeAssistant docker found.")
-            await self._setup_homeassistant()
+        # load last available data
+        await self.sys_snapshots.load()
 
-        # Load addons
-        arch = get_arch_from_image(self.supervisor.image)
-        await self.addons.prepare(arch)
+        # load services
+        await self.sys_services.load()
 
-        # schedule addon update task
-        self.scheduler.register_task(
-            self.addons.reload, RUN_RELOAD_ADDONS_TASKS, now=True)
+        # Load discovery
+        await self.sys_discovery.load()
 
-        # schedule self update task
-        self.scheduler.register_task(
-            self._hassio_update, RUN_UPDATE_SUPERVISOR_TASKS)
+        # Load ingress
+        await self.sys_ingress.load()
+
+        # start dns forwarding
+        self.sys_create_task(self.sys_dns.start())
 
     async def start(self):
-        """Start HassIO orchestration."""
+        """Start Hass.io orchestration."""
+        # on release channel, try update itself
+        if self.sys_supervisor.need_update:
+            if self.sys_dev:
+                _LOGGER.warning("Ignore Hass.io updates on dev!")
+            elif await self.sys_supervisor.update():
+                return
+
         # start api
-        await self.api.start()
-        _LOGGER.info("Start hassio api on %s", self.config.api_endpoint)
+        await self.sys_api.start()
 
-        # HomeAssistant is already running / supervisor have only reboot
-        if await self.homeassistant.is_running():
-            _LOGGER.info("HassIO reboot detected")
-            return
+        # start addon mark as initialize
+        await self.sys_addons.boot(STARTUP_INITIALIZE)
 
-        # start addon mark as before
-        await self.addons.auto_boot(STARTUP_BEFORE)
+        try:
+            # HomeAssistant is already running / supervisor have only reboot
+            if self.sys_hardware.last_boot == self.sys_config.last_boot:
+                _LOGGER.info("Hass.io reboot detected")
+                return
 
-        # run HomeAssistant
-        await self.homeassistant.run()
+            # reset register services / discovery
+            self.sys_services.reset()
 
-        # start addon mark as after
-        await self.addons.auto_boot(STARTUP_AFTER)
+            # start addon mark as system
+            await self.sys_addons.boot(STARTUP_SYSTEM)
 
-    async def stop(self, exit_code=0):
+            # start addon mark as services
+            await self.sys_addons.boot(STARTUP_SERVICES)
+
+            # run HomeAssistant
+            if self.sys_homeassistant.boot:
+                with suppress(HomeAssistantError):
+                    await self.sys_homeassistant.start()
+
+            # start addon mark as application
+            await self.sys_addons.boot(STARTUP_APPLICATION)
+
+            # store new last boot
+            self.sys_config.last_boot = self.sys_hardware.last_boot
+            self.sys_config.save_data()
+
+        finally:
+            # Add core tasks into scheduler
+            await self.sys_tasks.load()
+
+            # If landingpage / run upgrade in background
+            if self.sys_homeassistant.version == "landingpage":
+                self.sys_create_task(self.sys_homeassistant.install())
+
+            _LOGGER.info("Hass.io is up and running")
+
+    async def stop(self):
         """Stop a running orchestration."""
         # don't process scheduler anymore
-        self.scheduler.stop()
+        self.sys_scheduler.suspend = True
 
-        # process stop task pararell
-        tasks = [self.websession.close(), self.api.stop()]
-        await asyncio.wait(tasks, loop=self.loop)
+        # process async stop tasks
+        try:
+            with async_timeout.timeout(10):
+                await asyncio.wait(
+                    [
+                        self.sys_api.stop(),
+                        self.sys_dns.stop(),
+                        self.sys_websession.close(),
+                        self.sys_websession_ssl.close(),
+                        self.sys_ingress.unload(),
+                    ]
+                )
+        except asyncio.TimeoutError:
+            _LOGGER.warning("Force Shutdown!")
 
-        self.exit_code = exit_code
-        self.loop.stop()
+        _LOGGER.info("Hass.io is down")
 
-    async def _setup_homeassistant(self):
-        """Install a homeassistant docker container."""
-        while True:
-            # read homeassistant tag and install it
-            if not self.config.current_homeassistant:
-                await self.config.fetch_update_infos()
+    async def shutdown(self):
+        """Shutdown all running containers in correct order."""
+        await self.sys_addons.shutdown(STARTUP_APPLICATION)
 
-            tag = self.config.current_homeassistant
-            if tag and await self.homeassistant.install(tag):
-                break
-            _LOGGER.warning("Error on setup HomeAssistant. Retry in 60.")
-            await asyncio.sleep(60, loop=self.loop)
+        # Close Home Assistant
+        with suppress(HassioError):
+            await self.sys_homeassistant.stop()
 
-        # store version
-        _LOGGER.info("HomeAssistant docker now installed.")
-
-    async def _hassio_update(self):
-        """Check and run update of supervisor hassio."""
-        if self.config.current_hassio == self.supervisor.version:
-            return
-
-        _LOGGER.info(
-            "Found new HassIO version %s.", self.config.current_hassio)
-        await self.supervisor.update(self.config.current_hassio)
+        await self.sys_addons.shutdown(STARTUP_SERVICES)
+        await self.sys_addons.shutdown(STARTUP_SYSTEM)
+        await self.sys_addons.shutdown(STARTUP_INITIALIZE)

hassio/coresys.py

@@ -0,0 +1,474 @@
+"""Handle core shared data."""
+from __future__ import annotations
+import asyncio
+from typing import TYPE_CHECKING
+
+import aiohttp
+
+from .config import CoreConfig
+from .const import CHANNEL_DEV
+from .docker import DockerAPI
+from .misc.dns import DNSForward
+from .misc.hardware import Hardware
+from .misc.scheduler import Scheduler
+
+if TYPE_CHECKING:
+    from .addons import AddonManager
+    from .api import RestAPI
+    from .arch import CpuArch
+    from .auth import Auth
+    from .core import HassIO
+    from .dbus import DBusManager
+    from .discovery import Discovery
+    from .hassos import HassOS
+    from .homeassistant import HomeAssistant
+    from .host import HostManager
+    from .ingress import Ingress
+    from .services import ServiceManager
+    from .snapshots import SnapshotManager
+    from .supervisor import Supervisor
+    from .tasks import Tasks
+    from .updater import Updater
+
+
+class CoreSys:
+    """Class that handle all shared data."""
+
+    def __init__(self):
+        """Initialize coresys."""
+        # Static attributes
+        self.machine_id: str = None
+
+        # External objects
+        self._loop: asyncio.BaseEventLoop = asyncio.get_running_loop()
+        self._websession: aiohttp.ClientSession = aiohttp.ClientSession()
+        self._websession_ssl: aiohttp.ClientSession = aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(ssl=False))
+
+        # Global objects
+        self._config: CoreConfig = CoreConfig()
+        self._hardware: Hardware = Hardware()
+        self._docker: DockerAPI = DockerAPI()
+        self._scheduler: Scheduler = Scheduler()
+        self._dns: DNSForward = DNSForward()
+
+        # Internal objects pointers
+        self._core: HassIO = None
+        self._arch: CpuArch = None
+        self._auth: Auth = None
+        self._homeassistant: HomeAssistant = None
+        self._supervisor: Supervisor = None
+        self._addons: AddonManager = None
+        self._api: RestAPI = None
+        self._updater: Updater = None
+        self._snapshots: SnapshotManager = None
+        self._tasks: Tasks = None
+        self._host: HostManager = None
+        self._ingress: Ingress = None
+        self._dbus: DBusManager = None
+        self._hassos: HassOS = None
+        self._services: ServiceManager = None
+        self._discovery: Discovery = None
+
+    @property
+    def machine(self) -> str:
+        """Return running machine type of the Hass.io system."""
+        if self._homeassistant:
+            return self._homeassistant.machine
+        return None
+
+    @property
+    def dev(self) -> str:
+        """Return True if we run dev mode."""
+        return self._updater.channel == CHANNEL_DEV
+
+    @property
+    def timezone(self) -> str:
+        """Return timezone."""
+        return self._config.timezone
+
+    @property
+    def loop(self) -> asyncio.BaseEventLoop:
+        """Return loop object."""
+        return self._loop
+
+    @property
+    def websession(self) -> aiohttp.ClientSession:
+        """Return websession object."""
+        return self._websession
+
+    @property
+    def websession_ssl(self) -> aiohttp.ClientSession:
+        """Return websession object with disabled SSL."""
+        return self._websession_ssl
+
+    @property
+    def config(self) -> CoreConfig:
+        """Return CoreConfig object."""
+        return self._config
+
+    @property
+    def hardware(self) -> Hardware:
+        """Return Hardware object."""
+        return self._hardware
+
+    @property
+    def docker(self) -> DockerAPI:
+        """Return DockerAPI object."""
+        return self._docker
+
+    @property
+    def scheduler(self) -> Scheduler:
+        """Return Scheduler object."""
+        return self._scheduler
+
+    @property
+    def dns(self) -> DNSForward:
+        """Return DNSForward object."""
+        return self._dns
+
+    @property
+    def core(self) -> HassIO:
+        """Return HassIO object."""
+        return self._core
+
+    @core.setter
+    def core(self, value: HassIO):
+        """Set a Hass.io object."""
+        if self._core:
+            raise RuntimeError("Hass.io already set!")
+        self._core = value
+
+    @property
+    def arch(self) -> CpuArch:
+        """Return CpuArch object."""
+        return self._arch
+
+    @arch.setter
+    def arch(self, value: CpuArch):
+        """Set a CpuArch object."""
+        if self._arch:
+            raise RuntimeError("CpuArch already set!")
+        self._arch = value
+
+    @property
+    def auth(self) -> Auth:
+        """Return Auth object."""
+        return self._auth
+
+    @auth.setter
+    def auth(self, value: Auth):
+        """Set a Auth object."""
+        if self._auth:
+            raise RuntimeError("Auth already set!")
+        self._auth = value
+
+    @property
+    def homeassistant(self) -> HomeAssistant:
+        """Return Home Assistant object."""
+        return self._homeassistant
+
+    @homeassistant.setter
+    def homeassistant(self, value: HomeAssistant):
+        """Set a HomeAssistant object."""
+        if self._homeassistant:
+            raise RuntimeError("Home Assistant already set!")
+        self._homeassistant = value
+
+    @property
+    def supervisor(self) -> Supervisor:
+        """Return Supervisor object."""
+        return self._supervisor
+
+    @supervisor.setter
+    def supervisor(self, value: Supervisor):
+        """Set a Supervisor object."""
+        if self._supervisor:
+            raise RuntimeError("Supervisor already set!")
+        self._supervisor = value
+
+    @property
+    def api(self) -> RestAPI:
+        """Return API object."""
+        return self._api
+
+    @api.setter
+    def api(self, value: RestAPI):
+        """Set an API object."""
+        if self._api:
+            raise RuntimeError("API already set!")
+        self._api = value
+
+    @property
+    def updater(self) -> Updater:
+        """Return Updater object."""
+        return self._updater
+
+    @updater.setter
+    def updater(self, value: Updater):
+        """Set a Updater object."""
+        if self._updater:
+            raise RuntimeError("Updater already set!")
+        self._updater = value
+
+    @property
+    def addons(self) -> AddonManager:
+        """Return AddonManager object."""
+        return self._addons
+
+    @addons.setter
+    def addons(self, value: AddonManager):
+        """Set a AddonManager object."""
+        if self._addons:
+            raise RuntimeError("AddonManager already set!")
+        self._addons = value
+
+    @property
+    def snapshots(self) -> SnapshotManager:
+        """Return SnapshotManager object."""
+        return self._snapshots
+
+    @snapshots.setter
+    def snapshots(self, value: SnapshotManager):
+        """Set a SnapshotManager object."""
+        if self._snapshots:
+            raise RuntimeError("SnapshotsManager already set!")
+        self._snapshots = value
+
+    @property
+    def tasks(self) -> Tasks:
+        """Return Tasks object."""
+        return self._tasks
+
+    @tasks.setter
+    def tasks(self, value: Tasks):
+        """Set a Tasks object."""
+        if self._tasks:
+            raise RuntimeError("Tasks already set!")
+        self._tasks = value
+
+    @property
+    def services(self) -> ServiceManager:
+        """Return ServiceManager object."""
+        return self._services
+
+    @services.setter
+    def services(self, value: ServiceManager):
+        """Set a ServiceManager object."""
+        if self._services:
+            raise RuntimeError("Services already set!")
+        self._services = value
+
+    @property
+    def discovery(self) -> Discovery:
+        """Return ServiceManager object."""
+        return self._discovery
+
+    @discovery.setter
+    def discovery(self, value: Discovery):
+        """Set a Discovery object."""
+        if self._discovery:
+            raise RuntimeError("Discovery already set!")
+        self._discovery = value
+
+    @property
+    def dbus(self) -> DBusManager:
+        """Return DBusManager object."""
+        return self._dbus
+
+    @dbus.setter
+    def dbus(self, value: DBusManager):
+        """Set a DBusManager object."""
+        if self._dbus:
+            raise RuntimeError("DBusManager already set!")
+        self._dbus = value
+
+    @property
+    def host(self) -> HostManager:
+        """Return HostManager object."""
+        return self._host
+
+    @host.setter
+    def host(self, value: HostManager):
+        """Set a HostManager object."""
+        if self._host:
+            raise RuntimeError("HostManager already set!")
+        self._host = value
+
+    @property
+    def ingress(self) -> Ingress:
+        """Return Ingress object."""
+        return self._ingress
+
+    @ingress.setter
+    def ingress(self, value: Ingress):
+        """Set a Ingress object."""
+        if self._ingress:
+            raise RuntimeError("Ingress already set!")
+        self._ingress = value
+
+    @property
+    def hassos(self) -> HassOS:
+        """Return HassOS object."""
+        return self._hassos
+
+    @hassos.setter
+    def hassos(self, value: HassOS):
+        """Set a HassOS object."""
+        if self._hassos:
+            raise RuntimeError("HassOS already set!")
+        self._hassos = value
+
+
+class CoreSysAttributes:
+    """Inheret basic CoreSysAttributes."""
+
+    coresys = None
+
+    @property
+    def sys_machine(self) -> str:
+        """Return running machine type of the Hass.io system."""
+        return self.coresys.machine
+
+    @property
+    def sys_dev(self) -> str:
+        """Return True if we run dev mode."""
+        return self.coresys.dev
+
+    @property
+    def sys_timezone(self) -> str:
+        """Return timezone."""
+        return self.coresys.timezone
+
+    @property
+    def sys_machine_id(self) -> str:
+        """Return timezone."""
+        return self.coresys.machine_id
+
+    @property
+    def sys_loop(self) -> asyncio.BaseEventLoop:
+        """Return loop object."""
+        return self.coresys.loop
+
+    @property
+    def sys_websession(self) -> aiohttp.ClientSession:
+        """Return websession object."""
+        return self.coresys.websession
+
+    @property
+    def sys_websession_ssl(self) -> aiohttp.ClientSession:
+        """Return websession object with disabled SSL."""
+        return self.coresys.websession_ssl
+
+    @property
+    def sys_config(self) -> CoreConfig:
+        """Return CoreConfig object."""
+        return self.coresys.config
+
+    @property
+    def sys_hardware(self) -> Hardware:
+        """Return Hardware object."""
+        return self.coresys.hardware
+
+    @property
+    def sys_docker(self) -> DockerAPI:
+        """Return DockerAPI object."""
+        return self.coresys.docker
+
+    @property
+    def sys_scheduler(self) -> Scheduler:
+        """Return Scheduler object."""
+        return self.coresys.scheduler
+
+    @property
+    def sys_dns(self) -> DNSForward:
+        """Return DNSForward object."""
+        return self.coresys.dns
+
+    @property
+    def sys_core(self) -> HassIO:
+        """Return HassIO object."""
+        return self.coresys.core
+
+    @property
+    def sys_arch(self) -> CpuArch:
+        """Return CpuArch object."""
+        return self.coresys.arch
+
+    @property
+    def sys_auth(self) -> Auth:
+        """Return Auth object."""
+        return self.coresys.auth
+
+    @property
+    def sys_homeassistant(self) -> HomeAssistant:
+        """Return Home Assistant object."""
+        return self.coresys.homeassistant
+
+    @property
+    def sys_supervisor(self) -> Supervisor:
+        """Return Supervisor object."""
+        return self.coresys.supervisor
+
+    @property
+    def sys_api(self) -> RestAPI:
+        """Return API object."""
+        return self.coresys.api
+
+    @property
+    def sys_updater(self) -> Updater:
+        """Return Updater object."""
+        return self.coresys.updater
+
+    @property
+    def sys_addons(self) -> AddonManager:
+        """Return AddonManager object."""
+        return self.coresys.addons
+
+    @property
+    def sys_snapshots(self) -> SnapshotManager:
+        """Return SnapshotManager object."""
+        return self.coresys.snapshots
+
+    @property
+    def sys_tasks(self) -> Tasks:
+        """Return Tasks object."""
+        return self.coresys.tasks
+
+    @property
+    def sys_services(self) -> ServiceManager:
+        """Return ServiceManager object."""
+        return self.coresys.services
+
+    @property
+    def sys_discovery(self) -> Discovery:
+        """Return ServiceManager object."""
+        return self.coresys.discovery
+
+    @property
+    def sys_dbus(self) -> DBusManager:
+        """Return DBusManager object."""
+        return self.coresys.dbus
+
+    @property
+    def sys_host(self) -> HostManager:
+        """Return HostManager object."""
+        return self.coresys.host
+
+    @property
+    def sys_ingress(self) -> Ingress:
+        """Return Ingress object."""
+        return self.coresys.ingress
+
+    @property
+    def sys_hassos(self) -> HassOS:
+        """Return HassOS object."""
+        return self.coresys.hassos
+
+    def sys_run_in_executor(self, funct, *args) -> asyncio.Future:
+        """Wrapper for executor pool."""
+        return self.sys_loop.run_in_executor(None, funct, *args)
+
+    def sys_create_task(self, coroutine) -> asyncio.Task:
+        """Wrapper for async task."""
+        return self.sys_loop.create_task(coroutine)

hassio/dbus/__init__.py

@@ -0,0 +1,39 @@
+"""D-Bus interface objects."""
+
+from .systemd import Systemd
+from .hostname import Hostname
+from .rauc import Rauc
+from ..coresys import CoreSysAttributes
+
+
+class DBusManager(CoreSysAttributes):
+    """A DBus Interface handler."""
+
+    def __init__(self, coresys):
+        """Initialize D-Bus interface."""
+        self.coresys = coresys
+
+        self._systemd = Systemd()
+        self._hostname = Hostname()
+        self._rauc = Rauc()
+
+    @property
+    def systemd(self):
+        """Return the systemd interface."""
+        return self._systemd
+
+    @property
+    def hostname(self):
+        """Return the hostname interface."""
+        return self._hostname
+
+    @property
+    def rauc(self):
+        """Return the rauc interface."""
+        return self._rauc
+
+    async def load(self):
+        """Connect interfaces to D-Bus."""
+        await self.systemd.connect()
+        await self.hostname.connect()
+        await self.rauc.connect()