Merge pull request #1079 from home-assistant/dev

Release 163

.dockerignore

@@ -7,3 +7,7 @@
 
 # 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/release-drafter.yml

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

.github/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

.gitignore

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

.gitmodules

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

.hadolint.yaml

@@ -0,0 +1,5 @@
+ignored:
+  - DL3018
+  - DL3006
+  - DL3013
+  - SC2155

.travis.yml

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

API.md

@@ -1,4 +1,4 @@
-# Hass.io Server
+# Hass.io
 
 ## Hass.io RESTful API
 
@@ -22,11 +22,14 @@ On success / Code 200:
 }
 ```
 
-For access to API you need set the `X-HASSIO-KEY` they will be available for Add-ons/HomeAssistant with envoriment `HASSIO_TOKEN`.
+For access to API you need set the `X-HASSIO-KEY` they will be available for Add-ons/HomeAssistant with environment `HASSIO_TOKEN`.
 
 ### Hass.io
 
 - GET `/supervisor/ping`
+
+This API call don't need a token.
+
 - GET `/supervisor/info`
 
 The addons from `addons` are only installed one.
@@ -36,9 +39,13 @@ The addons from `addons` are only installed one.
     "version": "INSTALL_VERSION",
     "last_version": "LAST_VERSION",
     "arch": "armhf|aarch64|i386|amd64",
-    "beta_channel": "true|false",
+    "channel": "stable|beta|dev",
     "timezone": "TIMEZONE",
+    "logging": "debug|info|warning|error|critical",
+    "ip_address": "ip address",
     "wait_boot": "int",
+    "debug": "bool",
+    "debug_block": "bool",
     "addons": [
         {
             "name": "xy bla",
@@ -72,9 +79,12 @@ Optional:
 
 ```json
 {
-    "beta_channel": "true|false",
+    "channel": "stable|beta|dev",
     "timezone": "TIMEZONE",
     "wait_boot": "int",
+    "debug": "bool",
+    "debug_block": "bool",
+    "logging": "debug|info|warning|error|critical",
     "addons_repositories": [
         "REPO_URL"
     ]
@@ -217,22 +227,22 @@ return:
 ### Host
 
 - POST `/host/reload`
+
 - POST `/host/shutdown`
+
 - POST `/host/reboot`
+
 - GET `/host/info`
 
 ```json
 {
-    "type": "",
-    "version": "",
-    "last_version": "",
-    "features": ["shutdown", "reboot", "update", "hostname", "network_info", "network_control"],
-    "hostname": "",
-    "os": "",
-    "audio": {
-        "input": "0,0",
-        "output": "0,0"
-    }
+    "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",
 }
 ```
 
@@ -240,22 +250,67 @@ return:
 
 ```json
 {
-    "audio_input": "0,0",
-    "audio_output": "0,0"
+    "hostname": "",
 }
 ```
 
-- POST `/host/update`
+- POST `/host/reload`
 
-Optional:
+#### Services
 
+- GET `/host/services`
 ```json
 {
-    "version": "VERSION"
+    "services": [
+        {
+            "name": "xy.service",
+            "description": "XY ...",
+            "state": "active|"
+        }
+    ]
 }
 ```
 
-- GET `/host/hardware`
+- 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"],
@@ -266,31 +321,27 @@ Optional:
         "CARD_ID": {
             "name": "xy",
             "type": "microphone",
-            "devices": {
-                "DEV_ID": "type of device"
-            }
+            "devices": [
+                "chan_id": "channel ID",
+                "chan_type": "type of device"
+            ]
         }
     }
 }
 ```
 
-- POST `/host/reload`
-
-### Network
-
-- GET `/network/info`
-
+- GET `/hardware/audio`
 ```json
 {
-    "hostname": ""
-}
-```
-
-- POST `/network/options`
-
-```json
-{
-    "hostname": "",
+    "audio": {
+        "input": {
+            "0,0": "Mic"
+        },
+        "output": {
+            "1,0": "Jack",
+            "1,1": "HDMI"
+        }
+    }
 }
 ```
 
@@ -302,13 +353,16 @@ Optional:
 {
     "version": "INSTALL_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",
-    "startup_time": 600
+    "wait_boot": 600
 }
 ```
 
@@ -330,6 +384,7 @@ Output is the raw Docker log.
 - POST `/homeassistant/check`
 - POST `/homeassistant/start`
 - POST `/homeassistant/stop`
+- POST `/homeassistant/rebuild`
 
 - POST `/homeassistant/options`
 
@@ -340,8 +395,9 @@ Output is the raw Docker log.
     "port": "port for access hass",
     "ssl": "bool",
     "password": "",
+    "refresh_token": "",
     "watchdog": "bool",
-    "startup_time": 600
+    "wait_boot": 600
 }
 ```
 
@@ -370,6 +426,8 @@ Proxy to real websocket instance.
 
 ### RESTful for API addons
 
+If an add-on will call itself, you can use `/addons/self/...`.
+
 - GET `/addons`
 
 Get all available addons.
@@ -381,11 +439,11 @@ Get all available addons.
             "name": "xy bla",
             "slug": "xy",
             "description": "description",
-            "arch": ["armhf", "aarch64", "i386", "amd64"],
             "repository": "core|local|REP_ID",
             "version": "LAST_VERSION",
             "installed": "none|INSTALL_VERSION",
             "detached": "bool",
+            "available": "bool",
             "build": "bool",
             "url": "null|url",
             "icon": "bool",
@@ -410,11 +468,16 @@ Get all available addons.
 ```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",
@@ -423,25 +486,42 @@ Get all available addons.
     "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": "null|['mqtt']",
-    "discovery": "null|['component/platform']"
+    "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",
+    "ingress_panel": "null|bool"
 }
 ```
 
@@ -462,12 +542,23 @@ Get all available addons.
     },
     "options": {},
     "audio_output": "null|0,0",
-    "audio_input": "null|0,0"
+    "audio_input": "null|0,0",
+    "ingress_panel": "bool"
 }
 ```
 
 Reset custom network/audio/options, set it `null`.
 
+- POST `/addons/{addon}/security`
+
+This function is not callable by itself.
+
+```json
+{
+    "protected": "bool",
+}
+```
+
 - POST `/addons/{addon}/start`
 
 - POST `/addons/{addon}/stop`
@@ -505,39 +596,70 @@ Write data to add-on stdin
 }
 ```
 
-### Service discovery
+### ingress
 
-- GET `/services/discovery`
+- POST `/ingress/session`
+
+Create a new Session for access to ingress service.
+
+```json
+{
+    "session": "token"
+}
+```
+
+- GET `/ingress/panels`
+
+Return a list of enabled panels.
+
+```json
+{
+    "panels": {
+        "addon_slug": {
+            "enable": "boolean",
+            "icon": "mdi:...",
+            "title": "title",
+            "admin": "boolean"
+        }
+    }
+}
+```
+
+- VIEW `/ingress/{token}`
+
+Ingress WebUI for this Add-on. The addon need support HASS Auth!
+Need ingress session as cookie.
+
+### discovery
+
+- GET `/discovery`
 ```json
 {
     "discovery": [
         {
-            "provider": "name",
+            "addon": "slug",
+            "service": "name",
             "uuid": "uuid",
-            "component": "component",
-            "platform": "null|platform",
             "config": {}
         }
     ]
 }
 ```
 
-- GET `/services/discovery/{UUID}`
+- GET `/discovery/{UUID}`
 ```json
 {
-    "provider": "name",
+    "addon": "slug",
+    "service": "name",
     "uuid": "uuid",
-    "component": "component",
-    "platform": "null|platform",
     "config": {}
 }
 ```
 
-- POST `/services/discovery`
+- POST `/discovery`
 ```json
 {
-    "component": "component",
-    "platform": "null|platform",
+    "service": "name",
     "config": {}
 }
 ```
@@ -549,7 +671,9 @@ return:
 }
 ```
 
-- DEL `/services/discovery/{UUID}`
+- DEL `/discovery/{UUID}`
+
+### Services
 
 - GET `/services`
 ```json
@@ -558,28 +682,18 @@ return:
         {
             "slug": "name",
             "available": "bool",
-            "provider": "null|name|list"
+            "providers": "list"
         }
     ]
 }
 ```
 
-- GET `/services/xy`
-```json
-{
-    "available": "bool",
-    "xy": {}
-}
-```
-
 #### MQTT
 
-This service perform a auto discovery to Home-Assistant.
-
 - GET `/services/mqtt`
 ```json
 {
-    "provider": "name",
+    "addon": "name",
     "host": "xy",
     "port": "8883",
     "ssl": "bool",
@@ -603,45 +717,31 @@ This service perform a auto discovery to Home-Assistant.
 
 - DEL `/services/mqtt`
 
-## Host Control
+### Misc
 
-Communicate over UNIX socket with a host daemon.
-
-- commands
-
-```
-# info
--> {'type', 'version', 'last_version', 'features', 'hostname'}
-# reboot
-# shutdown
-# host-update [v]
-
-# hostname xy
-
-# network info
--> {}
-# network wlan ssd xy
-# network wlan password xy
-# network int ip xy
-# network int netmask xy
-# network int route xy
+- GET `/info`
+```json
+{
+    "supervisor": "version",
+    "homeassistant": "version",
+    "hassos": "null|version",
+    "hostname": "name",
+    "machine": "type",
+    "arch": "arch",
+    "supported_arch": ["arch1", "arch2"],
+    "channel": "stable|beta|dev",
+    "logging": "debug|info|warning|error|critical"
+}
 ```
 
-Features:
+### Auth / SSO API
 
-- shutdown
-- reboot
-- update
-- hostname
-- network_info
-- network_control
+You can use the user system on homeassistant. We handle this auth system on
+supervisor.
 
-Answer:
-```
-{}|OK|ERROR|WRONG
-```
+You can call post `/auth`
 
-- {}: json
-- OK: call was successfully
-- ERROR: error on call
-- WRONG: not supported
+We support:
+- Json `{ "user|name": "...", "password": "..." }`
+- application/x-www-form-urlencoded `user|name=...&password=...`
+- BasicAuth

Dockerfile

@@ -1,28 +1,28 @@
 ARG BUILD_FROM
 FROM $BUILD_FROM
 
-# Add env
-ENV LANG C.UTF-8
+ARG BUILD_ARCH
 
-# Setup base
+# Install base
 RUN apk add --no-cache \
-        python3 \
-        git \
-        socat \
-        libstdc++ \
-    && apk add --no-cache --virtual .build-dependencies \
-        make \
-        python3-dev \
-        g++ \
-    && pip3 install --no-cache-dir \
-        uvloop==0.9.1 \
-        cchardet==2.1.1 \
-        pycryptodome==3.4.11 \
-    && apk del .build-dependencies
+    openssl \
+    libffi \
+    musl \
+    git \
+    socat \
+    glib \
+    libstdc++ \
+    eudev-libs
+
+# Install requirements
+COPY requirements.txt /usr/src/
+RUN export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install --no-cache-dir --find-links https://wheels.hass.io/alpine-3.9/${BUILD_ARCH}/ \
+        -r /usr/src/requirements.txt \
+    && 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
+RUN pip3 install --no-cache-dir -e /usr/src/hassio
 
 CMD [ "python3", "-m", "hassio" ]

README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://dev.azure.com/home-assistant/Hass.io/_apis/build/status/hassio?branchName=dev)](https://dev.azure.com/home-assistant/Hass.io/_build/latest?definitionId=2&branchName=dev)
+
 # Hass.io
 
 ## First private cloud solution for home automation
@@ -10,9 +12,19 @@ and updating software.
 
 ![](misc/hassio.png?raw=true)
 
-- [Hass.io Addons](https://github.com/home-assistant/hassio-addons)
-- [Hass.io Build](https://github.com/home-assistant/hassio-build)
-
 ## Installation
 
 Installation instructions can be found at <https://home-assistant.io/hassio>.
+
+## Development
+
+The development of the supervisor is a bit tricky. Not difficult but tricky.
+
+- You can use the builder to build your supervisor: https://github.com/home-assistant/hassio-builder
+- Go into a HassOS device or VM and pull your supervisor.
+- Set the developer modus with cli `hassio supervisor options --channel=dev`
+- Tag it as `homeassistant/xy-hassio-supervisor:latest`
+- Restart the service like `systemctl restart hassos-supervisor | journalctl -fu hassos-supervisor`
+- Test your changes
+
+Small Bugfix or improvements, make a PR. Significant change makes first an RFC.

azure-pipelines.yml

@@ -0,0 +1,156 @@
+# https://dev.azure.com/home-assistant
+
+trigger:
+  branches:
+    include:
+    - master
+    - dev
+  tags:
+    include:
+    - '*'
+    exclude:
+    - untagged*
+pr:
+- dev
+
+variables:
+  - name: versionHadolint
+    value: 'v1.16.3'
+  - name: versionBuilder
+    value: '3.2'
+  - name: versionWheels
+    value: '0.3'
+  - group: docker
+  - group: wheels
+
+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'
+
+
+- job: 'Hadolint'
+  pool:
+    vmImage: 'ubuntu-16.04'
+  steps:
+  - script: sudo docker pull hadolint/hadolint:$(versionHadolint)
+    displayName: 'Install Hadolint'
+  - script: |
+      sudo docker run --rm -i \
+        -v $(pwd)/.hadolint.yaml:/.hadolint.yaml:ro \
+        hadolint/hadolint:$(versionHadolint) < Dockerfile
+    displayName: 'Run Hadolint'
+
+
+- job: 'Wheels'
+  condition: eq(variables['Build.SourceBranchName'], 'dev')
+  timeoutInMinutes: 360
+  pool:
+    vmImage: 'ubuntu-16.04'
+  strategy:
+    maxParallel: 3
+    matrix:
+      amd64:
+        buildArch: 'amd64'
+      i386:
+        buildArch: 'i386'
+      armhf:
+        buildArch: 'armhf'
+      armv7:
+        buildArch: 'armv7'
+      aarch64:
+        buildArch: 'aarch64'
+  steps:
+  - script: |
+      sudo apt-get install -y --no-install-recommends \
+        qemu-user-static \
+        binfmt-support
+      
+      sudo mount binfmt_misc -t binfmt_misc /proc/sys/fs/binfmt_misc
+      sudo update-binfmts --enable qemu-arm
+      sudo update-binfmts --enable qemu-aarch64
+    displayName: 'Initial cross build'
+  - script: |
+      mkdir -p .ssh
+      echo -e "-----BEGIN RSA PRIVATE KEY-----\n$(wheelsSSH)\n-----END RSA PRIVATE KEY-----" >> .ssh/id_rsa
+      ssh-keyscan -H $(wheelsHost) >> .ssh/known_hosts
+      chmod 600 .ssh/*
+    displayName: 'Install ssh key'
+  - script: sudo docker pull homeassistant/$(buildArch)-wheels:$(versionWheels)
+    displayName: 'Install wheels builder'
+  - script: |
+      sudo docker run --rm -v $(pwd):/data:ro -v $(pwd)/.ssh:/root/.ssh:rw \
+        homeassistant/$(buildArch)-wheels:$(versionWheels) \
+        --apk "build-base;libffi-dev;openssl-dev" \
+        --index https://wheels.hass.io \
+        --requirement requirements.txt \
+        --upload rsync \
+        --remote wheels@$(wheelsHost):/opt/wheels
+    displayName: 'Run wheels build'
+
+
+- job: 'ReleaseDEV'
+  condition: and(eq(variables['Build.SourceBranchName'], 'dev'), succeeded('JQ'), succeeded('Tox'), succeeded('Hadolint'), succeeded('Wheels'))
+  dependsOn:
+  - 'JQ'
+  - 'Tox'
+  - 'Hadolint'
+  - 'Wheels'
+  pool:
+    vmImage: 'ubuntu-16.04'
+  steps:
+  - script: sudo docker login -u $(dockerUser) -p $(dockerPassword)
+    displayName: 'Docker hub login'
+  - script: sudo docker pull homeassistant/amd64-builder:$(versionBuilder)
+    displayName: 'Install Builder'
+  - script: |
+      sudo docker run --rm --privileged \
+        -v ~/.docker:/root/.docker \
+        -v /run/docker.sock:/run/docker.sock:rw -v $(pwd):/data:ro \
+        homeassistant/amd64-builder:$(versionBuilder) \
+        --supervisor --all -t /data --version dev --docker-hub homeassistant
+    displayName: 'Build DEV'
+
+
+- job: 'Release'
+  condition: and(startsWith(variables['Build.SourceBranch'], 'refs/tags'), succeeded('JQ'), succeeded('Tox'), succeeded('Hadolint'))
+  dependsOn:
+  - 'JQ'
+  - 'Tox'
+  - 'Hadolint'
+  pool:
+    vmImage: 'ubuntu-16.04'
+  steps:
+  - script: sudo docker login -u $(dockerUser) -p $(dockerPassword)
+    displayName: 'Docker hub login'
+  - script: sudo docker pull homeassistant/amd64-builder:$(versionBuilder)
+    displayName: 'Install Builder'
+  - script: |
+      sudo docker run --rm --privileged \
+        -v ~/.docker:/root/.docker \
+        -v /run/docker.sock:/run/docker.sock:rw -v $(pwd):/data:ro \
+        homeassistant/amd64-builder:$(versionBuilder) \
+        --supervisor --all -t /data --docker-hub homeassistant
+    displayName: 'Build Release'

hassio/__init__.py

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

hassio/__main__.py

@@ -1,30 +1,34 @@
-"""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 attempt_use_uvloop():
+def initialize_event_loop():
     """Attempt to use uvloop."""
     try:
         import uvloop
-        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+
+        uvloop.install()
     except ImportError:
         pass
 
+    return asyncio.get_event_loop()
+
 
 # pylint: disable=invalid-name
 if __name__ == "__main__":
     bootstrap.initialize_logging()
-    attempt_use_uvloop()
-    loop = asyncio.get_event_loop()
 
+    # Init async event loop
+    loop = initialize_event_loop()
+
+    # Check if all information are available to setup Hass.io
     if not bootstrap.check_environment():
         sys.exit(1)
 
@@ -32,26 +36,26 @@ if __name__ == "__main__":
     executor = ThreadPoolExecutor(thread_name_prefix="SyncWorker")
     loop.set_default_executor(executor)
 
-    _LOGGER.info("Initialize Hassio setup")
-    coresys = bootstrap.initialize_coresys(loop)
-    hassio = core.HassIO(coresys)
+    _LOGGER.info("Initialize Hass.io setup")
+    coresys = loop.run_until_complete(bootstrap.initialize_coresys())
 
     bootstrap.migrate_system_env(coresys)
+    bootstrap.supervisor_debugger(coresys)
 
     _LOGGER.info("Setup HassIO")
-    loop.run_until_complete(hassio.setup())
+    loop.run_until_complete(coresys.core.setup())
 
-    loop.call_soon_threadsafe(loop.create_task, hassio.start())
+    loop.call_soon_threadsafe(loop.create_task, coresys.core.start())
     loop.call_soon_threadsafe(bootstrap.reg_signal, loop)
 
     try:
-        _LOGGER.info("Run HassIO")
+        _LOGGER.info("Run Hass.io")
         loop.run_forever()
     finally:
-        _LOGGER.info("Stopping HassIO")
-        loop.run_until_complete(hassio.stop())
+        _LOGGER.info("Stopping Hass.io")
+        loop.run_until_complete(coresys.core.stop())
         executor.shutdown(wait=False)
         loop.close()
 
-    _LOGGER.info("Close Hassio")
+    _LOGGER.info("Close Hass.io")
     sys.exit(0)

hassio/addons/__init__.py

@@ -1,145 +1,251 @@
-"""Init file for HassIO addons."""
+"""Init file for Hass.io add-ons."""
 import asyncio
+from contextlib import suppress
 import logging
+import tarfile
+from typing import Dict, List, Optional, Union
 
+from ..const import BOOT_AUTO, STATE_STARTED
+from ..coresys import CoreSys, CoreSysAttributes
+from ..exceptions import (
+    AddonsError,
+    AddonsNotSupportedError,
+    DockerAPIError,
+    HostAppArmorError,
+)
+from ..store.addon import AddonStore
 from .addon import Addon
-from .repository import Repository
 from .data import AddonsData
-from ..const import REPOSITORY_CORE, REPOSITORY_LOCAL, BOOT_AUTO
-from ..coresys import CoreSysAttributes
 
 _LOGGER = logging.getLogger(__name__)
 
-BUILTIN_REPOSITORIES = set((REPOSITORY_CORE, REPOSITORY_LOCAL))
+AnyAddon = Union[Addon, AddonStore]
 
 
 class AddonManager(CoreSysAttributes):
-    """Manage addons inside HassIO."""
+    """Manage add-ons inside Hass.io."""
 
-    def __init__(self, coresys):
-        """Initialize docker base wrapper."""
-        self.coresys = coresys
-        self.data = AddonsData(coresys)
-        self.addons_obj = {}
-        self.repositories_obj = {}
+    def __init__(self, coresys: CoreSys):
+        """Initialize Docker base wrapper."""
+        self.coresys: CoreSys = coresys
+        self.data: AddonsData = AddonsData(coresys)
+        self.local: Dict[str, Addon] = {}
+        self.store: Dict[str, AddonStore] = {}
 
     @property
-    def list_addons(self):
-        """Return a list of all addons."""
-        return list(self.addons_obj.values())
+    def all(self) -> List[AnyAddon]:
+        """Return a list of all add-ons."""
+        addons = {**self.store, **self.local}
+        return list(addons.values())
 
     @property
-    def list_installed(self):
-        """Return a list of installed addons."""
-        return [addon for addon in self.addons_obj.values()
-                if addon.is_installed]
+    def installed(self) -> List[Addon]:
+        """Return a list of all installed add-ons."""
+        return list(self.local.values())
 
-    @property
-    def list_repositories(self):
-        """Return list of addon repositories."""
-        return list(self.repositories_obj.values())
+    def get(self, addon_slug: str) -> Optional[AnyAddon]:
+        """Return an add-on from slug.
 
-    def get(self, addon_slug):
-        """Return a add-on from slug."""
-        return self.addons_obj.get(addon_slug)
+        Prio:
+          1 - Local
+          2 - Store
+        """
+        if addon_slug in self.local:
+            return self.local[addon_slug]
+        return self.store.get(addon_slug)
 
-    def from_uuid(self, uuid):
-        """Return a add-on from uuid."""
-        for addon in self.list_addons:
-            if addon.is_installed and uuid == addon.uuid:
+    def from_token(self, token: str) -> Optional[Addon]:
+        """Return an add-on from Hass.io token."""
+        for addon in self.installed:
+            if token == addon.hassio_token:
                 return addon
         return None
 
-    async def load(self):
-        """Startup addon management."""
-        self.data.reload()
-
-        # init hassio built-in repositories
-        repositories = \
-            set(self._config.addons_repositories) | BUILTIN_REPOSITORIES
-
-        # init custom repositories & load addons
-        await self.load_repositories(repositories)
-
-    async def reload(self):
-        """Update addons from repo and reload list."""
-        tasks = [repository.update() for repository in
-                 self.repositories_obj.values()]
-        if tasks:
-            await asyncio.wait(tasks, loop=self._loop)
-
-        # read data from repositories
-        self.data.reload()
-
-        # update addons
-        await self.load_addons()
-
-    async def load_repositories(self, list_repositories):
-        """Add a new custom repository."""
-        new_rep = set(list_repositories)
-        old_rep = set(self.repositories_obj)
-
-        # 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
-
-            # don't add built-in repository to config
-            if url not in BUILTIN_REPOSITORIES:
-                self._config.add_addon_repository(url)
-
-        tasks = [_add_repository(url) for url in new_rep - old_rep]
-        if tasks:
-            await asyncio.wait(tasks, loop=self._loop)
-
-        # del new repository
-        for url in old_rep - new_rep - BUILTIN_REPOSITORIES:
-            self.repositories_obj.pop(url).remove()
-            self._config.drop_addon_repository(url)
-
-        # update data
-        self.data.reload()
-        await self.load_addons()
-
-    async def load_addons(self):
-        """Update/add internal addon store."""
-        all_addons = set(self.data.system) | set(self.data.cache)
-
-        # calc diff
-        add_addons = all_addons - set(self.addons_obj)
-        del_addons = set(self.addons_obj) - all_addons
-
-        _LOGGER.info("Load addons: %d all - %d new - %d remove",
-                     len(all_addons), len(add_addons), len(del_addons))
-
-        # new addons
+    async def load(self) -> None:
+        """Start up add-on management."""
         tasks = []
-        for addon_slug in add_addons:
-            addon = Addon(self.coresys, addon_slug)
-
+        for slug in self.data.system:
+            addon = self.local[slug] = Addon(self.coresys, slug)
             tasks.append(addon.load())
-            self.addons_obj[addon_slug] = addon
 
+        # Run initial tasks
+        _LOGGER.info("Found %d installed add-ons", len(tasks))
         if tasks:
-            await asyncio.wait(tasks, loop=self._loop)
+            await asyncio.wait(tasks)
 
-        # remove
-        for addon_slug in del_addons:
-            self.addons_obj.pop(addon_slug)
-
-    async def auto_boot(self, stage):
-        """Boot addons with mode auto."""
+    async def boot(self, stage: str) -> None:
+        """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())
+        for addon in self.installed:
+            if addon.boot != BOOT_AUTO or addon.startup != stage:
+                continue
+            tasks.append(addon.start())
 
-        _LOGGER.info("Startup %s run %d addons", stage, len(tasks))
+        _LOGGER.info("Phase '%s' start %d add-ons", stage, len(tasks))
         if tasks:
-            await asyncio.wait(tasks, loop=self._loop)
-            await asyncio.sleep(self._config.wait_boot, loop=self._loop)
+            await asyncio.wait(tasks)
+            await asyncio.sleep(self.sys_config.wait_boot)
+
+    async def shutdown(self, stage: str) -> None:
+        """Shutdown addons."""
+        tasks = []
+        for addon in self.installed:
+            if await addon.state() != STATE_STARTED or addon.startup != stage:
+                continue
+            tasks.append(addon.stop())
+
+        _LOGGER.info("Phase '%s' stop %d add-ons", stage, len(tasks))
+        if tasks:
+            await asyncio.wait(tasks)
+
+    async def install(self, slug: str) -> None:
+        """Install an add-on."""
+        if slug in self.local:
+            _LOGGER.warning("Add-on %s is already installed", slug)
+            return
+        store = self.store.get(slug)
+
+        if not store:
+            _LOGGER.error("Add-on %s not exists", slug)
+            raise AddonsError()
+
+        if not store.available:
+            _LOGGER.error(
+                "Add-on %s not supported on that platform", slug)
+            raise AddonsNotSupportedError()
+
+        self.data.install(store)
+        addon = Addon(self.coresys, slug)
+
+        if not addon.path_data.is_dir():
+            _LOGGER.info(
+                "Create Home Assistant add-on data folder %s", addon.path_data)
+            addon.path_data.mkdir()
+
+        # Setup/Fix AppArmor profile
+        await addon.install_apparmor()
+
+        try:
+            await addon.instance.install(store.version, store.image)
+        except DockerAPIError:
+            self.data.uninstall(addon)
+            raise AddonsError() from None
+        else:
+            self.local[slug] = addon
+
+    async def uninstall(self, slug: str) -> None:
+        """Remove an add-on."""
+        if slug not in self.local:
+            _LOGGER.warning("Add-on %s is not installed", slug)
+            return
+        addon = self.local.get(slug)
+
+        try:
+            await addon.instance.remove()
+        except DockerAPIError:
+            raise AddonsError() from None
+
+        await addon.remove_data()
+
+        # Cleanup audio settings
+        if addon.path_asound.exists():
+            with suppress(OSError):
+                addon.path_asound.unlink()
+
+        # Cleanup AppArmor profile
+        with suppress(HostAppArmorError):
+            await addon.uninstall_apparmor()
+
+        # Cleanup internal data
+        addon.remove_discovery()
+        self.data.uninstall(addon)
+        self.local.pop(slug)
+
+    async def update(self, slug: str) -> None:
+        """Update add-on."""
+        if slug not in self.local:
+            _LOGGER.error("Add-on %s is not installed", slug)
+            raise AddonsError()
+        addon = self.local.get(slug)
+
+        if addon.is_detached:
+            _LOGGER.error("Add-on %s is not available inside store", slug)
+            raise AddonsError()
+        store = self.store.get(slug)
+
+        if addon.version == store.version:
+            _LOGGER.warning("No update available for add-on %s", slug)
+            return
+
+        # Check if available, Maybe something have changed
+        if not store.available:
+            _LOGGER.error(
+                "Add-on %s not supported on that platform", slug)
+            raise AddonsNotSupportedError()
+
+        # Update instance
+        last_state = await addon.state()
+        try:
+            await addon.instance.update(store.version, store.image)
+        except DockerAPIError:
+            raise AddonsError() from None
+        self.data.update(store)
+
+        # Setup/Fix AppArmor profile
+        await addon.install_apparmor()
+
+        # restore state
+        if last_state == STATE_STARTED:
+            await addon.start()
+
+    async def rebuild(self, slug: str) -> None:
+        """Perform a rebuild of local build add-on."""
+        if slug not in self.local:
+            _LOGGER.error("Add-on %s is not installed", slug)
+            raise AddonsError()
+        addon = self.local.get(slug)
+
+        if addon.is_detached:
+            _LOGGER.error("Add-on %s is not available inside store", slug)
+            raise AddonsError()
+        store = self.store.get(slug)
+
+        # Check if a rebuild is possible now
+        if addon.version != store.version:
+            _LOGGER.error("Version changed, use Update instead Rebuild")
+            raise AddonsError()
+        if not addon.need_build:
+            _LOGGER.error("Can't rebuild a image based add-on")
+            raise AddonsNotSupportedError()
+
+        # remove docker container but not addon config
+        last_state = await addon.state()
+        try:
+            await addon.instance.remove()
+            await addon.instance.install(addon.version)
+        except DockerAPIError:
+            raise AddonsError() from None
+        else:
+            self.data.update(store)
+
+        # restore state
+        if last_state == STATE_STARTED:
+            await addon.start()
+
+    async def restore(self, slug: str, tar_file: tarfile.TarFile) -> None:
+        """Restore state of an add-on."""
+        if slug not in self.local:
+            _LOGGER.debug("Add-on %s is not local available for restore")
+            addon = Addon(self.coresys, slug)
+        else:
+            _LOGGER.debug("Add-on %s is local available for restore")
+            addon = self.local[slug]
+
+        await addon.restore(tar_file)
+
+        # Check if new
+        if slug in self.local:
+            return
+
+        _LOGGER.info("Detect new Add-on after restore %s", slug)
+        self.local[slug] = addon

hassio/addons/build.py

@@ -1,50 +1,51 @@
-"""HassIO addons build environment."""
+"""Hass.io add-on build environment."""
+from __future__ import annotations
 from pathlib import Path
+from typing import TYPE_CHECKING, Dict
 
-from .validate import SCHEMA_BUILD_CONFIG, BASE_IMAGE
-from ..const import ATTR_SQUASH, ATTR_BUILD_FROM, ATTR_ARGS, META_ADDON
-from ..coresys import CoreSysAttributes
+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 . import AnyAddon
 
 
 class AddonBuild(JsonConfig, CoreSysAttributes):
-    """Handle build options for addons."""
+    """Handle build options for add-ons."""
 
-    def __init__(self, coresys, slug):
-        """Initialize addon builder."""
-        self.coresys = coresys
-        self._id = slug
+    def __init__(self, coresys: CoreSys, addon: AnyAddon) -> None:
+        """Initialize Hass.io add-on builder."""
+        self.coresys: CoreSys = coresys
+        self.addon = addon
 
         super().__init__(
             Path(self.addon.path_location, 'build.json'), SCHEMA_BUILD_CONFIG)
 
     def save_data(self):
         """Ignore save function."""
-        pass
+        raise RuntimeError()
 
     @property
-    def addon(self):
-        """Return addon of build data."""
-        return self._addons.get(self._id)
-
-    @property
-    def base_image(self):
-        """Base images for this addon."""
+    def base_image(self) -> str:
+        """Base images for this add-on."""
         return self._data[ATTR_BUILD_FROM].get(
-            self._arch, BASE_IMAGE[self._arch])
+            self.sys_arch.default,
+            f"homeassistant/{self.sys_arch.default}-base:latest")
 
     @property
-    def squash(self):
+    def squash(self) -> bool:
         """Return True or False if squash is active."""
         return self._data[ATTR_SQUASH]
 
     @property
-    def additional_args(self):
-        """Return additional docker build arguments."""
+    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."""
+        """Create a dict with Docker build arguments."""
         args = {
             'path': str(self.addon.path_location),
             'tag': f"{self.addon.image}:{version}",
@@ -53,15 +54,15 @@ class AddonBuild(JsonConfig, CoreSysAttributes):
             'squash': self.squash,
             'labels': {
                 'io.hass.version': version,
-                'io.hass.arch': self._arch,
+                'io.hass.arch': self.sys_arch.default,
                 'io.hass.type': META_ADDON,
-                'io.hass.name': self.addon.name,
-                'io.hass.description': self.addon.description,
+                '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._arch,
+                'BUILD_ARCH': self.sys_arch.default,
                 **self.additional_args,
             }
         }
@@ -70,3 +71,8 @@ class AddonBuild(JsonConfig, CoreSysAttributes):
             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/data.py

@@ -1,162 +1,74 @@
-"""Init file for HassIO addons."""
-import copy
+"""Init file for Hass.io add-on data."""
+from copy import deepcopy
 import logging
-import json
-from pathlib import Path
+from typing import Any, Dict
 
-import voluptuous as vol
-from voluptuous.humanize import humanize_error
-
-from .utils import extract_hash_from_path
-from .validate import (
-    SCHEMA_ADDON_CONFIG, SCHEMA_ADDONS_FILE, SCHEMA_REPOSITORY_CONFIG)
 from ..const import (
-    FILE_HASSIO_ADDONS, ATTR_VERSION, ATTR_SLUG, ATTR_REPOSITORY, ATTR_LOCATON,
-    REPOSITORY_CORE, REPOSITORY_LOCAL, ATTR_USER, ATTR_SYSTEM)
-from ..coresys import CoreSysAttributes
-from ..utils.json import JsonConfig, read_json_file
+    ATTR_IMAGE,
+    ATTR_OPTIONS,
+    ATTR_SYSTEM,
+    ATTR_USER,
+    ATTR_VERSION,
+    FILE_HASSIO_ADDONS,
+)
+from ..coresys import CoreSys, CoreSysAttributes
+from ..utils.json import JsonConfig
+from ..store.addon import AddonStore
+from .addon import Addon
+from .validate import SCHEMA_ADDONS_FILE
 
 _LOGGER = logging.getLogger(__name__)
 
+Config = Dict[str, Any]
+
 
 class AddonsData(JsonConfig, CoreSysAttributes):
-    """Hold data for addons inside HassIO."""
+    """Hold data for installed Add-ons inside Hass.io."""
 
-    def __init__(self, coresys):
+    def __init__(self, coresys: CoreSys):
         """Initialize data holder."""
         super().__init__(FILE_HASSIO_ADDONS, SCHEMA_ADDONS_FILE)
-        self.coresys = coresys
-        self._repositories = {}
-        self._cache = {}
+        self.coresys: CoreSys = coresys
 
     @property
     def user(self):
-        """Return local addon user data."""
+        """Return local add-on user data."""
         return self._data[ATTR_USER]
 
     @property
     def system(self):
-        """Return local addon data."""
+        """Return local add-on data."""
         return self._data[ATTR_SYSTEM]
 
-    @property
-    def cache(self):
-        """Return addon data from cache/repositories."""
-        return self._cache
+    def install(self, addon: AddonStore) -> None:
+        """Set addon as installed."""
+        self.system[addon.slug] = deepcopy(addon.data)
+        self.user[addon.slug] = {
+            ATTR_OPTIONS: {},
+            ATTR_VERSION: addon.version,
+            ATTR_IMAGE: addon.image,
+        }
+        self.save_data()
 
-    @property
-    def repositories(self):
-        """Return addon data from repositories."""
-        return self._repositories
+    def uninstall(self, addon: Addon) -> None:
+        """Set add-on as uninstalled."""
+        self.system.pop(addon.slug, None)
+        self.user.pop(addon.slug, None)
+        self.save_data()
 
-    def reload(self):
-        """Read data from addons repository."""
-        self._cache = {}
-        self._repositories = {}
+    def update(self, addon: AddonStore) -> None:
+        """Update version of add-on."""
+        self.system[addon.slug] = deepcopy(addon.data)
+        self.user[addon.slug].update({
+            ATTR_VERSION: addon.version,
+            ATTR_IMAGE: addon.image,
+        })
+        self.save_data()
 
-        # read core repository
-        self._read_addons_folder(
-            self._config.path_addons_core, REPOSITORY_CORE)
+    def restore(self, slug: str, user: Config, system: Config, image: str) -> None:
+        """Restore data to add-on."""
+        self.user[slug] = deepcopy(user)
+        self.system[slug] = deepcopy(system)
 
-        # read local repository
-        self._read_addons_folder(
-            self._config.path_addons_local, REPOSITORY_LOCAL)
-
-        # add built-in repositories information
-        self._set_builtin_repositories()
-
-        # read custom git repositories
-        for repository_element in self._config.path_addons_git.iterdir():
-            if repository_element.is_dir():
-                self._read_git_repository(repository_element)
-
-        # update local data
-        self._merge_config()
-
-    def _read_git_repository(self, path):
-        """Process a custom repository folder."""
-        slug = extract_hash_from_path(path)
-
-        # exists repository json
-        repository_file = Path(path, "repository.json")
-        try:
-            repository_info = SCHEMA_REPOSITORY_CONFIG(
-                read_json_file(repository_file)
-            )
-
-        except (OSError, json.JSONDecodeError):
-            _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 addons folder."""
-        for addon in path.glob("**/config.json"):
-            try:
-                addon_config = read_json_file(addon)
-
-                # validate
-                addon_config = SCHEMA_ADDON_CONFIG(addon_config)
-
-                # Generate slug
-                addon_slug = "{}_{}".format(
-                    repository, addon_config[ATTR_SLUG])
-
-                # store
-                addon_config[ATTR_REPOSITORY] = repository
-                addon_config[ATTR_LOCATON] = str(addon.parent)
-                self._cache[addon_slug] = addon_config
-
-            except (OSError, json.JSONDecodeError):
-                _LOGGER.warning("Can't read %s", addon)
-
-            except vol.Invalid as ex:
-                _LOGGER.warning("Can't read %s: %s", addon,
-                                humanize_error(addon_config, ex))
-
-    def _set_builtin_repositories(self):
-        """Add local built-in repository into dataset."""
-        try:
-            builtin_file = Path(__file__).parent.joinpath('built-in.json')
-            builtin_data = read_json_file(builtin_file)
-        except (OSError, json.JSONDecodeError) as err:
-            _LOGGER.warning("Can't read built-in json: %s", err)
-            return
-
-        # core repository
-        self._repositories[REPOSITORY_CORE] = \
-            builtin_data[REPOSITORY_CORE]
-
-        # local repository
-        self._repositories[REPOSITORY_LOCAL] = \
-            builtin_data[REPOSITORY_LOCAL]
-
-    def _merge_config(self):
-        """Update local config if they have update.
-
-        It need to be the same version as the local version is for merge.
-        """
-        have_change = False
-
-        for addon in set(self.system):
-            # detached
-            if addon not in self._cache:
-                continue
-
-            cache = self._cache[addon]
-            data = self.system[addon]
-            if data[ATTR_VERSION] == cache[ATTR_VERSION]:
-                if data != cache:
-                    self.system[addon] = copy.deepcopy(cache)
-                    have_change = True
-
-        if have_change:
-            self.save_data()
+        self.user[slug][ATTR_IMAGE] = image
+        self.save_data()

hassio/addons/git.py

@@ -1,112 +0,0 @@
-"""Init file for HassIO addons git."""
-import asyncio
-import logging
-import functools as ft
-from pathlib import Path
-import shutil
-
-import git
-
-from .utils import get_hash_from_repository
-from ..const import URL_HASSIO_ADDONS
-from ..coresys import CoreSysAttributes
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class GitRepo(CoreSysAttributes):
-    """Manage addons git repo."""
-
-    def __init__(self, coresys, path, url):
-        """Initialize git base wrapper."""
-        self.coresys = coresys
-        self.repo = None
-        self.path = path
-        self.url = url
-        self.lock = asyncio.Lock(loop=coresys.loop)
-
-    async def load(self):
-        """Init git addon repo."""
-        if not self.path.is_dir():
-            return await self.clone()
-
-        async with self.lock:
-            try:
-                _LOGGER.info("Load addon %s repository", self.path)
-                self.repo = await self._loop.run_in_executor(
-                    None, git.Repo, str(self.path))
-
-            except (git.InvalidGitRepositoryError, git.NoSuchPathError,
-                    git.GitCommandError) as err:
-                _LOGGER.error("Can't load %s repo: %s.", self.path, err)
-                return False
-
-            return True
-
-    async def clone(self):
-        """Clone git addon repo."""
-        async with self.lock:
-            try:
-                _LOGGER.info("Clone addon %s repository", self.url)
-                self.repo = await self._loop.run_in_executor(
-                    None, ft.partial(
-                        git.Repo.clone_from, self.url, str(self.path),
-                        recursive=True))
-
-            except (git.InvalidGitRepositoryError, git.NoSuchPathError,
-                    git.GitCommandError) as err:
-                _LOGGER.error("Can't clone %s repo: %s.", self.url, err)
-                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.")
-            return False
-
-        async with self.lock:
-            try:
-                _LOGGER.info("Pull addon %s repository", self.url)
-                await self._loop.run_in_executor(
-                    None, self.repo.remotes.origin.pull)
-
-            except (git.InvalidGitRepositoryError, git.NoSuchPathError,
-                    git.GitCommandError) as err:
-                _LOGGER.error("Can't pull %s repo: %s.", self.url, err)
-                return False
-
-            return True
-
-
-class GitRepoHassIO(GitRepo):
-    """HassIO addons repository."""
-
-    def __init__(self, coresys):
-        """Initialize git hassio addon repository."""
-        super().__init__(
-            coresys, coresys.config.path_addons_core, URL_HASSIO_ADDONS)
-
-
-class GitRepoCustom(GitRepo):
-    """Custom addons repository."""
-
-    def __init__(self, coresys, url):
-        """Initialize git hassio addon repository."""
-        path = Path(
-            coresys.config.path_addons_git,
-            get_hash_from_repository(url))
-
-        super().__init__(coresys, path, url)
-
-    def remove(self):
-        """Remove a custom addon."""
-        if self.path.is_dir():
-            _LOGGER.info("Remove custom addon repository %s", self.url)
-
-            def log_err(funct, path, _):
-                """Log error."""
-                _LOGGER.warning("Can't remove %s", path)
-
-            shutil.rmtree(str(self.path), onerror=log_err)

hassio/addons/model.py

@@ -0,0 +1,498 @@
+"""Init file for Hass.io add-ons."""
+from distutils.version import StrictVersion
+from pathlib import Path
+from typing import Any, Awaitable, Dict, List, Optional
+
+import voluptuous as vol
+
+from ..const import (
+    ATTR_APPARMOR,
+    ATTR_ARCH,
+    ATTR_AUDIO,
+    ATTR_AUTH_API,
+    ATTR_AUTO_UART,
+    ATTR_BOOT,
+    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_KERNEL_MODULES,
+    ATTR_LEGACY,
+    ATTR_LOCATON,
+    ATTR_MACHINE,
+    ATTR_MAP,
+    ATTR_NAME,
+    ATTR_OPTIONS,
+    ATTR_PANEL_ADMIN,
+    ATTR_PANEL_ICON,
+    ATTR_PANEL_TITLE,
+    ATTR_PORTS,
+    ATTR_PORTS_DESCRIPTION,
+    ATTR_PRIVILEGED,
+    ATTR_REPOSITORY,
+    ATTR_SCHEMA,
+    ATTR_SERVICES,
+    ATTR_SLUG,
+    ATTR_STARTUP,
+    ATTR_STDIN,
+    ATTR_TIMEOUT,
+    ATTR_TMPFS,
+    ATTR_URL,
+    ATTR_VERSION,
+    ATTR_WEBUI,
+    SECURITY_DEFAULT,
+    SECURITY_DISABLE,
+    SECURITY_PROFILE,
+)
+from ..coresys import CoreSysAttributes
+from .validate import MACHINE_ALL, RE_SERVICE, RE_VOLUME, validate_options
+
+Data = Dict[str, Any]
+
+
+class AddonModel(CoreSysAttributes):
+    """Add-on Data layout."""
+
+    slug: str = None
+
+    @property
+    def data(self) -> Data:
+        """Return Add-on config/data."""
+        raise NotImplementedError()
+
+    @property
+    def is_installed(self) -> bool:
+        """Return True if an add-on is installed."""
+        raise NotImplementedError()
+
+    @property
+    def is_detached(self) -> bool:
+        """Return True if add-on is detached."""
+        raise NotImplementedError()
+
+    @property
+    def available(self) -> bool:
+        """Return True if this add-on is available on this platform."""
+        return self._available(self.data)
+
+    @property
+    def options(self) -> Dict[str, Any]:
+        """Return options with local changes."""
+        return self.data[ATTR_OPTIONS]
+
+    @property
+    def boot(self) -> bool:
+        """Return boot config with prio local settings."""
+        return self.data[ATTR_BOOT]
+
+    @property
+    def auto_update(self) -> Optional[bool]:
+        """Return if auto update is enable."""
+        return None
+
+    @property
+    def name(self) -> str:
+        """Return name of add-on."""
+        return self.data[ATTR_NAME]
+
+    @property
+    def timeout(self) -> int:
+        """Return timeout of addon for docker stop."""
+        return self.data[ATTR_TIMEOUT]
+
+    @property
+    def uuid(self) -> Optional[str]:
+        """Return an API token for this add-on."""
+        return None
+
+    @property
+    def hassio_token(self) -> Optional[str]:
+        """Return access token for Hass.io API."""
+        return None
+
+    @property
+    def ingress_token(self) -> Optional[str]:
+        """Return access token for Hass.io API."""
+        return None
+
+    @property
+    def ingress_entry(self) -> Optional[str]:
+        """Return ingress external URL."""
+        return None
+
+    @property
+    def description(self) -> str:
+        """Return description of add-on."""
+        return self.data[ATTR_DESCRIPTON]
+
+    @property
+    def long_description(self) -> Optional[str]:
+        """Return README.md as long_description."""
+        readme = Path(self.path_location, 'README.md')
+
+        # If readme not exists
+        if not readme.exists():
+            return None
+
+        # Return data
+        with readme.open('r') as readme_file:
+            return readme_file.read()
+
+    @property
+    def repository(self) -> str:
+        """Return repository of add-on."""
+        return self.data[ATTR_REPOSITORY]
+
+    @property
+    def latest_version(self) -> str:
+        """Return latest version of add-on."""
+        return self.data[ATTR_VERSION]
+
+    @property
+    def version(self) -> str:
+        """Return version of add-on."""
+        return self.data[ATTR_VERSION]
+
+    @property
+    def protected(self) -> bool:
+        """Return if add-on is in protected mode."""
+        return True
+
+    @property
+    def startup(self) -> Optional[str]:
+        """Return startup type of add-on."""
+        return self.data.get(ATTR_STARTUP)
+
+    @property
+    def services_role(self) -> Dict[str, str]:
+        """Return dict of services with rights."""
+        services_list = self.data.get(ATTR_SERVICES, [])
+
+        services = {}
+        for data in services_list:
+            service = RE_SERVICE.match(data)
+            services[service.group('service')] = service.group('rights')
+
+        return services
+
+    @property
+    def discovery(self) -> List[str]:
+        """Return list of discoverable components/platforms."""
+        return self.data.get(ATTR_DISCOVERY, [])
+
+    @property
+    def ports_description(self) -> Optional[Dict[str, str]]:
+        """Return descriptions of ports."""
+        return self.data.get(ATTR_PORTS_DESCRIPTION)
+
+    @property
+    def ports(self) -> Optional[Dict[str, Optional[int]]]:
+        """Return ports of add-on."""
+        return self.data.get(ATTR_PORTS)
+
+    @property
+    def ingress_url(self) -> Optional[str]:
+        """Return URL to ingress url."""
+        return None
+
+    @property
+    def webui(self) -> Optional[str]:
+        """Return URL to webui or None."""
+        return self.data.get(ATTR_WEBUI)
+
+    @property
+    def ingress_port(self) -> Optional[int]:
+        """Return Ingress port."""
+        return None
+
+    @property
+    def panel_icon(self) -> str:
+        """Return panel icon for Ingress frame."""
+        return self.data[ATTR_PANEL_ICON]
+
+    @property
+    def panel_title(self) -> str:
+        """Return panel icon for Ingress frame."""
+        return self.data.get(ATTR_PANEL_TITLE, self.name)
+
+    @property
+    def panel_admin(self) -> str:
+        """Return panel icon for Ingress frame."""
+        return self.data[ATTR_PANEL_ADMIN]
+
+    @property
+    def host_network(self) -> bool:
+        """Return True if add-on run on host network."""
+        return self.data[ATTR_HOST_NETWORK]
+
+    @property
+    def host_pid(self) -> bool:
+        """Return True if add-on run on host PID namespace."""
+        return self.data[ATTR_HOST_PID]
+
+    @property
+    def host_ipc(self) -> bool:
+        """Return True if add-on run on host IPC namespace."""
+        return self.data[ATTR_HOST_IPC]
+
+    @property
+    def host_dbus(self) -> bool:
+        """Return True if add-on run on host D-BUS."""
+        return self.data[ATTR_HOST_DBUS]
+
+    @property
+    def devices(self) -> Optional[List[str]]:
+        """Return devices of add-on."""
+        return self.data.get(ATTR_DEVICES, [])
+
+    @property
+    def auto_uart(self) -> bool:
+        """Return True if we should map all UART device."""
+        return self.data[ATTR_AUTO_UART]
+
+    @property
+    def tmpfs(self) -> Optional[str]:
+        """Return tmpfs of add-on."""
+        return self.data.get(ATTR_TMPFS)
+
+    @property
+    def environment(self) -> Optional[Dict[str, str]]:
+        """Return environment of add-on."""
+        return self.data.get(ATTR_ENVIRONMENT)
+
+    @property
+    def privileged(self) -> List[str]:
+        """Return list of privilege."""
+        return self.data.get(ATTR_PRIVILEGED, [])
+
+    @property
+    def apparmor(self) -> str:
+        """Return True if AppArmor is enabled."""
+        if not self.data.get(ATTR_APPARMOR):
+            return SECURITY_DISABLE
+        elif self.sys_host.apparmor.exists(self.slug):
+            return SECURITY_PROFILE
+        return SECURITY_DEFAULT
+
+    @property
+    def legacy(self) -> bool:
+        """Return if the add-on don't support Home Assistant labels."""
+        return self.data[ATTR_LEGACY]
+
+    @property
+    def access_docker_api(self) -> bool:
+        """Return if the add-on need read-only Docker API access."""
+        return self.data[ATTR_DOCKER_API]
+
+    @property
+    def access_hassio_api(self) -> bool:
+        """Return True if the add-on access to Hass.io REASTful API."""
+        return self.data[ATTR_HASSIO_API]
+
+    @property
+    def access_homeassistant_api(self) -> bool:
+        """Return True if the add-on access to Home Assistant API proxy."""
+        return self.data[ATTR_HOMEASSISTANT_API]
+
+    @property
+    def hassio_role(self) -> str:
+        """Return Hass.io role for API."""
+        return self.data[ATTR_HASSIO_ROLE]
+
+    @property
+    def with_stdin(self) -> bool:
+        """Return True if the add-on access use stdin input."""
+        return self.data[ATTR_STDIN]
+
+    @property
+    def with_ingress(self) -> bool:
+        """Return True if the add-on access support ingress."""
+        return self.data[ATTR_INGRESS]
+
+    @property
+    def ingress_panel(self) -> Optional[bool]:
+        """Return True if the add-on access support ingress."""
+        return None
+
+    @property
+    def with_gpio(self) -> bool:
+        """Return True if the add-on access to GPIO interface."""
+        return self.data[ATTR_GPIO]
+
+    @property
+    def with_kernel_modules(self) -> bool:
+        """Return True if the add-on access to kernel modules."""
+        return self.data[ATTR_KERNEL_MODULES]
+
+    @property
+    def with_full_access(self) -> bool:
+        """Return True if the add-on want full access to hardware."""
+        return self.data[ATTR_FULL_ACCESS]
+
+    @property
+    def with_devicetree(self) -> bool:
+        """Return True if the add-on read access to devicetree."""
+        return self.data[ATTR_DEVICETREE]
+
+    @property
+    def access_auth_api(self) -> bool:
+        """Return True if the add-on access to login/auth backend."""
+        return self.data[ATTR_AUTH_API]
+
+    @property
+    def with_audio(self) -> bool:
+        """Return True if the add-on access to audio."""
+        return self.data[ATTR_AUDIO]
+
+    @property
+    def homeassistant_version(self) -> Optional[str]:
+        """Return min Home Assistant version they needed by Add-on."""
+        return self.data.get(ATTR_HOMEASSISTANT)
+
+    @property
+    def url(self) -> Optional[str]:
+        """Return URL of add-on."""
+        return self.data.get(ATTR_URL)
+
+    @property
+    def with_icon(self) -> bool:
+        """Return True if an icon exists."""
+        return self.path_icon.exists()
+
+    @property
+    def with_logo(self) -> bool:
+        """Return True if a logo exists."""
+        return self.path_logo.exists()
+
+    @property
+    def with_changelog(self) -> bool:
+        """Return True if a changelog exists."""
+        return self.path_changelog.exists()
+
+    @property
+    def supported_arch(self) -> List[str]:
+        """Return list of supported arch."""
+        return self.data[ATTR_ARCH]
+
+    @property
+    def supported_machine(self) -> List[str]:
+        """Return list of supported machine."""
+        return self.data.get(ATTR_MACHINE, MACHINE_ALL)
+
+    @property
+    def image(self) -> str:
+        """Generate image name from data."""
+        return self._image(self.data)
+
+    @property
+    def need_build(self) -> bool:
+        """Return True if this  add-on need a local build."""
+        return ATTR_IMAGE not in self.data
+
+    @property
+    def map_volumes(self) -> Dict[str, str]:
+        """Return a dict of {volume: policy} from add-on."""
+        volumes = {}
+        for volume in self.data[ATTR_MAP]:
+            result = RE_VOLUME.match(volume)
+            volumes[result.group(1)] = result.group(2) or 'ro'
+
+        return volumes
+
+    @property
+    def path_location(self) -> Path:
+        """Return path to this add-on."""
+        return Path(self.data[ATTR_LOCATON])
+
+    @property
+    def path_icon(self) -> Path:
+        """Return path to add-on icon."""
+        return Path(self.path_location, 'icon.png')
+
+    @property
+    def path_logo(self) -> Path:
+        """Return path to add-on logo."""
+        return Path(self.path_location, 'logo.png')
+
+    @property
+    def path_changelog(self) -> Path:
+        """Return path to add-on changelog."""
+        return Path(self.path_location, 'CHANGELOG.md')
+
+    @property
+    def path_apparmor(self) -> Path:
+        """Return path to custom AppArmor profile."""
+        return Path(self.path_location, 'apparmor.txt')
+
+    @property
+    def schema(self) -> vol.Schema:
+        """Create a schema for add-on options."""
+        raw_schema = self.data[ATTR_SCHEMA]
+
+        if isinstance(raw_schema, bool):
+            return vol.Schema(dict)
+        return vol.Schema(vol.All(dict, validate_options(raw_schema)))
+
+    def __eq__(self, other):
+        """Compaired add-on objects."""
+        if self.slug == other.slug:
+            return True
+        return False
+
+    def _available(self, config) -> bool:
+        """Return True if this add-on is available on this platform."""
+        # Architecture
+        if not self.sys_arch.is_supported(config[ATTR_ARCH]):
+            return False
+
+        # Machine / Hardware
+        machine = config.get(ATTR_MACHINE) or MACHINE_ALL
+        if self.sys_machine not in machine:
+            return False
+
+        # Home Assistant
+        version = config.get(ATTR_HOMEASSISTANT) or self.sys_homeassistant.version
+        if StrictVersion(self.sys_homeassistant.version) < StrictVersion(version):
+            return False
+
+        return True
+
+    def _image(self, config) -> str:
+        """Generate image name from data."""
+        # Repository with Dockerhub images
+        if ATTR_IMAGE in config:
+            arch = self.sys_arch.match(config[ATTR_ARCH])
+            return config[ATTR_IMAGE].format(arch=arch)
+
+        # local build
+        return f"{config[ATTR_REPOSITORY]}/{self.sys_arch.default}-addon-{config[ATTR_SLUG]}"
+
+    def install(self) -> Awaitable[None]:
+        """Install this add-on."""
+        return self.sys_addons.install(self.slug)
+
+    def uninstall(self) -> Awaitable[None]:
+        """Uninstall this add-on."""
+        return self.sys_addons.uninstall(self.slug)
+
+    def update(self) -> Awaitable[None]:
+        """Update this add-on."""
+        return self.sys_addons.update(self.slug)
+
+    def rebuild(self) -> Awaitable[None]:
+        """Rebuild this add-on."""
+        return self.sys_addons.rebuild(self.slug)

hassio/addons/utils.py

@@ -1,35 +1,99 @@
-"""Util addons functions."""
-import hashlib
-import logging
-import re
+"""Util add-ons functions."""
+from __future__ import annotations
 
-RE_SHA1 = re.compile(r"[a-f0-9]{8}")
+import asyncio
+import logging
+from pathlib import Path
+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,
+)
+
+if TYPE_CHECKING:
+    from .model import AddonModel
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def get_hash_from_repository(name):
-    """Generate a hash from repository."""
-    key = name.lower().encode()
-    return hashlib.sha1(key).hexdigest()[:8]
+def rating_security(addon: AddonModel) -> 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 extract_hash_from_path(path):
-    """Extract repo id from path."""
-    repo_dir = path.parts[-1]
+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
+        )
 
-    if not RE_SHA1.match(repo_dir):
-        return get_hash_from_repository(repo_dir)
-    return repo_dir
+        _, error_msg = await proc.communicate()
+    except OSError as err:
+        error_msg = str(err)
+    else:
+        if proc.returncode == 0:
+            return
 
-
-def check_installed(method):
-    """Wrap function with check if addon is installed."""
-    async def wrap_check(addon, *args, **kwargs):
-        """Return False if not installed or the function."""
-        if not addon.is_installed:
-            _LOGGER.error("Addon %s is not installed", addon.slug)
-            return False
-        return await method(addon, *args, **kwargs)
-
-    return wrap_check
+    _LOGGER.error("Can't remove Add-on Data: %s", error_msg)

hassio/addons/validate.py

@@ -1,31 +1,104 @@
-"""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, ATTR_OPTIONS, ATTR_PORTS, STARTUP_ONCE,
-    STARTUP_SYSTEM, STARTUP_SERVICES, STARTUP_APPLICATION, STARTUP_INITIALIZE,
-    BOOT_AUTO, BOOT_MANUAL, ATTR_SCHEMA, ATTR_IMAGE, ATTR_URL, ATTR_MAINTAINER,
-    ATTR_ARCH, ATTR_DEVICES, ATTR_ENVIRONMENT, ATTR_HOST_NETWORK, ARCH_ARMHF,
-    ARCH_AARCH64, ARCH_AMD64, ARCH_I386, ATTR_TMPFS, ATTR_PRIVILEGED,
-    ATTR_USER, ATTR_STATE, ATTR_SYSTEM, STATE_STARTED, STATE_STOPPED,
-    ATTR_LOCATON, ATTR_REPOSITORY, ATTR_TIMEOUT, ATTR_NETWORK, ATTR_UUID,
-    ATTR_AUTO_UPDATE, ATTR_WEBUI, ATTR_AUDIO, ATTR_AUDIO_INPUT, ATTR_HOST_IPC,
-    ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API, ATTR_BUILD_FROM, ATTR_SQUASH,
-    ATTR_ARGS, ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, ATTR_LEGACY,
-    ATTR_HOST_DBUS, ATTR_AUTO_UART, ATTR_SERVICES, ATTR_DISCOVERY)
-from ..validate import NETWORK_PORT, DOCKER_PORTS, ALSA_CHANNEL
+    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_INGRESS_PANEL,
+    ATTR_PANEL_ADMIN,
+    ATTR_PANEL_ICON,
+    ATTR_PANEL_TITLE,
+    ATTR_KERNEL_MODULES,
+    ATTR_LEGACY,
+    ATTR_LOCATON,
+    ATTR_MACHINE,
+    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>rw|:ro))?$")
-RE_DISCOVERY = re.compile(r"^(?P<component>\w*)(?:/(?P<platform>\w*>))?$")
+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'
@@ -45,32 +118,20 @@ RE_SCHEMA_ELEMENT = re.compile(
     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)
 
-ARCH_ALL = [
-    ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386
-]
 
-STARTUP_ALL = [
-    STARTUP_ONCE, STARTUP_INITIALIZE, STARTUP_SYSTEM, STARTUP_SERVICES,
-    STARTUP_APPLICATION
+MACHINE_ALL = [
+    'intel-nuc', 'odroid-c2', 'odroid-xu', 'orangepi-prime', 'qemux86',
+    'qemux86-64', 'qemuarm', 'qemuarm-64', 'raspberrypi', 'raspberrypi2',
+    'raspberrypi3', 'raspberrypi3-64', 'tinker',
 ]
 
-PRIVILEGED_ALL = [
-    "NET_ADMIN",
-    "SYS_ADMIN",
-    "SYS_RAWIO",
-    "SYS_TIME",
-    "SYS_NICE"
-]
-
-BASE_IMAGE = {
-    ARCH_ARMHF: "homeassistant/armhf-base:latest",
-    ARCH_AARCH64: "homeassistant/aarch64-base:latest",
-    ARCH_I386: "homeassistant/i386-base:latest",
-    ARCH_AMD64: "homeassistant/amd64-base:latest",
-}
-
 
 def _simple_startup(value):
     """Simple startup schema."""
@@ -87,16 +148,26 @@ 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.Optional(ATTR_ARCH, default=ARCH_ALL): [vol.In(ARCH_ALL)],
     vol.Required(ATTR_STARTUP):
         vol.All(_simple_startup, vol.In(STARTUP_ALL)),
     vol.Required(ATTR_BOOT):
         vol.In([BOOT_AUTO, BOOT_MANUAL]),
     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_PANEL_ICON, default="mdi:puzzle"): vol.Coerce(str),
+    vol.Optional(ATTR_PANEL_TITLE): vol.Coerce(str),
+    vol.Optional(ATTR_PANEL_ADMIN, default=True): vol.Boolean(),
+    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})$")],
@@ -106,14 +177,21 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
     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): [vol.Match(RE_DISCOVERY)],
+    vol.Optional(ATTR_DISCOVERY): [valid_discovery_service],
     vol.Required(ATTR_OPTIONS): dict,
     vol.Required(ATTR_SCHEMA): vol.Any(vol.Schema({
         vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [
@@ -125,24 +203,17 @@ SCHEMA_ADDON_CONFIG = vol.Schema({
             vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [SCHEMA_ELEMENT])
         }))
     }), False),
-    vol.Optional(ATTR_IMAGE): vol.Match(r"^[\w{}]+/[\-\w{}]+$"),
+    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=BASE_IMAGE): vol.Schema({
-        vol.In(ARCH_ALL): vol.Match(r"(?:^[\w{}]+/)?[\-\w{}]+:[\.\-\w{}]+$"),
+    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({
@@ -154,15 +225,19 @@ SCHEMA_BUILD_CONFIG = vol.Schema({
 # pylint: disable=no-value-for-parameter
 SCHEMA_ADDON_USER = vol.Schema({
     vol.Required(ATTR_VERSION): vol.Coerce(str),
-    vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex):
-        vol.Match(r"^[0-9a-f]{32}$"),
+    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_CHANNEL,
-    vol.Optional(ATTR_AUDIO_INPUT): ALSA_CHANNEL,
+    vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_DEVICE,
+    vol.Optional(ATTR_AUDIO_INPUT): ALSA_DEVICE,
+    vol.Optional(ATTR_PROTECTED, default=True): vol.Boolean(),
+    vol.Optional(ATTR_INGRESS_PANEL, default=False): vol.Boolean(),
 }, extra=vol.REMOVE_EXTRA)
 
 
@@ -193,7 +268,7 @@ SCHEMA_ADDON_SNAPSHOT = vol.Schema({
 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

hassio/api/__init__.py

@@ -1,249 +1,274 @@
-"""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 .supervisor import APISupervisor
-from .snapshots import APISnapshots
+from .security import SecurityMiddleware
 from .services import APIServices
-from .security import security_layer
-from ..coresys import CoreSysAttributes
+from .snapshots import APISnapshots
+from .supervisor import APISupervisor
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class RestAPI(CoreSysAttributes):
-    """Handle rest api for hassio."""
+    """Handle RESTful API for Hass.io."""
 
-    def __init__(self, coresys):
-        """Initialize docker base wrapper."""
-        self.coresys = coresys
-        self.webapp = web.Application(
-            middlewares=[security_layer], 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
 
-        # middleware
-        self.webapp['coresys'] = coresys
-
-    async def load(self):
+    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_network()
         self._register_discovery()
         self._register_services()
+        self._register_info()
+        self._register_auth()
 
-    def _register_host(self):
-        """Register hostcontrol function."""
+    def _register_host(self) -> None:
+        """Register hostcontrol functions."""
         api_host = APIHost()
         api_host.coresys = self.coresys
 
-        self.webapp.router.add_get('/host/info', api_host.info)
-        self.webapp.router.add_get('/host/hardware', api_host.hardware)
-        self.webapp.router.add_post('/host/reboot', api_host.reboot)
-        self.webapp.router.add_post('/host/shutdown', api_host.shutdown)
-        self.webapp.router.add_post('/host/update', api_host.update)
-        self.webapp.router.add_post('/host/options', api_host.options)
-        self.webapp.router.add_post('/host/reload', api_host.reload)
+        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),
+        ])
 
-    def _register_network(self):
-        """Register network function."""
-        api_net = APINetwork()
-        api_net.coresys = self.coresys
+    def _register_hassos(self) -> None:
+        """Register HassOS functions."""
+        api_hassos = APIHassOS()
+        api_hassos.coresys = self.coresys
 
-        self.webapp.router.add_get('/network/info', api_net.info)
-        self.webapp.router.add_post('/network/options', api_net.options)
+        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),
+        ])
 
-    def _register_supervisor(self):
-        """Register supervisor function."""
+    def _register_hardware(self) -> None:
+        """Register hardware functions."""
+        api_hardware = APIHardware()
+        api_hardware.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/hardware/info', api_hardware.info),
+            web.get('/hardware/audio', api_hardware.audio),
+        ])
+
+    def _register_info(self) -> None:
+        """Register info functions."""
+        api_info = APIInfo()
+        api_info.coresys = self.coresys
+
+        self.webapp.add_routes([
+            web.get('/info', api_info.info),
+        ])
+
+    def _register_auth(self) -> None:
+        """Register auth functions."""
+        api_auth = APIAuth()
+        api_auth.coresys = self.coresys
+
+        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.router.add_get('/supervisor/ping', api_supervisor.ping)
-        self.webapp.router.add_get('/supervisor/info', api_supervisor.info)
-        self.webapp.router.add_get('/supervisor/stats', api_supervisor.stats)
-        self.webapp.router.add_post(
-            '/supervisor/update', api_supervisor.update)
-        self.webapp.router.add_post(
-            '/supervisor/reload', api_supervisor.reload)
-        self.webapp.router.add_post(
-            '/supervisor/options', api_supervisor.options)
-        self.webapp.router.add_get('/supervisor/logs', api_supervisor.logs)
+        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):
-        """Register homeassistant function."""
+    def _register_homeassistant(self) -> None:
+        """Register Home Assistant functions."""
         api_hass = APIHomeAssistant()
         api_hass.coresys = self.coresys
 
-        self.webapp.router.add_get('/homeassistant/info', api_hass.info)
-        self.webapp.router.add_get('/homeassistant/logs', api_hass.logs)
-        self.webapp.router.add_get('/homeassistant/stats', api_hass.stats)
-        self.webapp.router.add_post('/homeassistant/options', api_hass.options)
-        self.webapp.router.add_post('/homeassistant/update', api_hass.update)
-        self.webapp.router.add_post('/homeassistant/restart', api_hass.restart)
-        self.webapp.router.add_post('/homeassistant/stop', api_hass.stop)
-        self.webapp.router.add_post('/homeassistant/start', api_hass.start)
-        self.webapp.router.add_post('/homeassistant/check', api_hass.check)
+        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):
-        """Register HomeAssistant API Proxy."""
+    def _register_proxy(self) -> None:
+        """Register Home Assistant API Proxy."""
         api_proxy = APIProxy()
         api_proxy.coresys = self.coresys
 
-        self.webapp.router.add_get(
-            '/homeassistant/api/websocket', api_proxy.websocket)
-        self.webapp.router.add_get(
-            '/homeassistant/websocket', api_proxy.websocket)
-        self.webapp.router.add_get(
-            '/homeassistant/api/stream', api_proxy.stream)
-        self.webapp.router.add_post(
-            '/homeassistant/api/{path:.+}', api_proxy.api)
-        self.webapp.router.add_get(
-            '/homeassistant/api/{path:.+}', api_proxy.api)
-        self.webapp.router.add_get(
-            '/homeassistant/api/', api_proxy.api)
+        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):
-        """Register homeassistant function."""
+    def _register_addons(self) -> None:
+        """Register Add-on functions."""
         api_addons = APIAddons()
         api_addons.coresys = self.coresys
 
-        self.webapp.router.add_get('/addons', api_addons.list)
-        self.webapp.router.add_post('/addons/reload', api_addons.reload)
-        self.webapp.router.add_get('/addons/{addon}/info', api_addons.info)
-        self.webapp.router.add_post(
-            '/addons/{addon}/install', api_addons.install)
-        self.webapp.router.add_post(
-            '/addons/{addon}/uninstall', api_addons.uninstall)
-        self.webapp.router.add_post('/addons/{addon}/start', api_addons.start)
-        self.webapp.router.add_post('/addons/{addon}/stop', api_addons.stop)
-        self.webapp.router.add_post(
-            '/addons/{addon}/restart', api_addons.restart)
-        self.webapp.router.add_post(
-            '/addons/{addon}/update', api_addons.update)
-        self.webapp.router.add_post(
-            '/addons/{addon}/options', api_addons.options)
-        self.webapp.router.add_post(
-            '/addons/{addon}/rebuild', api_addons.rebuild)
-        self.webapp.router.add_get('/addons/{addon}/logs', api_addons.logs)
-        self.webapp.router.add_get('/addons/{addon}/icon', api_addons.icon)
-        self.webapp.router.add_get('/addons/{addon}/logo', api_addons.logo)
-        self.webapp.router.add_get(
-            '/addons/{addon}/changelog', api_addons.changelog)
-        self.webapp.router.add_post('/addons/{addon}/stdin', api_addons.stdin)
-        self.webapp.router.add_get('/addons/{addon}/stats', api_addons.stats)
+        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_snapshots(self):
-        """Register snapshots function."""
+    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.get('/ingress/panels', api_ingress.panels),
+            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.router.add_get('/snapshots', api_snapshots.list)
-        self.webapp.router.add_post('/snapshots/reload', api_snapshots.reload)
+        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),
+        ])
 
-        self.webapp.router.add_post(
-            '/snapshots/new/full', api_snapshots.snapshot_full)
-        self.webapp.router.add_post(
-            '/snapshots/new/partial', api_snapshots.snapshot_partial)
-        self.webapp.router.add_post(
-            '/snapshots/new/upload', api_snapshots.upload)
-
-        self.webapp.router.add_get(
-            '/snapshots/{snapshot}/info', api_snapshots.info)
-        self.webapp.router.add_post(
-            '/snapshots/{snapshot}/remove', api_snapshots.remove)
-        self.webapp.router.add_post(
-            '/snapshots/{snapshot}/restore/full', api_snapshots.restore_full)
-        self.webapp.router.add_post(
-            '/snapshots/{snapshot}/restore/partial',
-            api_snapshots.restore_partial)
-        self.webapp.router.add_get(
-            '/snapshots/{snapshot}/download',
-            api_snapshots.download)
-
-    def _register_services(self):
+    def _register_services(self) -> None:
+        """Register services functions."""
         api_services = APIServices()
         api_services.coresys = self.coresys
 
-        self.webapp.router.add_get('/services', api_services.list)
+        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),
+        ])
 
-        self.webapp.router.add_get(
-            '/services/{service}', api_services.get_service)
-        self.webapp.router.add_post(
-            '/services/{service}', api_services.set_service)
-        self.webapp.router.add_delete(
-            '/services/{service}', api_services.del_service)
-
-    def _register_discovery(self):
+    def _register_discovery(self) -> None:
+        """Register discovery functions."""
         api_discovery = APIDiscovery()
         api_discovery.coresys = self.coresys
 
-        self.webapp.router.add_get(
-            '/services/discovery', api_discovery.list)
-        self.webapp.router.add_get(
-            '/services/discovery/{uuid}', api_discovery.get_discovery)
-        self.webapp.router.add_delete(
-            '/services/discovery/{uuid}', api_discovery.del_discovery)
-        self.webapp.router.add_post(
-            '/services/discovery', api_discovery.set_discovery)
+        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):
-        """Register panel for homeassistant."""
-        def create_panel_response(build_type):
-            """Create a function to generate a response."""
-            path = Path(__file__).parent.joinpath(
-                f"panel/{build_type}.html")
-            return lambda request: web.FileResponse(path)
+    def _register_panel(self) -> None:
+        """Register panel for Home Assistant."""
+        panel_dir = Path(__file__).parent.joinpath("panel")
+        self.webapp.add_routes([web.static('/app', panel_dir)])
 
-        # This route is for backwards compatibility with HA < 0.58
-        self.webapp.router.add_get(
-            '/panel', create_panel_response('hassio-main-es5'))
-
-        # This route is for backwards compatibility with HA 0.58 - 0.61
-        self.webapp.router.add_get(
-            '/panel_es5', create_panel_response('hassio-main-es5'))
-        self.webapp.router.add_get(
-            '/panel_latest', create_panel_response('hassio-main-latest'))
-
-        # This route is for HA > 0.61
-        self.webapp.router.add_get(
-            '/app-es5/index.html', create_panel_response('index'))
-        self.webapp.router.add_get(
-            '/app-es5/hassio-app.html', create_panel_response('hassio-app'))
-
-    async def start(self):
-        """Run rest api webserver."""
-        self._handler = self.webapp.make_handler(loop=self._loop)
+    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.shutdown(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,26 +1,93 @@
-"""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 .utils import api_process, api_process_raw, api_validate
+from ..addons import AnyAddon
+from ..addons.utils import rating_security
 from ..const import (
-    ATTR_VERSION, ATTR_LAST_VERSION, ATTR_STATE, ATTR_BOOT, ATTR_OPTIONS,
-    ATTR_URL, ATTR_DESCRIPTON, ATTR_DETACHED, ATTR_NAME, ATTR_REPOSITORY,
-    ATTR_BUILD, ATTR_AUTO_UPDATE, ATTR_NETWORK, ATTR_HOST_NETWORK, ATTR_SLUG,
-    ATTR_SOURCE, ATTR_REPOSITORIES, ATTR_ADDONS, ATTR_ARCH, ATTR_MAINTAINER,
-    ATTR_INSTALLED, ATTR_LOGO, ATTR_WEBUI, ATTR_DEVICES, ATTR_PRIVILEGED,
-    ATTR_AUDIO, ATTR_AUDIO_INPUT, ATTR_AUDIO_OUTPUT, ATTR_HASSIO_API,
-    ATTR_GPIO, ATTR_HOMEASSISTANT_API, ATTR_STDIN, BOOT_AUTO, BOOT_MANUAL,
-    ATTR_CHANGELOG, ATTR_HOST_IPC, ATTR_HOST_DBUS, ATTR_LONG_DESCRIPTION,
-    ATTR_CPU_PERCENT, ATTR_MEMORY_LIMIT, ATTR_MEMORY_USAGE, ATTR_NETWORK_TX,
-    ATTR_NETWORK_RX, ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_ICON, ATTR_SERVICES,
+    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,
-    CONTENT_TYPE_PNG, CONTENT_TYPE_BINARY, CONTENT_TYPE_TEXT)
+    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_PANEL,
+    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,
+    STATE_NONE,
+)
 from ..coresys import CoreSysAttributes
-from ..validate import DOCKER_PORTS
+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__)
 
@@ -33,43 +100,49 @@ SCHEMA_OPTIONS = vol.Schema({
     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,
+    vol.Optional(ATTR_INGRESS_PANEL): vol.Boolean(),
+})
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_SECURITY = vol.Schema({
+    vol.Optional(ATTR_PROTECTED): vol.Boolean(),
 })
 
 
 class APIAddons(CoreSysAttributes):
-    """Handle rest api for addons functions."""
+    """Handle RESTful API for add-on functions."""
 
-    def _extract_addon(self, request, check_installed=True):
-        """Return addon and if not exists trow a exception."""
-        addon = self._addons.get(request.match_info.get('addon'))
+    def _extract_addon(self, request: web.Request, check_installed: bool = True) -> AnyAddon:
+        """Return addon, throw an exception it it doesn't exist."""
+        addon_slug = request.match_info.get('addon')
+
+        # Lookup itself
+        if addon_slug == 'self':
+            return request.get(REQUEST_FROM)
+
+        addon = self.sys_addons.get(addon_slug)
         if not addon:
-            raise RuntimeError("Addon not exists")
+            raise APIError("Addon does not exist")
 
         if check_installed and not addon.is_installed:
-            raise RuntimeError("Addon is not installed")
+            raise APIError("Addon is not installed")
 
         return addon
 
-    @staticmethod
-    def _pretty_devices(addon):
-        """Return a simplified device list."""
-        dev_list = addon.devices
-        if not dev_list:
-            return None
-        return [row.split(':')[0] for row in dev_list]
-
     @api_process
-    async def list(self, request):
-        """Return all addons / repositories ."""
+    async def list(self, request: web.Request) -> Dict[str, Any]:
+        """Return all add-ons or repositories."""
         data_addons = []
-        for addon in self._addons.list_addons:
+        for addon in self.sys_addons.all:
             data_addons.append({
                 ATTR_NAME: addon.name,
                 ATTR_SLUG: addon.slug,
                 ATTR_DESCRIPTON: addon.description,
-                ATTR_VERSION: addon.last_version,
-                ATTR_INSTALLED: addon.version_installed,
-                ATTR_ARCH: addon.supported_arch,
+                ATTR_VERSION: addon.latest_version,
+                ATTR_INSTALLED: addon.version if addon.is_installed else None,
+                ATTR_AVAILABLE: addon.available,
                 ATTR_DETACHED: addon.is_detached,
                 ATTR_REPOSITORY: addon.repository,
                 ATTR_BUILD: addon.need_build,
@@ -79,7 +152,7 @@ class APIAddons(CoreSysAttributes):
             })
 
         data_repositories = []
-        for repository in self._addons.list_repositories:
+        for repository in self.sys_store.all:
             data_repositories.append({
                 ATTR_SLUG: repository.slug,
                 ATTR_NAME: repository.name,
@@ -94,60 +167,97 @@ class APIAddons(CoreSysAttributes):
         }
 
     @api_process
-    async def reload(self, request):
-        """Reload all addons data."""
-        await asyncio.shield(self._addons.reload(), loop=self._loop)
-        return True
+    async def reload(self, request: web.Request) -> None:
+        """Reload all add-on data from store."""
+        await asyncio.shield(self.sys_store.reload())
 
     @api_process
-    async def info(self, request):
-        """Return addon information."""
+    async def info(self, request: web.Request) -> Dict[str, Any]:
+        """Return add-on information."""
         addon = self._extract_addon(request, check_installed=False)
 
-        return {
+        data = {
             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_AUTO_UPDATE: None,
             ATTR_REPOSITORY: addon.repository,
-            ATTR_LAST_VERSION: addon.last_version,
-            ATTR_STATE: await addon.state(),
+            ATTR_VERSION: None,
+            ATTR_LAST_VERSION: addon.latest_version,
+            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_STATE: STATE_NONE,
             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_DEVICES: self._pretty_devices(addon),
+            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_WEBUI: None,
             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: addon.services,
+            ATTR_AUDIO_INPUT: None,
+            ATTR_AUDIO_OUTPUT: None,
+            ATTR_SERVICES: _pretty_services(addon),
             ATTR_DISCOVERY: addon.discovery,
+            ATTR_IP_ADDRESS: None,
+            ATTR_INGRESS: addon.with_ingress,
+            ATTR_INGRESS_ENTRY: None,
+            ATTR_INGRESS_URL: None,
+            ATTR_INGRESS_PORT: None,
+            ATTR_INGRESS_PANEL: None,
         }
 
+        if addon.is_installed:
+            data.update({
+                ATTR_STATE: await addon.state(),
+                ATTR_WEBUI: addon.webui,
+                ATTR_INGRESS_ENTRY: addon.ingress_entry,
+                ATTR_INGRESS_URL: addon.ingress_url,
+                ATTR_INGRESS_PORT: addon.ingress_port,
+                ATTR_INGRESS_PANEL: addon.ingress_panel,
+                ATTR_AUDIO_INPUT: addon.audio_input,
+                ATTR_AUDIO_OUTPUT: addon.audio_output,
+                ATTR_AUTO_UPDATE: addon.auto_update,
+                ATTR_IP_ADDRESS: str(addon.ip_address),
+                ATTR_VERSION: addon.version,
+            })
+
+        return data
+
     @api_process
-    async def options(self, request):
-        """Store user options for addon."""
+    async def options(self, request: web.Request) -> None:
+        """Store user options for add-on."""
         addon = self._extract_addon(request)
 
         addon_schema = SCHEMA_OPTIONS.extend({
             vol.Optional(ATTR_OPTIONS): vol.Any(None, addon.schema),
         })
-
         body = await api_validate(addon_schema, request)
 
         if ATTR_OPTIONS in body:
@@ -162,19 +272,30 @@ class APIAddons(CoreSysAttributes):
             addon.audio_input = body[ATTR_AUDIO_INPUT]
         if ATTR_AUDIO_OUTPUT in body:
             addon.audio_output = body[ATTR_AUDIO_OUTPUT]
+        if ATTR_INGRESS_PANEL in body:
+            addon.ingress_panel = body[ATTR_INGRESS_PANEL]
+            await self.sys_ingress.update_hass_panel(addon)
 
-        addon.save_data()
-        return True
+        addon.save_persist()
 
     @api_process
-    async def stats(self, 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()
 
-        if not stats:
-            raise RuntimeError("No stats available")
-
         return {
             ATTR_CPU_PERCENT: stats.cpu_percent,
             ATTR_MEMORY_USAGE: stats.memory_usage,
@@ -186,20 +307,20 @@ class APIAddons(CoreSysAttributes):
         }
 
     @api_process
-    def install(self, request):
-        """Install addon."""
+    def install(self, request: web.Request) -> Awaitable[None]:
+        """Install add-on."""
         addon = self._extract_addon(request, check_installed=False)
-        return asyncio.shield(addon.install(), loop=self._loop)
+        return asyncio.shield(addon.install())
 
     @api_process
-    def uninstall(self, request):
-        """Uninstall addon."""
+    def uninstall(self, request: web.Request) -> Awaitable[None]:
+        """Uninstall add-on."""
         addon = self._extract_addon(request)
-        return asyncio.shield(addon.uninstall(), loop=self._loop)
+        return asyncio.shield(addon.uninstall())
 
     @api_process
-    def start(self, request):
-        """Start addon."""
+    def start(self, request: web.Request) -> Awaitable[None]:
+        """Start add-on."""
         addon = self._extract_addon(request)
 
         # check options
@@ -207,83 +328,99 @@ class APIAddons(CoreSysAttributes):
         try:
             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 asyncio.shield(addon.start(), loop=self._loop)
+        return asyncio.shield(addon.start())
 
     @api_process
-    def stop(self, request):
-        """Stop addon."""
+    def stop(self, request: web.Request) -> Awaitable[None]:
+        """Stop add-on."""
         addon = self._extract_addon(request)
-        return asyncio.shield(addon.stop(), loop=self._loop)
+        return asyncio.shield(addon.stop())
 
     @api_process
-    def update(self, request):
-        """Update addon."""
+    def update(self, request: web.Request) -> Awaitable[None]:
+        """Update add-on."""
         addon = self._extract_addon(request)
 
-        if addon.last_version == addon.version_installed:
-            raise RuntimeError("No update available!")
+        if addon.latest_version == addon.version:
+            raise APIError("No update available!")
 
-        return asyncio.shield(addon.update(), loop=self._loop)
+        return asyncio.shield(addon.update())
 
     @api_process
-    def restart(self, request):
-        """Restart addon."""
+    def restart(self, request: web.Request) -> Awaitable[None]:
+        """Restart add-on."""
         addon = self._extract_addon(request)
-        return asyncio.shield(addon.restart(), loop=self._loop)
+        return asyncio.shield(addon.restart())
 
     @api_process
-    def rebuild(self, request):
-        """Rebuild local build addon."""
+    def rebuild(self, request: web.Request) -> Awaitable[None]:
+        """Rebuild local build add-on."""
         addon = self._extract_addon(request)
         if not addon.need_build:
-            raise RuntimeError("Only local build addons are supported")
+            raise APIError("Only local build addons are supported")
 
-        return asyncio.shield(addon.rebuild(), loop=self._loop)
+        return asyncio.shield(addon.rebuild())
 
     @api_process_raw(CONTENT_TYPE_BINARY)
-    def logs(self, request):
-        """Return logs from addon."""
+    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):
-        """Return icon from addon."""
+    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 RuntimeError("No icon found!")
+            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):
-        """Return logo from addon."""
+    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 RuntimeError("No logo found!")
+            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):
-        """Return changelog from addon."""
+    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 RuntimeError("No changelog found!")
+            raise APIError("No changelog found!")
 
         with addon.path_changelog.open('r') as changelog:
             return changelog.read()
 
     @api_process
-    async def stdin(self, request):
-        """Write to stdin of addon."""
+    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 RuntimeError("STDIN not supported by addon")
+            raise APIError("STDIN not supported by add-on")
 
         data = await request.read()
-        return await asyncio.shield(addon.write_stdin(data), loop=self._loop)
+        await asyncio.shield(addon.write_stdin(data))
+
+
+def _pretty_devices(addon: AnyAddon) -> 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: AnyAddon) -> 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

@@ -1,43 +1,58 @@
-"""Init file for HassIO network rest api."""
-
+"""Init file for Hass.io network RESTful API."""
 import voluptuous as vol
 
 from .utils import api_process, api_validate
 from ..const import (
-    ATTR_PROVIDER, ATTR_UUID, ATTR_COMPONENT, ATTR_PLATFORM, ATTR_CONFIG,
-    ATTR_DISCOVERY, REQUEST_FROM)
+    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_COMPONENT): vol.Coerce(str),
-    vol.Optional(ATTR_PLATFORM): vol.Any(None, vol.Coerce(str)),
-    vol.Optional(ATTR_CONFIG): vol.Any(None, dict),
-})
+SCHEMA_DISCOVERY = vol.Schema(
+    {
+        vol.Required(ATTR_SERVICE): valid_discovery_service,
+        vol.Optional(ATTR_CONFIG): vol.Maybe(dict),
+    }
+)
 
 
 class APIDiscovery(CoreSysAttributes):
-    """Handle rest api for discovery functions."""
+    """Handle RESTful API for discovery functions."""
 
     def _extract_message(self, request):
         """Extract discovery message from URL."""
-        message = self._services.discovery.get(request.match_info.get('uuid'))
+        message = self.sys_discovery.get(request.match_info.get("uuid"))
         if not message:
-            raise RuntimeError("Discovery message not found")
+            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._services.discovery.list_messages:
-            discovery.append({
-                ATTR_PROVIDER: message.provider,
-                ATTR_UUID: message.uuid,
-                ATTR_COMPONENT: message.component,
-                ATTR_PLATFORM: message.platform,
-                ATTR_CONFIG: message.config,
-            })
+        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}
 
@@ -45,8 +60,14 @@ class APIDiscovery(CoreSysAttributes):
     async def set_discovery(self, request):
         """Write data into a discovery pipeline."""
         body = await api_validate(SCHEMA_DISCOVERY, request)
-        message = self._services.discovery.send(
-            provider=request[REQUEST_FROM], **body)
+        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}
 
@@ -55,11 +76,13 @@ class APIDiscovery(CoreSysAttributes):
         """Read data into a discovery message."""
         message = self._extract_message(request)
 
+        # HomeAssistant?
+        self._check_permission_ha(request)
+
         return {
-            ATTR_PROVIDER: message.provider,
+            ATTR_ADDON: message.addon,
+            ATTR_SERVICE: message.service,
             ATTR_UUID: message.uuid,
-            ATTR_COMPONENT: message.component,
-            ATTR_PLATFORM: message.platform,
             ATTR_CONFIG: message.config,
         }
 
@@ -67,6 +90,11 @@ class APIDiscovery(CoreSysAttributes):
     async def del_discovery(self, request):
         """Delete data into a discovery message."""
         message = self._extract_message(request)
+        addon = request[REQUEST_FROM]
 
-        self._services.discovery.remove(message)
+        # 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,95 +1,121 @@
-"""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 .utils import api_process, api_process_raw, api_validate
 from ..const import (
-    ATTR_VERSION, ATTR_LAST_VERSION, ATTR_IMAGE, ATTR_CUSTOM, ATTR_BOOT,
-    ATTR_PORT, ATTR_PASSWORD, ATTR_SSL, ATTR_WATCHDOG, ATTR_CPU_PERCENT,
-    ATTR_MEMORY_USAGE, ATTR_MEMORY_LIMIT, ATTR_NETWORK_RX, ATTR_NETWORK_TX,
-    ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_WAIT_BOOT, CONTENT_TYPE_BINARY)
+    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 ..validate import NETWORK_PORT, DOCKER_IMAGE
+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__)
 
-
 # pylint: disable=no-value-for-parameter
-SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_BOOT): vol.Boolean(),
-    vol.Inclusive(ATTR_IMAGE, 'custom_hass'):
-        vol.Any(None, 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.Any(None, 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)),
-})
+SCHEMA_OPTIONS = vol.Schema(
+    {
+        vol.Optional(ATTR_BOOT): vol.Boolean(),
+        vol.Inclusive(ATTR_IMAGE, "custom_hass"): vol.Maybe(DOCKER_IMAGE),
+        vol.Inclusive(ATTR_LAST_VERSION, "custom_hass"): vol.Maybe(vol.Coerce(str)),
+        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),
-})
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 
 
 class APIHomeAssistant(CoreSysAttributes):
-    """Handle rest api for homeassistant functions."""
+    """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."""
         return {
-            ATTR_VERSION: self._homeassistant.version,
-            ATTR_LAST_VERSION: self._homeassistant.last_version,
-            ATTR_IMAGE: self._homeassistant.image,
-            ATTR_CUSTOM: self._homeassistant.is_custom_image,
-            ATTR_BOOT: self._homeassistant.boot,
-            ATTR_PORT: self._homeassistant.api_port,
-            ATTR_SSL: self._homeassistant.api_ssl,
-            ATTR_WATCHDOG: self._homeassistant.watchdog,
-            ATTR_WAIT_BOOT: self._homeassistant.wait_boot,
+            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,
         }
 
     @api_process
-    async def options(self, request):
-        """Set homeassistant options."""
+    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._homeassistant.image = body[ATTR_IMAGE]
-            self._homeassistant.last_version = body[ATTR_LAST_VERSION]
+            self.sys_homeassistant.image = body[ATTR_IMAGE]
+            self.sys_homeassistant.latest_version = body[ATTR_LAST_VERSION]
 
         if ATTR_BOOT in body:
-            self._homeassistant.boot = body[ATTR_BOOT]
+            self.sys_homeassistant.boot = body[ATTR_BOOT]
 
         if ATTR_PORT in body:
-            self._homeassistant.api_port = body[ATTR_PORT]
+            self.sys_homeassistant.api_port = body[ATTR_PORT]
 
         if ATTR_PASSWORD in body:
-            self._homeassistant.api_password = body[ATTR_PASSWORD]
+            self.sys_homeassistant.api_password = body[ATTR_PASSWORD]
+            self.sys_homeassistant.refresh_token = None
 
         if ATTR_SSL in body:
-            self._homeassistant.api_ssl = body[ATTR_SSL]
+            self.sys_homeassistant.api_ssl = body[ATTR_SSL]
 
         if ATTR_WATCHDOG in body:
-            self._homeassistant.watchdog = body[ATTR_WATCHDOG]
+            self.sys_homeassistant.watchdog = body[ATTR_WATCHDOG]
 
         if ATTR_WAIT_BOOT in body:
-            self._homeassistant.wait_boot = body[ATTR_WAIT_BOOT]
+            self.sys_homeassistant.wait_boot = body[ATTR_WAIT_BOOT]
 
-        self._homeassistant.save_data()
-        return True
+        if ATTR_REFRESH_TOKEN in body:
+            self.sys_homeassistant.refresh_token = body[ATTR_REFRESH_TOKEN]
+            self.sys_homeassistant.api_password = None
+
+        self.sys_homeassistant.save_data()
 
     @api_process
-    async def stats(self, request):
+    async def stats(self, request: web.Request) -> Dict[Any, str]:
         """Return resource information."""
-        stats = await self._homeassistant.stats()
+        stats = await self.sys_homeassistant.stats()
         if not stats:
-            raise RuntimeError("No stats available")
+            raise APIError("No stats available")
 
         return {
             ATTR_CPU_PERCENT: stats.cpu_percent,
@@ -102,42 +128,41 @@ class APIHomeAssistant(CoreSysAttributes):
         }
 
     @api_process
-    async def update(self, request):
-        """Update homeassistant."""
+    async def update(self, request: web.Request) -> None:
+        """Update Home Assistant."""
         body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self._homeassistant.last_version)
+        version = body.get(ATTR_VERSION, self.sys_homeassistant.latest_version)
 
-        if version == self._homeassistant.version:
-            raise RuntimeError("Version {} is already in use".format(version))
-
-        return await asyncio.shield(
-            self._homeassistant.update(version), loop=self._loop)
+        await asyncio.shield(self.sys_homeassistant.update(version))
 
     @api_process
-    def stop(self, request):
-        """Stop homeassistant."""
-        return asyncio.shield(self._homeassistant.stop(), loop=self._loop)
+    def stop(self, request: web.Request) -> Coroutine:
+        """Stop Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.stop())
 
     @api_process
-    def start(self, request):
-        """Start homeassistant."""
-        return asyncio.shield(self._homeassistant.start(), loop=self._loop)
+    def start(self, request: web.Request) -> Coroutine:
+        """Start Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.start())
 
     @api_process
-    def restart(self, request):
-        """Restart homeassistant."""
-        return asyncio.shield(self._homeassistant.restart(), loop=self._loop)
+    def restart(self, request: web.Request) -> Coroutine:
+        """Restart Home Assistant."""
+        return asyncio.shield(self.sys_homeassistant.restart())
+
+    @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):
-        """Return homeassistant docker logs."""
-        return self._homeassistant.logs()
+    def logs(self, request: web.Request) -> Coroutine:
+        """Return Home Assistant Docker logs."""
+        return self.sys_homeassistant.logs()
 
     @api_process
-    async def check(self, request):
-        """Check config of homeassistant."""
-        result = await self._homeassistant.check_config()
+    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 RuntimeError(result.log)
-
-        return True
+            raise APIError(result.log)

hassio/api/host.py

@@ -1,92 +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 .utils import api_process_hostcontrol, api_process, api_validate
+from .utils import api_process, api_validate
 from ..const import (
-    ATTR_VERSION, ATTR_LAST_VERSION, ATTR_TYPE, ATTR_HOSTNAME, ATTR_FEATURES,
-    ATTR_OS, ATTR_SERIAL, ATTR_INPUT, ATTR_DISK, ATTR_AUDIO, ATTR_AUDIO_INPUT,
-    ATTR_AUDIO_OUTPUT, ATTR_GPIO)
+    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
-from ..validate import ALSA_CHANNEL
 
 _LOGGER = logging.getLogger(__name__)
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
-})
+SERVICE = 'service'
 
 SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_CHANNEL,
-    vol.Optional(ATTR_AUDIO_INPUT): ALSA_CHANNEL,
+    vol.Optional(ATTR_HOSTNAME): vol.Coerce(str),
 })
 
 
 class APIHost(CoreSysAttributes):
-    """Handle rest api for host functions."""
+    """Handle RESTful API for host functions."""
 
     @api_process
     async def info(self, request):
         """Return host information."""
         return {
-            ATTR_TYPE: self._host_control.type,
-            ATTR_VERSION: self._host_control.version,
-            ATTR_LAST_VERSION: self._host_control.last_version,
-            ATTR_FEATURES: self._host_control.features,
-            ATTR_HOSTNAME: self._host_control.hostname,
-            ATTR_OS: self._host_control.os_info,
+            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,
         }
 
     @api_process
     async def options(self, request):
-        """Process host options."""
+        """Edit host settings."""
         body = await api_validate(SCHEMA_OPTIONS, request)
 
-        if ATTR_AUDIO_OUTPUT in body:
-            self._config.audio_output = body[ATTR_AUDIO_OUTPUT]
-        if ATTR_AUDIO_INPUT in body:
-            self._config.audio_input = body[ATTR_AUDIO_INPUT]
-
-        self._config.save_data()
-        return True
-
-    @api_process_hostcontrol
-    def reboot(self, request):
-        """Reboot host."""
-        return self._host_control.reboot()
-
-    @api_process_hostcontrol
-    def shutdown(self, request):
-        """Poweroff host."""
-        return self._host_control.shutdown()
-
-    @api_process_hostcontrol
-    async def reload(self, request):
-        """Reload host data."""
-        await self._host_control.load()
-        return True
-
-    @api_process_hostcontrol
-    async def update(self, request):
-        """Update host OS."""
-        body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self._host_control.last_version)
-
-        if version == self._host_control.version:
-            raise RuntimeError(f"Version {version} is already in use")
-
-        return await asyncio.shield(
-            self._host_control.update(version=version), loop=self._loop)
+        # hostname
+        if ATTR_HOSTNAME in body:
+            await asyncio.shield(
+                self.sys_host.control.set_hostname(body[ATTR_HOSTNAME]))
 
     @api_process
-    async def hardware(self, request):
-        """Return local hardware infos."""
+    def reboot(self, request):
+        """Reboot host."""
+        return asyncio.shield(self.sys_host.control.reboot())
+
+    @api_process
+    def shutdown(self, request):
+        """Poweroff host."""
+        return asyncio.shield(self.sys_host.control.shutdown())
+
+    @api_process
+    def reload(self, request):
+        """Reload host data."""
+        return asyncio.shield(self.sys_host.reload())
+
+    @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 {
-            ATTR_SERIAL: list(self._hardware.serial_devices),
-            ATTR_INPUT: list(self._hardware.input_devices),
-            ATTR_DISK: list(self._hardware.disk_devices),
-            ATTR_GPIO: list(self._hardware.gpio_devices),
-            ATTR_AUDIO: self._hardware.audio_devices,
+            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,40 @@
+"""Init file for Hass.io info RESTful API."""
+import logging
+from typing import Any, Dict
+
+from aiohttp import web
+
+from ..const import (
+    ATTR_ARCH,
+    ATTR_CHANNEL,
+    ATTR_HASSOS,
+    ATTR_HOMEASSISTANT,
+    ATTR_HOSTNAME,
+    ATTR_LOGGING,
+    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: web.Request) -> Dict[str, Any]:
+        """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,
+            ATTR_LOGGING: self.sys_config.logging,
+        }

hassio/api/ingress.py

@@ -0,0 +1,258 @@
+"""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_ADMIN,
+    ATTR_ICON,
+    ATTR_SESSION,
+    ATTR_TITLE,
+    ATTR_PANELS,
+    ATTR_ENABLE,
+    COOKIE_INGRESS,
+    HEADER_TOKEN,
+    REQUEST_FROM,
+)
+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 panels(self, request: web.Request) -> Dict[str, Any]:
+        """Create a list of panel data."""
+        addons = {}
+        for addon in self.sys_ingress.addons:
+            addons[addon.slug] = {
+                ATTR_TITLE: addon.panel_title,
+                ATTR_ICON: addon.panel_icon,
+                ATTR_ADMIN: addon.panel_admin,
+                ATTR_ENABLE: addon.ingress_panel,
+            }
+
+        return {ATTR_PANELS: addons}
+
+    @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 (
+        "upgrade" in headers.get(hdrs.CONNECTION, "").lower()
+        and headers.get(hdrs.UPGRADE, "").lower() == "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,38 +0,0 @@
-"""Init file for HassIO network rest api."""
-import logging
-
-import voluptuous as vol
-
-from .utils import api_process, api_process_hostcontrol, api_validate
-from ..const import ATTR_HOSTNAME
-from ..coresys import CoreSysAttributes
-
-_LOGGER = logging.getLogger(__name__)
-
-
-SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_HOSTNAME): vol.Coerce(str),
-})
-
-
-class APINetwork(CoreSysAttributes):
-    """Handle rest api for network functions."""
-
-    @api_process
-    async def info(self, request):
-        """Show network settings."""
-        return {
-            ATTR_HOSTNAME: self._host_control.hostname,
-        }
-
-    @api_process_hostcontrol
-    async def options(self, request):
-        """Edit network settings."""
-        body = await api_validate(SCHEMA_OPTIONS, request)
-
-        # hostname
-        if ATTR_HOSTNAME in body:
-            if self._host_control.hostname != body[ATTR_HOSTNAME]:
-                await self._host_control.set_hostname(body[ATTR_HOSTNAME])
-
-        return True

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:"b60fb48c5280275dd7e2",7:"3a63ad36bccf4ea567fa",8:"a571dfa106202cc57af6",9:"a7e5fb452cd1b3a5faef",10:"b3340b3df270d20af4a1",11:"6e9c87e51920a9c354e5",12:"1b30ffdc501071af245c",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

@@ -11,27 +11,28 @@
         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.head.appendChild(e);
-      }
-      if (!window.parent.HASS_DEV) {
-        addScript('/frontend_es5/custom-elements-es5-adapter.js');
-      }
-      var webComponentsSupported = (
-        'customElements' in window &&
-        'import' in document.createElement('link') &&
-        'content' in document.createElement('template'));
-      if (!webComponentsSupported) {
-        addScript('/static/webcomponents-lite.js');
-      }
+    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'>
-    <link rel='import' href='/static/mdi.html' async>
   </body>
 </html>

hassio/api/proxy.py

@@ -1,69 +1,75 @@
-"""Utils for HomeAssistant Proxy."""
+"""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, HTTPInternalServerError
-from aiohttp.hdrs import CONTENT_TYPE
+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."""
+    """API Proxy for Home Assistant."""
 
     def _check_access(self, request):
         """Check the Hass.io token."""
-        hassio_token = request.headers.get(HEADER_HA_ACCESS)
-        addon = self._addons.from_uuid(hassio_token)
-
-        if not addon:
-            _LOGGER.warning("Unknown Home-Assistant API access!")
+        if AUTHORIZATION in request.headers:
+            bearer = request.headers[AUTHORIZATION]
+            hassio_token = bearer.split(' ')[-1]
         else:
-            _LOGGER.info("%s access from %s", request.path, addon.slug)
+            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."""
-        url = f"{self._homeassistant.api_url}/api/{path}"
-
+        """Return a client request with proxy origin for Home Assistant."""
         try:
-            data = None
-            headers = {}
-            method = getattr(self._websession_ssl, request.method.lower())
-            params = request.query or None
-
             # read data
-            with async_timeout.timeout(30, loop=self._loop):
+            with async_timeout.timeout(30):
                 data = await request.read()
 
             if data:
-                headers.update({CONTENT_TYPE: request.content_type})
+                content_type = request.content_type
+            else:
+                content_type = None
 
-            # need api password?
-            if self._homeassistant.api_password:
-                headers = {HEADER_HA_ACCESS: self._homeassistant.api_password}
-
-            # reset headers
-            if not headers:
-                headers = None
-
-            client = await method(
-                url, data=data, headers=headers, timeout=timeout,
-                params=params
-            )
-
-            return client
+            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)
-
+            _LOGGER.error("Client error on API %s request %s", path, err)
         except asyncio.TimeoutError:
-            _LOGGER.error("Client timeout error on API request %s.", path)
+            _LOGGER.error("Client timeout error on API request %s", path)
 
         raise HTTPBadGateway()
 
@@ -71,125 +77,146 @@ class APIProxy(CoreSysAttributes):
         """Proxy HomeAssistant EventStream Requests."""
         self._check_access(request)
 
-        _LOGGER.info("Home-Assistant EventStream start")
-        client = await self._api_client(request, 'stream', timeout=None)
+        _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)
 
-        response = web.StreamResponse()
-        response.content_type = request.headers.get(CONTENT_TYPE)
-        try:
-            await response.prepare(request)
-            while True:
-                data = await client.content.read(10)
-                if not data:
-                    await response.write_eof()
-                    break
-                response.write(data)
+            except (aiohttp.ClientError, aiohttp.ClientPayloadError):
+                pass
 
-        except aiohttp.ClientError:
-            await response.write_eof()
-
-        except asyncio.CancelledError:
-            pass
-
-        finally:
-            client.close()
-            _LOGGER.info("Home-Assistant EventStream close")
-
-        return response
+            _LOGGER.info("Home Assistant EventStream close")
+            return response
 
     async def api(self, request):
-        """Proxy HomeAssistant API Requests."""
+        """Proxy Home Assistant API Requests."""
         self._check_access(request)
 
         # Normal request
         path = request.match_info.get('path', '')
-        client = await self._api_client(request, path)
-
-        data = await client.read()
-        return web.Response(
-            body=data,
-            status=client.status,
-            content_type=client.content_type
-        )
+        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._homeassistant.api_url}/api/websocket"
+        """Initialize a WebSocket API connection."""
+        url = f"{self.sys_homeassistant.api_url}/api/websocket"
 
         try:
-            client = await self._websession_ssl.ws_connect(
-                url, heartbeat=60, verify_ssl=False)
+            client = await self.sys_websession_ssl.ws_connect(
+                url, heartbeat=30, verify_ssl=False)
 
-            # handle authentication
-            for _ in range(2):
-                data = await client.receive_json()
-                if data.get('type') == 'auth_ok':
-                    return client
-                elif data.get('type') == 'auth_required':
-                    await client.send_json({
-                        'type': 'auth',
-                        'api_password': self._homeassistant.api_password,
-                    })
+            # Handle authentication
+            data = await client.receive_json()
 
-            _LOGGER.error("Authentication to Home-Assistant websocket")
+            if data.get('type') == 'auth_ok':
+                return client
 
-        except (aiohttp.ClientError, RuntimeError) as err:
-            _LOGGER.error("Client error on websocket API %s.", err)
+            if data.get('type') != 'auth_required':
+                # Invalid protocol
+                _LOGGER.error(
+                    "Got unexpected response from HA WebSocket: %s", data)
+                raise APIError()
 
-        raise HTTPBadGateway()
+            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 initialze")
+        """Initialize a WebSocket API connection."""
+        _LOGGER.info("Home Assistant WebSocket API request initialize")
 
         # init server
-        server = web.WebSocketResponse(heartbeat=60)
+        server = web.WebSocketResponse(heartbeat=30)
         await server.prepare(request)
 
         # handle authentication
         try:
             await server.send_json({
                 'type': 'auth_required',
-                'ha_version': self._homeassistant.version,
+                'ha_version': self.sys_homeassistant.version,
             })
 
             # Check API access
             response = await server.receive_json()
-            hassio_token = response.get('api_password')
-            addon = self._addons.from_uuid(hassio_token)
+            hassio_token = response.get('api_password') or response.get('access_token')
+            addon = self.sys_addons.from_token(hassio_token)
 
-            if not addon:
-                _LOGGER.warning("Unauthorized websocket access!")
-            else:
-                _LOGGER.info("Websocket access from %s", addon.slug)
+            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._homeassistant.version,
+                'ha_version': self.sys_homeassistant.version,
             })
         except (RuntimeError, ValueError) as err:
             _LOGGER.error("Can't initialize handshake: %s", err)
-            raise HTTPInternalServerError() from None
+            return server
 
         # init connection to hass
-        client = await self._websocket_client()
+        try:
+            client = await self._websocket_client()
+        except APIError:
+            return server
 
-        _LOGGER.info("Home-Assistant Websocket API request running")
+        _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 = asyncio.ensure_future(
-                        client.receive_str(), loop=self._loop)
+                    client_read = self.sys_create_task(
+                        client.receive_str())
                 if not server_read:
-                    server_read = asyncio.ensure_future(
-                        server.receive_str(), loop=self._loop)
+                    server_read = self.sys_create_task(
+                        server.receive_str())
 
                 # wait until data need to be processed
                 await asyncio.wait(
                     [client_read, server_read],
-                    loop=self._loop, return_when=asyncio.FIRST_COMPLETED
+                    return_when=asyncio.FIRST_COMPLETED
                 )
 
                 # server
@@ -207,8 +234,8 @@ class APIProxy(CoreSysAttributes):
         except asyncio.CancelledError:
             pass
 
-        except RuntimeError as err:
-            _LOGGER.info("Home-Assistant Websocket API error: %s", err)
+        except (RuntimeError, ConnectionError, TypeError) as err:
+            _LOGGER.info("Home Assistant WebSocket API error: %s", err)
 
         finally:
             if client_read:
@@ -217,8 +244,10 @@ class APIProxy(CoreSysAttributes):
                 server_read.cancel()
 
             # close connections
-            await client.close()
-            await server.close()
+            if not client.closed:
+                await client.close()
+            if not server.closed:
+                await server.close()
 
-        _LOGGER.info("Home-Assistant Websocket API connection is closed")
+        _LOGGER.info("Home Assistant WebSocket API connection is closed")
         return server

hassio/api/security.py

@@ -3,48 +3,145 @@ import logging
 import re
 
 from aiohttp.web import middleware
-from aiohttp.web_exceptions import HTTPUnauthorized
+from aiohttp.web_exceptions import HTTPUnauthorized, HTTPForbidden
 
-from ..const import HEADER_TOKEN, REQUEST_FROM
+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__)
 
-NO_SECURITY_CHECK = set((
-    re.compile(r"^/homeassistant/api/.*$"),
-    re.compile(r"^/homeassistant/websocket$"),
-    re.compile(r"^/supervisor/ping$"),
-))
+# 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
 
 
-@middleware
-async def security_layer(request, handler):
-    """Check security access of this layer."""
-    coresys = request.app['coresys']
-    hassio_token = request.headers.get(HEADER_TOKEN)
+class SecurityMiddleware(CoreSysAttributes):
+    """Security middleware functions."""
 
-    # Ignore security check
-    for rule in NO_SECURITY_CHECK:
-        if rule.match(request.path):
+    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)
 
-    # Need to be removed later
-    if not hassio_token:
-        _LOGGER.warning("Invalid token for access %s", request.path)
-        request[REQUEST_FROM] = 'UNKNOWN'
-        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 == coresys.homeassistant.uuid:
-        _LOGGER.debug("%s access from Home-Assistant", request.path)
-        request[REQUEST_FROM] = 'homeassistant'
-        return await handler(request)
+        # Home-Assistant
+        if hassio_token == self.sys_homeassistant.hassio_token:
+            _LOGGER.debug("%s access from Home Assistant", request.path)
+            request_from = self.sys_homeassistant
 
-    # Add-on
-    addon = coresys.addons.from_uuid(hassio_token)
-    if addon:
-        _LOGGER.info("%s access from %s", request.path, addon.slug)
-        request[REQUEST_FROM] = addon.slug
-        return await handler(request)
+        # Host
+        if hassio_token == self.sys_machine_id:
+            _LOGGER.debug("%s access from Host", request.path)
+            request_from = self.sys_host
 
-    raise HTTPUnauthorized()
+        # 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

@@ -1,19 +1,21 @@
-"""Init file for HassIO network rest api."""
+"""Init file for Hass.io network RESTful API."""
 
 from .utils import api_process, api_validate
 from ..const import (
-    ATTR_AVAILABLE, ATTR_PROVIDER, ATTR_SLUG, ATTR_SERVICES, REQUEST_FROM)
+    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 rest api for services functions."""
+    """Handle RESTful API for services functions."""
 
     def _extract_service(self, request):
-        """Return service and if not exists trow a exception."""
-        service = self._services.get(request.match_info.get('service'))
+        """Return service, throw an exception if it doesn't exist."""
+        service = self.sys_services.get(request.match_info.get('service'))
         if not service:
-            raise RuntimeError("Service not exists")
+            raise APIError("Service does not exist")
 
         return service
 
@@ -21,11 +23,11 @@ class APIServices(CoreSysAttributes):
     async def list(self, request):
         """Show register services."""
         services = []
-        for service in self._services.list_services:
+        for service in self.sys_services.list_services:
             services.append({
                 ATTR_SLUG: service.slug,
                 ATTR_AVAILABLE: service.enabled,
-                ATTR_PROVIDER: service.provider,
+                ATTR_PROVIDERS: service.providers,
             })
 
         return {ATTR_SERVICES: services}
@@ -35,21 +37,39 @@ class APIServices(CoreSysAttributes):
         """Write data into a service."""
         service = self._extract_service(request)
         body = await api_validate(service.schema, request)
+        addon = request[REQUEST_FROM]
 
-        return service.set_service_data(request[REQUEST_FROM], body)
+        _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)
 
-        return {
-            ATTR_AVAILABLE: service.enabled,
-            service.slug: service.get_service_data(),
-        }
+        # 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)
-        return service.del_service_data(request[REQUEST_FROM])
+        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

@@ -1,4 +1,4 @@
-"""Init file for HassIO snapshot rest api."""
+"""Init file for Hass.io snapshot RESTful API."""
 import asyncio
 import logging
 from pathlib import Path
@@ -14,6 +14,7 @@ from ..const import (
     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__)
 
@@ -46,20 +47,20 @@ SCHEMA_SNAPSHOT_PARTIAL = SCHEMA_SNAPSHOT_FULL.extend({
 
 
 class APISnapshots(CoreSysAttributes):
-    """Handle rest api for snapshot functions."""
+    """Handle RESTful API for snapshot functions."""
 
     def _extract_snapshot(self, request):
-        """Return addon and if not exists trow a exception."""
-        snapshot = self._snapshots.get(request.match_info.get('snapshot'))
+        """Return snapshot, throw an exception if it doesn't exist."""
+        snapshot = self.sys_snapshots.get(request.match_info.get('snapshot'))
         if not snapshot:
-            raise RuntimeError("Snapshot not exists")
+            raise APIError("Snapshot does not exist")
         return snapshot
 
     @api_process
     async def list(self, request):
         """Return snapshot list."""
         data_snapshots = []
-        for snapshot in self._snapshots.list_snapshots:
+        for snapshot in self.sys_snapshots.list_snapshots:
             data_snapshots.append({
                 ATTR_SLUG: snapshot.slug,
                 ATTR_NAME: snapshot.name,
@@ -75,7 +76,7 @@ class APISnapshots(CoreSysAttributes):
     @api_process
     async def reload(self, request):
         """Reload snapshot list."""
-        await asyncio.shield(self._snapshots.reload(), loop=self._loop)
+        await asyncio.shield(self.sys_snapshots.reload())
         return True
 
     @api_process
@@ -110,7 +111,7 @@ class APISnapshots(CoreSysAttributes):
         """Full-Snapshot a snapshot."""
         body = await api_validate(SCHEMA_SNAPSHOT_FULL, request)
         snapshot = await asyncio.shield(
-            self._snapshots.do_snapshot_full(**body), loop=self._loop)
+            self.sys_snapshots.do_snapshot_full(**body))
 
         if snapshot:
             return {ATTR_SLUG: snapshot.slug}
@@ -121,7 +122,7 @@ class APISnapshots(CoreSysAttributes):
         """Partial-Snapshot a snapshot."""
         body = await api_validate(SCHEMA_SNAPSHOT_PARTIAL, request)
         snapshot = await asyncio.shield(
-            self._snapshots.do_snapshot_partial(**body), loop=self._loop)
+            self.sys_snapshots.do_snapshot_partial(**body))
 
         if snapshot:
             return {ATTR_SLUG: snapshot.slug}
@@ -134,9 +135,7 @@ class APISnapshots(CoreSysAttributes):
         body = await api_validate(SCHEMA_RESTORE_FULL, request)
 
         return await asyncio.shield(
-            self._snapshots.do_restore_full(snapshot, **body),
-            loop=self._loop
-        )
+            self.sys_snapshots.do_restore_full(snapshot, **body))
 
     @api_process
     async def restore_partial(self, request):
@@ -145,15 +144,13 @@ class APISnapshots(CoreSysAttributes):
         body = await api_validate(SCHEMA_RESTORE_PARTIAL, request)
 
         return await asyncio.shield(
-            self._snapshots.do_restore_partial(snapshot, **body),
-            loop=self._loop
-        )
+            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._snapshots.remove(snapshot)
+        return self.sys_snapshots.remove(snapshot)
 
     async def download(self, request):
         """Download a snapshot file."""
@@ -167,7 +164,7 @@ class APISnapshots(CoreSysAttributes):
     @api_process
     async def upload(self, request):
         """Upload a snapshot file."""
-        with TemporaryDirectory(dir=str(self._config.path_tmp)) as temp_dir:
+        with TemporaryDirectory(dir=str(self.sys_config.path_tmp)) as temp_dir:
             tar_file = Path(temp_dir, f"snapshot.tar")
 
             try:
@@ -183,7 +180,7 @@ class APISnapshots(CoreSysAttributes):
                 return False
 
             snapshot = await asyncio.shield(
-                self._snapshots.import_snapshot(tar_file), loop=self._loop)
+                self.sys_snapshots.import_snapshot(tar_file))
 
             if snapshot:
                 return {ATTR_SLUG: snapshot.slug}

hassio/api/supervisor.py

@@ -1,100 +1,140 @@
-"""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 .utils import api_process, api_process_raw, api_validate
 from ..const import (
-    ATTR_ADDONS, ATTR_VERSION, ATTR_LAST_VERSION, ATTR_BETA_CHANNEL, ATTR_ARCH,
-    HASSIO_VERSION, ATTR_ADDONS_REPOSITORIES, ATTR_LOGO, ATTR_REPOSITORY,
-    ATTR_DESCRIPTON, ATTR_NAME, ATTR_SLUG, ATTR_INSTALLED, ATTR_TIMEZONE,
-    ATTR_STATE, ATTR_WAIT_BOOT, ATTR_CPU_PERCENT, ATTR_MEMORY_USAGE,
-    ATTR_MEMORY_LIMIT, ATTR_NETWORK_RX, ATTR_NETWORK_TX, ATTR_BLK_READ,
-    ATTR_BLK_WRITE, CONTENT_TYPE_BINARY, ATTR_ICON)
+    ATTR_ADDONS,
+    ATTR_ADDONS_REPOSITORIES,
+    ATTR_ARCH,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_CHANNEL,
+    ATTR_CPU_PERCENT,
+    ATTR_DEBUG,
+    ATTR_DEBUG_BLOCK,
+    ATTR_DESCRIPTON,
+    ATTR_ICON,
+    ATTR_INSTALLED,
+    ATTR_IP_ADDRESS,
+    ATTR_LAST_VERSION,
+    ATTR_LOGGING,
+    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,
+    CONTENT_TYPE_BINARY,
+    HASSIO_VERSION,
+)
 from ..coresys import CoreSysAttributes
-from ..validate import validate_timezone, WAIT_BOOT, REPOSITORIES
+from ..exceptions import APIError
+from ..utils.validate import validate_timezone
+from ..validate import CHANNELS, LOG_LEVEL, 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_CHANNEL): vol.Boolean(),
-    vol.Optional(ATTR_ADDONS_REPOSITORIES): REPOSITORIES,
-    vol.Optional(ATTR_TIMEZONE): validate_timezone,
-    vol.Optional(ATTR_WAIT_BOOT): WAIT_BOOT,
-})
+# pylint: disable=no-value-for-parameter
+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,
+        vol.Optional(ATTR_LOGGING): LOG_LEVEL,
+        vol.Optional(ATTR_DEBUG): vol.Boolean(),
+        vol.Optional(ATTR_DEBUG_BLOCK): vol.Boolean(),
+    }
+)
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
-})
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 
 
 class APISupervisor(CoreSysAttributes):
-    """Handle rest api for supervisor functions."""
+    """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."""
         list_addons = []
-        for addon in self._addons.list_addons:
-            if addon.is_installed:
-                list_addons.append({
+        for addon in self.sys_addons.installed:
+            list_addons.append(
+                {
                     ATTR_NAME: addon.name,
                     ATTR_SLUG: addon.slug,
                     ATTR_DESCRIPTON: addon.description,
                     ATTR_STATE: await addon.state(),
-                    ATTR_VERSION: addon.last_version,
-                    ATTR_INSTALLED: addon.version_installed,
+                    ATTR_VERSION: addon.latest_version,
+                    ATTR_INSTALLED: addon.version,
                     ATTR_REPOSITORY: addon.repository,
                     ATTR_ICON: addon.with_icon,
                     ATTR_LOGO: addon.with_logo,
-                })
+                }
+            )
 
         return {
             ATTR_VERSION: HASSIO_VERSION,
-            ATTR_LAST_VERSION: self._updater.version_hassio,
-            ATTR_BETA_CHANNEL: self._updater.beta_channel,
-            ATTR_ARCH: self._arch,
-            ATTR_WAIT_BOOT: self._config.wait_boot,
-            ATTR_TIMEZONE: self._config.timezone,
+            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_LOGGING: self.sys_config.logging,
             ATTR_ADDONS: list_addons,
-            ATTR_ADDONS_REPOSITORIES: self._config.addons_repositories,
+            ATTR_ADDONS_REPOSITORIES: self.sys_config.addons_repositories,
         }
 
     @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_CHANNEL in body:
-            self._updater.beta_channel = body[ATTR_BETA_CHANNEL]
+        if ATTR_CHANNEL in body:
+            self.sys_updater.channel = body[ATTR_CHANNEL]
 
         if ATTR_TIMEZONE in body:
-            self._config.timezone = body[ATTR_TIMEZONE]
+            self.sys_config.timezone = body[ATTR_TIMEZONE]
 
         if ATTR_WAIT_BOOT in body:
-            self._config.wait_boot = body[ATTR_WAIT_BOOT]
+            self.sys_config.wait_boot = body[ATTR_WAIT_BOOT]
+
+        if ATTR_DEBUG in body:
+            self.sys_config.debug = body[ATTR_DEBUG]
+
+        if ATTR_DEBUG_BLOCK in body:
+            self.sys_config.debug_block = body[ATTR_DEBUG_BLOCK]
+
+        if ATTR_LOGGING in body:
+            self.sys_config.logging = body[ATTR_LOGGING]
 
         if ATTR_ADDONS_REPOSITORIES in body:
             new = set(body[ATTR_ADDONS_REPOSITORIES])
-            await asyncio.shield(self._addons.load_repositories(new))
+            await asyncio.shield(self.sys_store.update_repositories(new))
 
-        self._updater.save_data()
-        self._config.save_data()
-        return True
+        self.sys_updater.save_data()
+        self.sys_config.save_data()
 
     @api_process
-    async def stats(self, request):
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
         """Return resource information."""
-        stats = await self._supervisor.stats()
-        if not stats:
-            raise RuntimeError("No stats available")
+        stats = await self.sys_supervisor.stats()
 
         return {
             ATTR_CPU_PERCENT: stats.cpu_percent,
@@ -107,33 +147,21 @@ class APISupervisor(CoreSysAttributes):
         }
 
     @api_process
-    async def update(self, request):
-        """Update supervisor OS."""
+    async def update(self, request: web.Request) -> None:
+        """Update Supervisor OS."""
         body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self._updater.version_hassio)
+        version = body.get(ATTR_VERSION, self.sys_updater.version_hassio)
 
-        if version == self._supervisor.version:
-            raise RuntimeError("Version {} is already in use".format(version))
-
-        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._updater.reload(),
-        ]
-        results, _ = await asyncio.shield(
-            asyncio.wait(tasks, loop=self._loop), loop=self._loop)
-
-        for result in results:
-            if result.exception() is not None:
-                raise RuntimeError("Some reload task fails!")
-
-        return True
+    def reload(self, request: web.Request) -> Awaitable[None]:
+        """Reload add-ons, configuration, etc."""
+        return asyncio.shield(self.sys_updater.reload())
 
     @api_process_raw(CONTENT_TYPE_BINARY)
-    def logs(self, request):
-        """Return supervisor docker logs."""
-        return self._supervisor.logs()
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return supervisor Docker logs."""
+        return self.sys_supervisor.logs()

hassio/api/utils.py

@@ -1,16 +1,15 @@
-"""Init file for HassIO util for rest api."""
+"""Init file for Hass.io util for RESTful API."""
 import json
-import hashlib
 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,
     CONTENT_TYPE_BINARY)
+from ..exceptions import HassioError, APIError, APIForbidden
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -22,53 +21,31 @@ def json_loads(data):
     try:
         return json.loads(data)
     except json.JSONDecodeError:
-        raise RuntimeError("Invalid json")
+        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."""
+        """Return API information."""
         try:
             answer = await method(api, *args, **kwargs)
-        except RuntimeError as err:
+        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 answer:
-            return api_return_ok()
-        return api_return_error()
+        elif isinstance(answer, bool) and not answer:
+            return api_return_error()
+        return api_return_ok()
 
     return wrap_api
 
 
-def api_process_hostcontrol(method):
-    """Wrap HostControl calls to rest api."""
-    async def wrap_hostcontrol(api, *args, **kwargs):
-        """Return host information."""
-        # pylint: disable=protected-access
-        if not api._host_control.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_hostcontrol
-
-
 def api_process_raw(content):
     """Wrap content_type into function."""
     def wrap_method(method):
@@ -78,9 +55,12 @@ def api_process_raw(content):
             try:
                 msg_data = await method(api, *args, **kwargs)
                 msg_type = content
-            except RuntimeError as err:
+            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)
 
@@ -89,7 +69,7 @@ def api_process_raw(content):
 
 
 def api_return_error(message=None):
-    """Return a API error message."""
+    """Return an API error message."""
     return web.json_response({
         JSON_RESULT: RESULT_ERROR,
         JSON_MESSAGE: message,
@@ -97,7 +77,7 @@ def api_return_error(message=None):
 
 
 def api_return_ok(data=None):
-    """Return a API ok answer."""
+    """Return an API ok answer."""
     return web.json_response({
         JSON_RESULT: RESULT_OK,
         JSON_DATA: data or {},
@@ -110,12 +90,6 @@ async def api_validate(schema, request):
     try:
         data = schema(data)
     except vol.Invalid as ex:
-        raise RuntimeError(humanize_error(data, ex)) from None
+        raise APIError(humanize_error(data, ex)) from None
 
     return data
-
-
-def hash_password(password):
-    """Hash and salt our passwords."""
-    key = ")*()*SALT_HASSIO2123{}6554547485HSKA!!*JSLAfdasda$".format(password)
-    return hashlib.sha256(key.encode()).hexdigest()

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,96 +1,132 @@
-"""Bootstrap HassIO."""
+"""Bootstrap Hass.io."""
 import logging
 import os
-import signal
-import shutil
 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 .core import HassIO
 from .coresys import CoreSys
-from .supervisor import Supervisor
+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 .store import StoreManager
 from .tasks import Tasks
 from .updater import Updater
-from .services import ServiceManager
 
 _LOGGER = logging.getLogger(__name__)
 
+ENV_SHARE = "SUPERVISOR_SHARE"
+ENV_NAME = "SUPERVISOR_NAME"
+ENV_REPO = "HOMEASSISTANT_REPOSITORY"
 
-def initialize_coresys(loop):
+MACHINE_ID = Path("/etc/machine-id")
+
+
+async def initialize_coresys():
     """Initialize HassIO coresys/objects."""
-    coresys = CoreSys(loop)
+    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.store = StoreManager(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):
-    """Setup default config and create folders."""
+def initialize_system_data(coresys: CoreSys):
+    """Set up the default configuration and create folders."""
     config = coresys.config
 
-    # homeassistant config folder
-    if not config.path_config.is_dir():
+    # Home Assistant configuration folder
+    if not config.path_homeassistant.is_dir():
         _LOGGER.info(
-            "Create Home-Assistant config folder %s", config.path_config)
-        config.path_config.mkdir()
+            "Create Home Assistant configuration folder %s", config.path_homeassistant
+        )
+        config.path_homeassistant.mkdir()
 
     # hassio ssl folder
     if not config.path_ssl.is_dir():
-        _LOGGER.info("Create hassio ssl folder %s", config.path_ssl)
+        _LOGGER.info("Create Hass.io SSL/TLS folder %s", config.path_ssl)
         config.path_ssl.mkdir()
 
     # hassio addon data folder
     if not config.path_addons_data.is_dir():
-        _LOGGER.info(
-            "Create hassio addon data folder %s", config.path_addons_data)
+        _LOGGER.info("Create Hass.io Add-on data folder %s", config.path_addons_data)
         config.path_addons_data.mkdir(parents=True)
 
     if not config.path_addons_local.is_dir():
-        _LOGGER.info("Create hassio addon local repository folder %s",
-                     config.path_addons_local)
+        _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 hassio addon git repositories folder %s",
-                     config.path_addons_git)
+        _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 hassio temp folder %s", config.path_tmp)
+        _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 hassio backup folder %s", config.path_backup)
+        _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 hassio share folder %s", config.path_share)
+        _LOGGER.info("Create Hass.io share folder %s", config.path_share)
         config.path_share.mkdir()
 
-    return config
+    # apparmor folder
+    if not config.path_apparmor.is_dir():
+        _LOGGER.info("Create Hass.io Apparmor folder %s", config.path_apparmor)
+        config.path_apparmor.mkdir()
+
+    # Update log level
+    coresys.config.modify_log_level()
 
 
-def migrate_system_env(coresys):
+def migrate_system_env(coresys: CoreSys):
     """Cleanup some stuff after update."""
     config = coresys.config
 
@@ -100,39 +136,39 @@ def migrate_system_env(coresys):
         try:
             old_build.rmdir()
         except OSError:
-            _LOGGER.warning("Can't cleanup old addons build dir.")
+            _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."""
     # check environment variables
-    for key in ('SUPERVISOR_SHARE', 'SUPERVISOR_NAME',
-                'HOMEASSISTANT_REPOSITORY'):
+    for key in (ENV_SHARE, ENV_NAME, ENV_REPO):
         try:
             os.environ[key]
         except KeyError:
@@ -141,33 +177,48 @@ def check_environment():
 
     # check docker socket
     if not SOCKET_DOCKER.is_socket():
-        _LOGGER.fatal("Can't find docker socket!")
+        _LOGGER.fatal("Can't find Docker socket!")
         return False
 
     # check socat exec
-    if not shutil.which('socat'):
-        _LOGGER.fatal("Can0t find socat program!")
+    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):
-    """Register SIGTERM, SIGKILL to stop system."""
+    """Register SIGTERM and SIGKILL to stop system."""
     try:
-        loop.add_signal_handler(
-            signal.SIGTERM, lambda: loop.call_soon(loop.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.call_soon(loop.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.call_soon(loop.stop))
+        loop.add_signal_handler(signal.SIGINT, lambda: loop.call_soon(loop.stop))
     except (ValueError, RuntimeError):
         _LOGGER.warning("Could not bind to SIGINT")
+
+
+def supervisor_debugger(coresys: CoreSys) -> None:
+    """Setup debugger if needed."""
+    if not coresys.config.debug or not coresys.dev:
+        return
+    import ptvsd
+
+    _LOGGER.info("Initialize Hass.io debugger")
+
+    ptvsd.enable_attach(address=('0.0.0.0', 33333), redirect_output=True)
+    if coresys.config.debug_block:
+        ptvsd.wait_for_attach()

hassio/config.py

@@ -1,12 +1,23 @@
-"""Bootstrap HassIO."""
+"""Bootstrap Hass.io."""
 from datetime import datetime
 import logging
 import os
 from pathlib import Path, PurePath
+import re
+
+import pytz
 
 from .const import (
-    FILE_HASSIO_CONFIG, HASSIO_DATA, ATTR_TIMEZONE, ATTR_ADDONS_CUSTOM_LIST,
-    ATTR_AUDIO_INPUT, ATTR_AUDIO_OUTPUT, ATTR_LAST_BOOT, ATTR_WAIT_BOOT)
+    ATTR_ADDONS_CUSTOM_LIST,
+    ATTR_DEBUG,
+    ATTR_DEBUG_BLOCK,
+    ATTR_LAST_BOOT,
+    ATTR_LOGGING,
+    ATTR_TIMEZONE,
+    ATTR_WAIT_BOOT,
+    FILE_HASSIO_CONFIG,
+    HASSIO_DATA,
+)
 from .utils.dt import parse_datetime
 from .utils.json import JsonConfig
 from .validate import SCHEMA_HASSIO_CONFIG
@@ -25,9 +36,12 @@ ADDONS_DATA = PurePath("addons/data")
 BACKUP_DATA = PurePath("backup")
 SHARE_DATA = PurePath("share")
 TMP_DATA = PurePath("tmp")
+APPARMOR_DATA = PurePath("apparmor")
 
 DEFAULT_BOOT_TIME = datetime.utcfromtimestamp(0).isoformat()
 
+RE_TIMEZONE = re.compile(r"time_zone: (?P<timezone>[\w/\-+]+)")
+
 
 class CoreConfig(JsonConfig):
     """Hold all core config data."""
@@ -39,7 +53,21 @@ class CoreConfig(JsonConfig):
     @property
     def timezone(self):
         """Return system timezone."""
-        return self._data[ATTR_TIMEZONE]
+        config_file = Path(self.path_homeassistant, "configuration.yaml")
+        try:
+            assert config_file.exists()
+            configuration = config_file.read_text()
+
+            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):
@@ -47,15 +75,51 @@ class CoreConfig(JsonConfig):
         self._data[ATTR_TIMEZONE] = value
 
     @property
-    def wait_boot(self):
+    def wait_boot(self) -> int:
         """Return wait time for auto boot stages."""
         return self._data[ATTR_WAIT_BOOT]
 
     @wait_boot.setter
-    def wait_boot(self, value):
+    def wait_boot(self, value: int):
         """Set wait boot time."""
         self._data[ATTR_WAIT_BOOT] = value
 
+    @property
+    def debug(self) -> bool:
+        """Return True if ptvsd is enabled."""
+        return self._data[ATTR_DEBUG]
+
+    @debug.setter
+    def debug(self, value: bool):
+        """Set debug mode."""
+        self._data[ATTR_DEBUG] = value
+
+    @property
+    def debug_block(self) -> bool:
+        """Return True if ptvsd should waiting."""
+        return self._data[ATTR_DEBUG_BLOCK]
+
+    @debug_block.setter
+    def debug_block(self, value: bool):
+        """Set debug wait mode."""
+        self._data[ATTR_DEBUG_BLOCK] = value
+
+    @property
+    def logging(self) -> str:
+        """Return log level of system."""
+        return self._data[ATTR_LOGGING]
+
+    @logging.setter
+    def logging(self, value: str):
+        """Set system log level."""
+        self._data[ATTR_LOGGING] = value
+        self.modify_log_level()
+
+    def modify_log_level(self) -> None:
+        """Change log level."""
+        lvl = getattr(logging, self.logging.upper())
+        logging.basicConfig(level=lvl)
+
     @property
     def last_boot(self):
         """Return last boot datetime."""
@@ -73,27 +137,27 @@ class CoreConfig(JsonConfig):
 
     @property
     def path_hassio(self):
-        """Return hassio data path."""
+        """Return Hass.io data path."""
         return HASSIO_DATA
 
     @property
     def path_extern_hassio(self):
-        """Return hassio data path extern for docker."""
-        return PurePath(os.environ['SUPERVISOR_SHARE'])
+        """Return Hass.io data path external for Docker."""
+        return PurePath(os.environ["SUPERVISOR_SHARE"])
 
     @property
-    def path_extern_config(self):
-        """Return config path extern for docker."""
+    def path_extern_homeassistant(self):
+        """Return config path external for Docker."""
         return str(PurePath(self.path_extern_hassio, HOMEASSISTANT_CONFIG))
 
     @property
-    def path_config(self):
+    def path_homeassistant(self):
         """Return config path inside supervisor."""
         return Path(HASSIO_DATA, HOMEASSISTANT_CONFIG)
 
     @property
     def path_extern_ssl(self):
-        """Return SSL path extern for docker."""
+        """Return SSL path external for Docker."""
         return str(PurePath(self.path_extern_hassio, HASSIO_SSL))
 
     @property
@@ -103,39 +167,44 @@ class CoreConfig(JsonConfig):
 
     @property
     def path_addons_core(self):
-        """Return git path for core addons."""
+        """Return git path for core Add-ons."""
         return Path(HASSIO_DATA, ADDONS_CORE)
 
     @property
     def path_addons_git(self):
-        """Return path for git addons."""
+        """Return path for Git Add-on."""
         return Path(HASSIO_DATA, ADDONS_GIT)
 
     @property
     def path_addons_local(self):
-        """Return path for customs addons."""
+        """Return path for custom Add-ons."""
         return Path(HASSIO_DATA, ADDONS_LOCAL)
 
     @property
     def path_extern_addons_local(self):
-        """Return path for customs addons."""
+        """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 root Add-on data folder."""
         return Path(HASSIO_DATA, ADDONS_DATA)
 
     @property
     def path_extern_addons_data(self):
-        """Return root addon data folder extern for docker."""
+        """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 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."""
@@ -143,7 +212,7 @@ class CoreConfig(JsonConfig):
 
     @property
     def path_extern_backup(self):
-        """Return root backup data folder extern for docker."""
+        """Return root backup data folder external for Docker."""
         return PurePath(self.path_extern_hassio, BACKUP_DATA)
 
     @property
@@ -151,14 +220,19 @@ class CoreConfig(JsonConfig):
         """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 extern for docker."""
+        """Return root share data folder external for Docker."""
         return PurePath(self.path_extern_hassio, SHARE_DATA)
 
     @property
     def addons_repositories(self):
-        """Return list of addons custom repositories."""
+        """Return list of custom Add-on repositories."""
         return self._data[ATTR_ADDONS_CUSTOM_LIST]
 
     def add_addon_repository(self, repo):
@@ -174,23 +248,3 @@ class CoreConfig(JsonConfig):
             return
 
         self._data[ATTR_ADDONS_CUSTOM_LIST].remove(repo)
-
-    @property
-    def audio_output(self):
-        """Return ALSA audio output card,dev."""
-        return self._data.get(ATTR_AUDIO_OUTPUT)
-
-    @audio_output.setter
-    def audio_output(self, value):
-        """Set ALSA audio output card,dev."""
-        self._data[ATTR_AUDIO_OUTPUT] = value
-
-    @property
-    def audio_input(self):
-        """Return ALSA audio input card,dev."""
-        return self._data.get(ATTR_AUDIO_INPUT)
-
-    @audio_input.setter
-    def audio_input(self, value):
-        """Set ALSA audio input card,dev."""
-        self._data[ATTR_AUDIO_INPUT] = value

hassio/const.py

@@ -1,199 +1,313 @@
-"""Const file for HassIO."""
+"""Constants file for Hass.io."""
 from pathlib import Path
 from ipaddress import ip_network
 
-HASSIO_VERSION = '0.93'
 
-URL_HASSIO_VERSION = ('https://raw.githubusercontent.com/home-assistant/'
-                      'hassio/{}/version.json')
+HASSIO_VERSION = "163"
 
-URL_HASSIO_ADDONS = 'https://github.com/home-assistant/hassio-addons'
+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"
+
+URL_HASSOS_OTA = (
+    "https://github.com/home-assistant/hassos/releases/download/"
+    "{version}/hassos_{board}-{version}.raucb"
+)
 
 HASSIO_DATA = Path("/data")
 
+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")
 
 SOCKET_DOCKER = Path("/var/run/docker.sock")
-SOCKET_HC = Path("/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')
+DOCKER_NETWORK = "hassio"
+DOCKER_NETWORK_MASK = ip_network("172.30.32.0/23")
+DOCKER_NETWORK_RANGE = ip_network("172.30.33.0/24")
 
-LABEL_VERSION = 'io.hass.version'
-LABEL_ARCH = 'io.hass.arch'
-LABEL_TYPE = 'io.hass.type'
+LABEL_VERSION = "io.hass.version"
+LABEL_ARCH = "io.hass.arch"
+LABEL_TYPE = "io.hass.type"
+LABEL_MACHINE = "io.hass.machine"
 
-META_ADDON = 'addon'
-META_SUPERVISOR = 'supervisor'
-META_HOMEASSISTANT = 'homeassistant'
+META_ADDON = "addon"
+META_SUPERVISOR = "supervisor"
+META_HOMEASSISTANT = "homeassistant"
 
-JSON_RESULT = 'result'
-JSON_DATA = 'data'
-JSON_MESSAGE = 'message'
+JSON_RESULT = "result"
+JSON_DATA = "data"
+JSON_MESSAGE = "message"
 
-RESULT_ERROR = 'error'
-RESULT_OK = 'ok'
+RESULT_ERROR = "error"
+RESULT_OK = "ok"
 
-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'
-HEADER_HA_ACCESS = 'x-ha-access'
-HEADER_TOKEN = 'X-HASSIO-KEY'
+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"
 
-ENV_TOKEN = 'HASSIO_TOKEN'
-ENV_TIME = 'TZ'
+ENV_TOKEN = "HASSIO_TOKEN"
+ENV_TIME = "TZ"
 
-REQUEST_FROM = 'HASSIO_FROM'
+REQUEST_FROM = "HASSIO_FROM"
 
-ATTR_WAIT_BOOT = 'wait_boot'
-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_OS = 'os'
-ATTR_TYPE = 'type'
-ATTR_SOURCE = 'source'
-ATTR_FEATURES = 'features'
-ATTR_ADDONS = 'addons'
-ATTR_VERSION = 'version'
-ATTR_AUTO_UART = 'auto_uart'
-ATTR_LAST_BOOT = 'last_boot'
-ATTR_LAST_VERSION = 'last_version'
-ATTR_BETA_CHANNEL = 'beta_channel'
-ATTR_NAME = 'name'
-ATTR_SLUG = 'slug'
-ATTR_DESCRIPTON = 'description'
-ATTR_STARTUP = 'startup'
-ATTR_BOOT = 'boot'
-ATTR_PORTS = 'ports'
-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_SESSION = 'session'
-ATTR_SESSIONS = 'sessions'
-ATTR_LOCATON = 'location'
-ATTR_BUILD = 'build'
-ATTR_DEVICES = 'devices'
-ATTR_ENVIRONMENT = 'environment'
-ATTR_HOST_NETWORK = 'host_network'
-ATTR_HOST_IPC = 'host_ipc'
-ATTR_HOST_DBUS = 'host_dbus'
-ATTR_NETWORK = 'network'
-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_PROVIDER = 'provider'
-ATTR_AVAILABLE = 'available'
-ATTR_HOST = 'host'
-ATTR_USERNAME = 'username'
-ATTR_PROTOCOL = 'protocol'
-ATTR_DISCOVERY = 'discovery'
-ATTR_PLATFORM = 'platform'
-ATTR_COMPONENT = 'component'
-ATTR_CONFIG = 'config'
-ATTR_DISCOVERY_ID = 'discovery_id'
-ATTR_SERVICES = 'services'
-ATTR_DISCOVERY = 'discovery'
-ATTR_PROTECTED = 'protected'
-ATTR_CRYPTO = 'crypto'
+ATTR_MACHINE = "machine"
+ATTR_WAIT_BOOT = "wait_boot"
+ATTR_DEPLOYMENT = "deployment"
+ATTR_WATCHDOG = "watchdog"
+ATTR_CHANGELOG = "changelog"
+ATTR_LOGGING = "logging"
+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_INGRESS_PANEL = "ingress_panel"
+ATTR_PANEL_ICON = "panel_icon"
+ATTR_PANEL_TITLE = "panel_title"
+ATTR_PANEL_ADMIN = "panel_admin"
+ATTR_TITLE = "title"
+ATTR_ENABLE = "enable"
+ATTR_IP_ADDRESS = "ip_address"
+ATTR_SESSION = "session"
+ATTR_ADMIN = "admin"
+ATTR_PANELS = "panels"
+ATTR_DEBUG = "debug"
+ATTR_DEBUG_BLOCK = "debug_block"
 
-SERVICE_MQTT = 'mqtt'
+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_INITIALIZE = "initialize"
+STARTUP_SYSTEM = "system"
+STARTUP_SERVICES = "services"
+STARTUP_APPLICATION = "application"
+STARTUP_ONCE = "once"
 
-BOOT_AUTO = 'auto'
-BOOT_MANUAL = 'manual'
+STARTUP_ALL = [
+    STARTUP_ONCE,
+    STARTUP_INITIALIZE,
+    STARTUP_SYSTEM,
+    STARTUP_SERVICES,
+    STARTUP_APPLICATION,
+]
 
-STATE_STARTED = 'started'
-STATE_STOPPED = 'stopped'
-STATE_NONE = 'none'
+BOOT_AUTO = "auto"
+BOOT_MANUAL = "manual"
 
-MAP_CONFIG = 'config'
-MAP_SSL = 'ssl'
-MAP_ADDONS = 'addons'
-MAP_BACKUP = 'backup'
-MAP_SHARE = 'share'
+STATE_STARTED = "started"
+STATE_STOPPED = "stopped"
+STATE_NONE = "none"
 
-ARCH_ARMHF = 'armhf'
-ARCH_AARCH64 = 'aarch64'
-ARCH_AMD64 = 'amd64'
-ARCH_I386 = 'i386'
+MAP_CONFIG = "config"
+MAP_SSL = "ssl"
+MAP_ADDONS = "addons"
+MAP_BACKUP = "backup"
+MAP_SHARE = "share"
 
-REPOSITORY_CORE = 'core'
-REPOSITORY_LOCAL = 'local'
+ARCH_ARMHF = "armhf"
+ARCH_ARMV7 = "armv7"
+ARCH_AARCH64 = "aarch64"
+ARCH_AMD64 = "amd64"
+ARCH_I386 = "i386"
 
-FOLDER_HOMEASSISTANT = 'homeassistant'
-FOLDER_SHARE = 'share'
-FOLDER_ADDONS = 'addons/local'
-FOLDER_SSL = 'ssl'
+ARCH_ALL = [ARCH_ARMHF, ARCH_ARMV7, ARCH_AARCH64, ARCH_AMD64, ARCH_I386]
 
-SNAPSHOT_FULL = 'full'
-SNAPSHOT_PARTIAL = 'partial'
+CHANNEL_STABLE = "stable"
+CHANNEL_BETA = "beta"
+CHANNEL_DEV = "dev"
 
-CRYPTO_AES128 = 'aes128'
+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,117 +1,158 @@
-"""Main file for HassIO."""
+"""Main file for Hass.io."""
+from contextlib import suppress
 import asyncio
 import logging
 
+import async_timeout
+
 from .coresys import CoreSysAttributes
 from .const import (
-    STARTUP_SYSTEM, STARTUP_SERVICES, STARTUP_APPLICATION, STARTUP_INITIALIZE)
-from .utils.dt import fetch_timezone
+    STARTUP_SYSTEM,
+    STARTUP_SERVICES,
+    STARTUP_APPLICATION,
+    STARTUP_INITIALIZE,
+)
+from .exceptions import HassioError, HomeAssistantError
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class HassIO(CoreSysAttributes):
-    """Main object of hassio."""
+    """Main object of Hass.io."""
 
     def __init__(self, coresys):
-        """Initialize hassio object."""
+        """Initialize Hass.io object."""
         self.coresys = coresys
 
     async def setup(self):
         """Setup HassIO orchestration."""
-        # update timezone
-        if self._config.timezone == 'UTC':
-            self._config.timezone = await fetch_timezone(self._websession)
+        # Load Supervisor
+        await self.sys_supervisor.load()
 
-        # supervisor
-        await self._supervisor.load()
+        # Load DBus
+        await self.sys_dbus.load()
 
-        # hostcontrol
-        await self._host_control.load()
+        # Load Host
+        await self.sys_host.load()
 
-        # Load homeassistant
-        await self._homeassistant.load()
+        # Load Home Assistant
+        await self.sys_homeassistant.load()
 
-        # Load addons
-        await self._addons.load()
+        # Load CPU/Arch
+        await self.sys_arch.load()
+
+        # Load HassOS
+        await self.sys_hassos.load()
+
+        # Load Stores
+        await self.sys_store.load()
+
+        # Load Add-ons
+        await self.sys_addons.load()
 
         # rest api views
-        await self._api.load()
+        await self.sys_api.load()
 
         # load last available data
-        await self._updater.load()
+        await self.sys_updater.load()
 
         # load last available data
-        await self._snapshots.load()
+        await self.sys_snapshots.load()
 
         # load services
-        await self._services.load()
+        await self.sys_services.load()
+
+        # Load discovery
+        await self.sys_discovery.load()
+
+        # Load ingress
+        await self.sys_ingress.load()
 
         # start dns forwarding
-        self._loop.create_task(self._dns.start())
-
-        # start addon mark as initialize
-        await self._addons.auto_boot(STARTUP_INITIALIZE)
+        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
-        # on beta channel, only read new versions
-        if not self._updater.beta_channel and self._supervisor.need_update:
-            if await self._supervisor.update():
+        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
-        else:
-            _LOGGER.info("Ignore Hass.io auto updates on beta mode")
 
         # start api
-        await self._api.start()
-        _LOGGER.info("Start API on %s", self._docker.network.supervisor)
+        await self.sys_api.start()
+
+        # start addon mark as initialize
+        await self.sys_addons.boot(STARTUP_INITIALIZE)
 
         try:
             # HomeAssistant is already running / supervisor have only reboot
-            if self._hardware.last_boot == self._config.last_boot:
+            if self.sys_hardware.last_boot == self.sys_config.last_boot:
                 _LOGGER.info("Hass.io reboot detected")
                 return
 
             # reset register services / discovery
-            self._services.reset()
+            self.sys_services.reset()
 
             # start addon mark as system
-            await self._addons.auto_boot(STARTUP_SYSTEM)
+            await self.sys_addons.boot(STARTUP_SYSTEM)
 
             # start addon mark as services
-            await self._addons.auto_boot(STARTUP_SERVICES)
+            await self.sys_addons.boot(STARTUP_SERVICES)
 
             # run HomeAssistant
-            if self._homeassistant.boot:
-                await self._homeassistant.start()
+            if self.sys_homeassistant.boot:
+                with suppress(HomeAssistantError):
+                    await self.sys_homeassistant.start()
 
             # start addon mark as application
-            await self._addons.auto_boot(STARTUP_APPLICATION)
+            await self.sys_addons.boot(STARTUP_APPLICATION)
 
             # store new last boot
-            self._config.last_boot = self._hardware.last_boot
-            self._config.save_data()
+            self.sys_config.last_boot = self.sys_hardware.last_boot
+            self.sys_config.save_data()
 
         finally:
             # Add core tasks into scheduler
-            await self._tasks.load()
+            await self.sys_tasks.load()
 
             # If landingpage / run upgrade in background
-            if self._homeassistant.version == 'landingpage':
-                self._loop.create_task(self._homeassistant.install())
+            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.suspend = True
-
-        # process stop tasks
-        self._websession.close()
-        self._websession_ssl.close()
+        self.sys_scheduler.suspend = True
 
         # process async stop tasks
-        await asyncio.wait(
-            [self._api.stop(), self._dns.stop()], loop=self._loop)
+        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!")
+
+        _LOGGER.info("Hass.io is down")
+
+    async def shutdown(self):
+        """Shutdown all running containers in correct order."""
+        await self.sys_addons.shutdown(STARTUP_APPLICATION)
+
+        # Close Home Assistant
+        with suppress(HassioError):
+            await self.sys_homeassistant.stop()
+
+        await self.sys_addons.shutdown(STARTUP_SERVICES)
+        await self.sys_addons.shutdown(STARTUP_SYSTEM)
+        await self.sys_addons.shutdown(STARTUP_INITIALIZE)

hassio/coresys.py

@@ -1,203 +1,493 @@
 """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.host_control import HostControl
 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 .store import StoreManager
+    from .tasks import Tasks
+    from .updater import Updater
 
-class CoreSys(object):
+
+class CoreSys:
     """Class that handle all shared data."""
 
-    def __init__(self, loop):
+    def __init__(self):
         """Initialize coresys."""
         # Static attributes
-        self.exit_code = 0
+        self.machine_id: str = None
 
         # External objects
-        self._loop = loop
-        self._websession = aiohttp.ClientSession(loop=loop)
-        self._websession_ssl = aiohttp.ClientSession(
-            connector=aiohttp.TCPConnector(verify_ssl=False), loop=loop)
+        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()
-        self._hardware = Hardware()
-        self._docker = DockerAPI()
-        self._scheduler = Scheduler(loop=loop)
-        self._dns = DNSForward(loop=loop)
-        self._host_control = HostControl(loop=loop)
+        self._config: CoreConfig = CoreConfig()
+        self._hardware: Hardware = Hardware()
+        self._docker: DockerAPI = DockerAPI()
+        self._scheduler: Scheduler = Scheduler()
+        self._dns: DNSForward = DNSForward()
 
         # Internal objects pointers
-        self._homeassistant = None
-        self._supervisor = None
-        self._addons = None
-        self._api = None
-        self._updater = None
-        self._snapshots = None
-        self._tasks = None
-        self._services = None
+        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._store: StoreManager = None
+        self._discovery: Discovery = None
 
     @property
-    def arch(self):
-        """Return running arch of hass.io system."""
-        if self._supervisor:
-            return self._supervisor.arch
+    def machine(self) -> str:
+        """Return running machine type of the Hass.io system."""
+        if self._homeassistant:
+            return self._homeassistant.machine
         return None
 
     @property
-    def loop(self):
+    def dev(self) -> bool:
+        """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):
+    def websession(self) -> aiohttp.ClientSession:
         """Return websession object."""
         return self._websession
 
     @property
-    def websession_ssl(self):
+    def websession_ssl(self) -> aiohttp.ClientSession:
         """Return websession object with disabled SSL."""
         return self._websession_ssl
 
     @property
-    def config(self):
+    def config(self) -> CoreConfig:
         """Return CoreConfig object."""
         return self._config
 
     @property
-    def hardware(self):
+    def hardware(self) -> Hardware:
         """Return Hardware object."""
         return self._hardware
 
     @property
-    def docker(self):
+    def docker(self) -> DockerAPI:
         """Return DockerAPI object."""
         return self._docker
 
     @property
-    def scheduler(self):
+    def scheduler(self) -> Scheduler:
         """Return Scheduler object."""
         return self._scheduler
 
     @property
-    def dns(self):
+    def dns(self) -> DNSForward:
         """Return DNSForward object."""
         return self._dns
 
     @property
-    def host_control(self):
-        """Return HostControl object."""
-        return self._host_control
+    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 homeassistant(self):
-        """Return HomeAssistant object."""
+    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):
+    def homeassistant(self, value: HomeAssistant):
         """Set a HomeAssistant object."""
         if self._homeassistant:
-            raise RuntimeError("HomeAssistant already set!")
+            raise RuntimeError("Home Assistant already set!")
         self._homeassistant = value
 
     @property
-    def supervisor(self):
+    def supervisor(self) -> Supervisor:
         """Return Supervisor object."""
         return self._supervisor
 
     @supervisor.setter
-    def supervisor(self, value):
+    def supervisor(self, value: Supervisor):
         """Set a Supervisor object."""
         if self._supervisor:
             raise RuntimeError("Supervisor already set!")
         self._supervisor = value
 
     @property
-    def api(self):
+    def api(self) -> RestAPI:
         """Return API object."""
         return self._api
 
     @api.setter
-    def api(self, value):
-        """Set a API object."""
+    def api(self, value: RestAPI):
+        """Set an API object."""
         if self._api:
             raise RuntimeError("API already set!")
         self._api = value
 
     @property
-    def updater(self):
+    def updater(self) -> Updater:
         """Return Updater object."""
         return self._updater
 
     @updater.setter
-    def updater(self, value):
+    def updater(self, value: Updater):
         """Set a Updater object."""
         if self._updater:
             raise RuntimeError("Updater already set!")
         self._updater = value
 
     @property
-    def addons(self):
+    def addons(self) -> AddonManager:
         """Return AddonManager object."""
         return self._addons
 
     @addons.setter
-    def addons(self, value):
+    def addons(self, value: AddonManager):
         """Set a AddonManager object."""
         if self._addons:
             raise RuntimeError("AddonManager already set!")
         self._addons = value
 
     @property
-    def snapshots(self):
+    def store(self) -> StoreManager:
+        """Return StoreManager object."""
+        return self._store
+
+    @store.setter
+    def store(self, value: StoreManager):
+        """Set a StoreManager object."""
+        if self._store:
+            raise RuntimeError("StoreManager already set!")
+        self._store = value
+
+    @property
+    def snapshots(self) -> SnapshotManager:
         """Return SnapshotManager object."""
         return self._snapshots
 
     @snapshots.setter
-    def snapshots(self, value):
+    def snapshots(self, value: SnapshotManager):
         """Set a SnapshotManager object."""
         if self._snapshots:
             raise RuntimeError("SnapshotsManager already set!")
         self._snapshots = value
 
     @property
-    def tasks(self):
+    def tasks(self) -> Tasks:
         """Return Tasks object."""
         return self._tasks
 
     @tasks.setter
-    def tasks(self, value):
+    def tasks(self, value: Tasks):
         """Set a Tasks object."""
         if self._tasks:
             raise RuntimeError("Tasks already set!")
         self._tasks = value
 
     @property
-    def services(self):
+    def services(self) -> ServiceManager:
         """Return ServiceManager object."""
         return self._services
 
     @services.setter
-    def services(self, value):
+    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
 
-class CoreSysAttributes(object):
+    @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
 
-    def __getattr__(self, name):
-        """Mapping to coresys."""
-        if hasattr(self.coresys, name[1:]):
-            return getattr(self.coresys, name[1:])
-        raise AttributeError(f"Can't find {name} on {self.__class__}")
+    @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_store(self) -> StoreManager:
+        """Return StoreManager object."""
+        return self.coresys.store
+
+    @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()

hassio/dbus/hostname.py

@@ -0,0 +1,39 @@
+"""D-Bus interface for hostname."""
+import logging
+
+from .interface import DBusInterface
+from .utils import dbus_connected
+from ..exceptions import DBusError
+from ..utils.gdbus import DBus
+
+_LOGGER = logging.getLogger(__name__)
+
+DBUS_NAME = 'org.freedesktop.hostname1'
+DBUS_OBJECT = '/org/freedesktop/hostname1'
+
+
+class Hostname(DBusInterface):
+    """Handle D-Bus interface for hostname/system."""
+
+    async def connect(self):
+        """Connect to system's D-Bus."""
+        try:
+            self.dbus = await DBus.connect(DBUS_NAME, DBUS_OBJECT)
+        except DBusError:
+            _LOGGER.warning("Can't connect to hostname")
+
+    @dbus_connected
+    def set_static_hostname(self, hostname):
+        """Change local hostname.
+
+        Return a coroutine.
+        """
+        return self.dbus.SetStaticHostname(hostname, False)
+
+    @dbus_connected
+    def get_properties(self):
+        """Return local host informations.
+
+        Return a coroutine.
+        """
+        return self.dbus.get_properties(DBUS_NAME)

hassio/dbus/interface.py

@@ -0,0 +1,18 @@
+"""Interface class for D-Bus wrappers."""
+
+
+class DBusInterface:
+    """Handle D-Bus interface for hostname/system."""
+
+    def __init__(self):
+        """Initialize systemd."""
+        self.dbus = None
+
+    @property
+    def is_connected(self):
+        """Return True, if they is connected to D-Bus."""
+        return self.dbus is not None
+
+    async def connect(self):
+        """Connect to D-Bus."""
+        raise NotImplementedError()

hassio/dbus/rauc.py

@@ -0,0 +1,55 @@
+"""D-Bus interface for rauc."""
+import logging
+
+from .interface import DBusInterface
+from .utils import dbus_connected
+from ..exceptions import DBusError
+from ..utils.gdbus import DBus
+
+_LOGGER = logging.getLogger(__name__)
+
+DBUS_NAME = 'de.pengutronix.rauc'
+DBUS_OBJECT = '/'
+
+
+class Rauc(DBusInterface):
+    """Handle D-Bus interface for rauc."""
+
+    async def connect(self):
+        """Connect to D-Bus."""
+        try:
+            self.dbus = await DBus.connect(DBUS_NAME, DBUS_OBJECT)
+        except DBusError:
+            _LOGGER.warning("Can't connect to rauc")
+
+    @dbus_connected
+    def install(self, raucb_file):
+        """Install rauc bundle file.
+
+        Return a coroutine.
+        """
+        return self.dbus.Installer.Install(raucb_file)
+
+    @dbus_connected
+    def get_slot_status(self):
+        """Get slot status.
+
+        Return a coroutine.
+        """
+        return self.dbus.Installer.GetSlotStatus()
+
+    @dbus_connected
+    def get_properties(self):
+        """Return rauc informations.
+
+        Return a coroutine.
+        """
+        return self.dbus.get_properties(f"{DBUS_NAME}.Installer")
+
+    @dbus_connected
+    def signal_completed(self):
+        """Return a signal wrapper for completed signal.
+
+        Return a coroutine.
+        """
+        return self.dbus.wait_signal(f"{DBUS_NAME}.Installer.Completed")