Merge pull request #1224 from home-assistant/dev

Release 178

.devcontainer/Dockerfile

@@ -0,0 +1,43 @@
+FROM python:3.7
+
+WORKDIR /workspaces
+
+# Install Node/Yarn for Frontent
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        curl \
+        git \
+        apt-utils \
+        apt-transport-https \
+    && curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - \
+    && echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list \
+    && apt-get update && apt-get install -y --no-install-recommends \
+        nodejs \
+        yarn \
+    && curl -o - https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash \
+    && rm -rf /var/lib/apt/lists/*
+ENV NVM_DIR /root/.nvm
+
+# Install docker
+# https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        apt-transport-https \
+        ca-certificates \
+        curl \
+        software-properties-common \
+        gpg-agent \
+    && curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add - \
+    && add-apt-repository "deb https://download.docker.com/linux/debian $(lsb_release -cs) stable" \
+    && apt-get update && apt-get install -y --no-install-recommends \
+        docker-ce \
+        docker-ce-cli \
+        containerd.io \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies from requirements.txt if it exists
+COPY requirements.txt requirements_tests.txt /workspaces/
+RUN pip install -r requirements.txt \
+    && pip3 install -r requirements_tests.txt \
+    && pip install black tox
+
+# Set the default shell to bash instead of sh
+ENV SHELL /bin/bash

.devcontainer/devcontainer.json

@@ -0,0 +1,29 @@
+// See https://aka.ms/vscode-remote/devcontainer.json for format details.
+{
+	"name": "Hass.io dev",
+	"context": "..",
+	"dockerFile": "Dockerfile",
+	"appPort": "9123:8123",
+	"runArgs": [
+		"-e",
+		"GIT_EDITOR='code --wait'",
+		"--privileged"
+	],
+	"extensions": [
+		"ms-python.python"
+	],
+	"settings": {
+		"python.pythonPath": "/usr/local/bin/python",
+		"python.linting.pylintEnabled": true,
+		"python.linting.enabled": true,
+		"python.formatting.provider": "black",
+		"python.formatting.blackArgs": [
+			"--target-version",
+			"py37"
+		],
+		"editor.formatOnPaste": false,
+		"editor.formatOnSave": true,
+		"editor.formatOnType": true,
+		"files.trimTrailingWhitespace": true
+	}
+}

.dockerignore

@@ -0,0 +1,23 @@
+# General files
+.git
+.github
+.devcontainer
+.vscode
+
+# Test related files
+.tox
+
+# Temporary files
+**/__pycache__
+.pytest_cache
+
+# virtualenv
+venv/
+
+# HA
+home-assistant-polymer/*
+misc/*
+script/*
+
+# Test ENV
+data/

.github/ISSUE_TEMPLATE.md

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

.github/move.yml

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

.github/release-drafter.yml

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

.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,8 @@ ENV/
 
 # pylint
 .pylint.d/
+
+# VS Code
+.vscode/*
+!.vscode/cSpell.json
+!.vscode/tasks.json

.gitmodules

@@ -0,0 +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.5"
-
-cache:
-  directories:
-    - $HOME/.cache/pip
-install: pip install -U tox
-language: python
-script: tox

.vscode/tasks.json

@@ -0,0 +1,92 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Run Testenv",
+            "type": "shell",
+            "command": "./scripts/test_env.sh",
+            "group": {
+                "kind": "test",
+                "isDefault": true,
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new"
+            },
+            "problemMatcher": []
+        },
+        {
+            "label": "Run Testenv CLI",
+            "type": "shell",
+            "command": "docker run --rm -ti -v /etc/machine-id:/etc/machine-id --network=hassio --add-host hassio:172.30.32.2 homeassistant/amd64-hassio-cli:dev",
+            "group": {
+                "kind": "test",
+                "isDefault": true,
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new"
+            },
+            "problemMatcher": []
+        },
+        {
+            "label": "Update UI",
+            "type": "shell",
+            "command": "./scripts/update-frontend.sh",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new"
+            },
+            "problemMatcher": []
+        },
+        {
+            "label": "Pytest",
+            "type": "shell",
+            "command": "pytest --timeout=10 tests",
+            "group": {
+                "kind": "test",
+                "isDefault": true,
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new"
+            },
+            "problemMatcher": []
+        },
+        {
+            "label": "Flake8",
+            "type": "shell",
+            "command": "flake8 hassio tests",
+            "group": {
+                "kind": "test",
+                "isDefault": true,
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new"
+            },
+            "problemMatcher": []
+        },
+        {
+            "label": "Pylint",
+            "type": "shell",
+            "command": "pylint hassio",
+            "dependsOn": [
+                "Install all Requirements"
+            ],
+            "group": {
+                "kind": "test",
+                "isDefault": true,
+            },
+            "presentation": {
+                "reveal": "always",
+                "panel": "new"
+            },
+            "problemMatcher": []
+        }
+    ]
+}

API.md

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

Dockerfile

@@ -0,0 +1,38 @@
+ARG BUILD_FROM
+FROM $BUILD_FROM
+
+# Install base
+RUN apk add --no-cache \
+    openssl \
+    libffi \
+    musl \
+    git \
+    socat \
+    glib \
+    libstdc++ \
+    eudev \
+    eudev-libs
+
+ARG BUILD_ARCH
+WORKDIR /usr/src
+
+# Install requirements
+COPY requirements.txt .
+RUN export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links \
+        "https://wheels.home-assistant.io/alpine-$(cut -d '.' -f 1-2 < /etc/alpine-release)/${BUILD_ARCH}/" \
+        -r ./requirements.txt \
+    && rm -f requirements.txt
+
+# Install HassIO
+COPY . hassio
+RUN pip3 install --no-cache-dir -e ./hassio \
+    && python3 -m compileall ./hassio/hassio
+
+
+# Initialize udev daemon, handle CMD
+COPY entry.sh /bin/
+ENTRYPOINT ["/bin/entry.sh"]
+
+WORKDIR /
+CMD [ "python3", "-m", "hassio" ]

LICENSE

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

README.md

@@ -1,26 +1,30 @@
-# HassIO
-### First private cloud solution for home automation.
+[![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 is a Docker based system for managing your Home Assistant installation and related applications. The system is controlled via Home Assistant which communicates with the supervisor. The supervisor provides an API to manage the installation. This includes changing network settings or installing and updating software.
+# Hass.io
+
+## First private cloud solution for home automation
+
+Hass.io is a Docker-based system for managing your Home Assistant installation
+and related applications. The system is controlled via Home Assistant which
+communicates with the Supervisor. The Supervisor provides an API to manage the
+installation. This includes changing network settings or installing
+and updating software.
 
 ![](misc/hassio.png?raw=true)
 
-[HassIO-Addons](https://github.com/home-assistant/hassio-addons) | [HassIO-Build](https://github.com/home-assistant/hassio-build)
+## Installation
 
-**HassIO is under active development and is not ready yet for production use.**
+Installation instructions can be found at <https://home-assistant.io/hassio>.
 
-## Installing Hass.io
+## Development
 
-Looks to our [website](https://home-assistant.io/hassio).
+The development of the supervisor is a bit tricky. Not difficult but tricky.
 
-# HomeAssistant
+- 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
 
-## SSL
-
-All addons that create SSL certs follow the same file structure. If you use one, put follow lines in your `configuration.yaml`.
-
-```yaml
-http:
-  ssl_certificate: /ssl/fullchain.pem
-  ssl_key: /ssl/privkey.pem
-```
+Small Bugfix or improvements, make a PR. Significant change makes first an RFC.

azure-pipelines.yml

@@ -0,0 +1,168 @@
+# https://dev.azure.com/home-assistant
+
+trigger:
+  batch: true
+  branches:
+    include:
+    - master
+    - dev
+  tags:
+    include:
+    - '*'
+    exclude:
+    - untagged*
+pr:
+  - dev
+variables:
+  - name: basePythonTag
+    value: '3.7-alpine3.10'
+  - name: versionHadolint
+    value: 'v1.16.3'
+  - name: versionBuilder
+    value: '4.4'
+  - name: versionWheels
+    value: '1.0-3.7-alpine3.10'
+  - group: docker
+  - group: wheels
+
+
+stages:
+
+- stage: 'Test'
+  jobs:
+  - job: 'Tox'
+    pool:
+      vmImage: 'ubuntu-latest'
+    steps:
+    - task: UsePythonVersion@0
+      displayName: 'Use Python 3.7'
+      inputs:
+        versionSpec: '3.7'
+    - script: pip install tox
+      displayName: 'Install Tox'
+    - script: tox
+      displayName: 'Run Tox'
+  - job: 'Black'
+    pool:
+      vmImage: 'ubuntu-latest'
+    steps:
+    - task: UsePythonVersion@0
+      displayName: 'Use Python $(python.version)'
+      inputs:
+        versionSpec: '3.7'
+    - script: pip install black
+      displayName: 'Install black'
+    - script: black --target-version py37 --check hassio tests
+      displayName: 'Run Black'
+  - job: 'JQ'
+    pool:
+      vmImage: 'ubuntu-latest'
+    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-latest'
+    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'
+
+- stage: 'Wheels'
+  jobs:
+  - job: 'Wheels'
+    condition: eq(variables['Build.SourceBranchName'], 'dev')
+    timeoutInMinutes: 360
+    pool:
+      vmImage: 'ubuntu-latest'
+    strategy:
+      maxParallel: 5
+      matrix:
+        amd64:
+          buildArch: 'amd64'
+        i386:
+          buildArch: 'i386'
+        armhf:
+          buildArch: 'armhf'
+        armv7:
+          buildArch: 'armv7'
+        aarch64:
+          buildArch: 'aarch64'
+    steps:
+    - script: |
+        sudo apt-get update
+        sudo apt-get install -y --no-install-recommends \
+          qemu-user-static \
+          binfmt-support \
+          curl
+
+        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 $(wheelsIndex) \
+          --requirement requirements.txt \
+          --upload rsync \
+          --remote wheels@$(wheelsHost):/opt/wheels
+      displayName: 'Run wheels build'
+
+- stage: 'Deploy'
+  jobs:
+  - job: 'VersionValidate'
+    condition: or(startsWith(variables['Build.SourceBranch'], 'refs/tags'), eq(variables['Build.SourceBranchName'], 'dev'))
+    pool:
+      vmImage: 'ubuntu-latest'
+    steps:
+    - task: UsePythonVersion@0
+      displayName: 'Use Python 3.7'
+      inputs:
+        versionSpec: '3.7'
+    - script: |
+        setup_version="$(python setup.py -V)"
+        branch_version="$(Build.SourceBranchName)"
+
+        if [ "${branch_version}" == "dev" ]; then
+          exit 0
+        elif [ "${setup_version}" != "${branch_version}" ]; then
+          echo "Version of tag ${branch_version} don't match with ${setup_version}!"
+          exit 1
+        fi
+      displayName: 'Check version of branch/tag'
+  - job: 'Release'
+    dependsOn:
+    - 'VersionValidate'
+    pool:
+      vmImage: 'ubuntu-latest'
+    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 $(basePythonTag) --version $(Build.SourceBranchName) \
+          --all -t /data --docker-hub homeassistant
+      displayName: 'Build Release'

entry.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+set -e
+
+udevd --daemon
+udevadm trigger
+
+if CMD="$(command -v "$1")"; then
+  shift
+  exec "$CMD" "$@"
+else
+  echo "Command not found: $1"
+  exit 1
+fi

hassio/__init__.py

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

hassio/__main__.py

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

hassio/addons/__init__.py

@@ -1,218 +1,319 @@
-"""Init file for HassIO addons."""
+"""Init file for Hass.io add-ons."""
 import asyncio
+from contextlib import suppress
 import logging
-import shutil
+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,
+    CoreDNSError,
+    DockerAPIError,
+    HomeAssistantAPIError,
+    HostAppArmorError,
+)
+from ..store.addon import AddonStore
+from .addon import Addon
 from .data import AddonsData
-from .git import AddonsRepoHassIO, AddonsRepoCustom
-from ..const import STATE_STOPPED, STATE_STARTED
-from ..dock.addon import DockerAddon
 
 _LOGGER = logging.getLogger(__name__)
 
+AnyAddon = Union[Addon, AddonStore]
 
-class AddonManager(AddonsData):
-    """Manage addons inside HassIO."""
 
-    def __init__(self, config, loop, dock):
-        """Initialize docker base wrapper."""
-        super().__init__(config)
+class AddonManager(CoreSysAttributes):
+    """Manage add-ons inside Hass.io."""
 
-        self.loop = loop
-        self.dock = dock
-        self.repositories = []
-        self.dockers = {}
+    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] = {}
 
-    async def prepare(self, arch):
-        """Startup addon management."""
-        self.arch = arch
+    @property
+    def all(self) -> List[AnyAddon]:
+        """Return a list of all add-ons."""
+        addons = {**self.store, **self.local}
+        return list(addons.values())
 
-        # init hassio repository
-        self.repositories.append(AddonsRepoHassIO(self.config, self.loop))
+    @property
+    def installed(self) -> List[Addon]:
+        """Return a list of all installed add-ons."""
+        return list(self.local.values())
 
-        # init custom repositories
-        for url in self.config.addons_repositories:
-            self.repositories.append(
-                AddonsRepoCustom(self.config, self.loop, url))
+    def get(self, addon_slug: str) -> Optional[AnyAddon]:
+        """Return an add-on from slug.
 
-        # load addon repository
-        tasks = [addon.load() for addon in self.repositories]
+        Prio:
+          1 - Local
+          2 - Store
+        """
+        if addon_slug in self.local:
+            return self.local[addon_slug]
+        return self.store.get(addon_slug)
+
+    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) -> None:
+        """Start up add-on management."""
+        tasks = []
+        for slug in self.data.system:
+            addon = self.local[slug] = Addon(self.coresys, slug)
+            tasks.append(addon.load())
+
+        # 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)
 
-            # read data from repositories
-            self.read_data_from_repositories()
-            self.merge_update_config()
+        # Sync DNS
+        await self.sync_dns()
 
-        # load installed addons
-        for addon in self.list_installed:
-            self.dockers[addon] = DockerAddon(
-                self.config, self.loop, self.dock, self, addon)
-            await self.dockers[addon].attach()
+    async def boot(self, stage: str) -> None:
+        """Boot add-ons with mode auto."""
+        tasks = []
+        for addon in self.installed:
+            if addon.boot != BOOT_AUTO or addon.startup != stage:
+                continue
+            tasks.append(addon.start())
 
-    async def add_git_repository(self, url):
-        """Add a new custom repository."""
-        if url in self.config.addons_repositories:
-            _LOGGER.warning("Repository already exists %s", url)
-            return False
+        _LOGGER.info("Phase '%s' start %d add-ons", stage, len(tasks))
+        if tasks:
+            await asyncio.wait(tasks)
+            await asyncio.sleep(self.sys_config.wait_boot)
 
-        repo = AddonsRepoCustom(self.config, self.loop, url)
+    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())
 
-        if not await repo.load():
-            _LOGGER.error("Can't load from repository %s", url)
-            return False
+        _LOGGER.info("Phase '%s' stop %d add-ons", stage, len(tasks))
+        if tasks:
+            await asyncio.wait(tasks)
 
-        self.config.addons_repositories = url
-        self.repositories.append(repo)
-        return True
+    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)
 
-    def drop_git_repository(self, url):
-        """Remove a custom repository."""
-        for repo in self.repositories:
-            if repo.url == url:
-                self.repositories.remove(repo)
-                self.config.drop_addon_repository(url)
-                repo.remove()
-                return True
+        if not store:
+            _LOGGER.error("Add-on %s not exists", slug)
+            raise AddonsError()
 
-        return False
+        if not store.available:
+            _LOGGER.error("Add-on %s not supported on that platform", slug)
+            raise AddonsNotSupportedError()
 
-    async def reload(self):
-        """Update addons from repo and reload list."""
-        tasks = [addon.pull() for addon in self.repositories]
-        if not tasks:
+        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
+            _LOGGER.info("Add-on '%s' successfully installed", slug)
+
+    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 Ingress panel from sidebar
+        if addon.ingress_panel:
+            addon.ingress_panel = False
+            with suppress(HomeAssistantAPIError):
+                await self.sys_ingress.update_hass_panel(addon)
+
+        # Cleanup internal data
+        addon.remove_discovery()
+
+        self.data.uninstall(addon)
+        self.local.pop(slug)
+
+        _LOGGER.info("Add-on '%s' successfully removed", 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
 
-        await asyncio.wait(tasks, loop=self.loop)
+        # Check if available, Maybe something have changed
+        if not store.available:
+            _LOGGER.error("Add-on %s not supported on that platform", slug)
+            raise AddonsNotSupportedError()
 
-        # read data from repositories
-        self.read_data_from_repositories()
-        self.merge_update_config()
+        # Update instance
+        last_state = await addon.state()
+        try:
+            await addon.instance.update(store.version, store.image)
 
-        # remove stalled addons
-        for addon in self.list_detached:
-            _LOGGER.warning("Dedicated addon '%s' found!", addon)
+            # Cleanup
+            with suppress(DockerAPIError):
+                await addon.instance.cleanup()
+        except DockerAPIError:
+            raise AddonsError() from None
+        else:
+            self.data.update(store)
+            _LOGGER.info("Add-on '%s' successfully updated", slug)
 
-    async def auto_boot(self, start_type):
-        """Boot addons with mode auto."""
-        boot_list = self.list_startup(start_type)
-        tasks = [self.start(addon) for addon in boot_list]
+        # Setup/Fix AppArmor profile
+        await addon.install_apparmor()
 
-        _LOGGER.info("Startup %s run %d addons", start_type, len(tasks))
-        if tasks:
-            await asyncio.wait(tasks, loop=self.loop)
+        # restore state
+        if last_state == STATE_STARTED:
+            await addon.start()
 
-    async def install(self, addon, version=None):
-        """Install a addon."""
-        if not self.exists_addon(addon):
-            _LOGGER.error("Addon %s not exists for install", addon)
-            return False
+    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 self.arch not in self.get_arch(addon):
-            _LOGGER.error("Addon %s not supported on %s", addon, self.arch)
-            return False
+        if addon.is_detached:
+            _LOGGER.error("Add-on %s is not available inside store", slug)
+            raise AddonsError()
+        store = self.store.get(slug)
 
-        if self.is_installed(addon):
-            _LOGGER.error("Addon %s is already installed", addon)
-            return False
+        # 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()
 
-        if not self.path_data(addon).is_dir():
-            _LOGGER.info("Create Home-Assistant addon data folder %s",
-                         self.path_data(addon))
-            self.path_data(addon).mkdir()
+        # 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)
+            _LOGGER.info("Add-on '%s' successfully rebuilded", slug)
 
-        addon_docker = DockerAddon(
-            self.config, self.loop, self.dock, self, addon)
+        # restore state
+        if last_state == STATE_STARTED:
+            await addon.start()
 
-        version = version or self.get_last_version(addon)
-        if not await addon_docker.install(version):
-            return False
+    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]
 
-        self.dockers[addon] = addon_docker
-        self.set_addon_install(addon, version)
-        return True
+        await addon.restore(tar_file)
 
-    async def uninstall(self, addon):
-        """Remove a addon."""
-        if not self.is_installed(addon):
-            _LOGGER.error("Addon %s is already uninstalled", addon)
-            return False
-
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
-
-        if not await self.dockers[addon].remove():
-            return False
-
-        if self.path_data(addon).is_dir():
-            _LOGGER.info("Remove Home-Assistant addon data folder %s",
-                         self.path_data(addon))
-            shutil.rmtree(str(self.path_data(addon)))
-
-        self.dockers.pop(addon)
-        self.set_addon_uninstall(addon)
-        return True
-
-    async def state(self, addon):
-        """Return running state of addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
+        # Check if new
+        if slug in self.local:
             return
 
-        if await self.dockers[addon].is_running():
-            return STATE_STARTED
-        return STATE_STOPPED
+        _LOGGER.info("Detect new Add-on after restore %s", slug)
+        self.local[slug] = addon
 
-    async def start(self, addon):
-        """Set options and start addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
+    async def repair(self) -> None:
+        """Repair local add-ons."""
+        needs_repair: List[Addon] = []
 
-        if not self.write_addon_options(addon):
-            _LOGGER.error("Can't write options for addon %s", addon)
-            return False
+        # Evaluate Add-ons to repair
+        for addon in self.installed:
+            if await addon.instance.exists():
+                continue
+            needs_repair.append(addon)
 
-        return await self.dockers[addon].run()
+        _LOGGER.info("Found %d add-ons to repair", len(needs_repair))
+        if not needs_repair:
+            return
 
-    async def stop(self, addon):
-        """Stop addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
+        for addon in needs_repair:
+            _LOGGER.info("Start repair for add-on: %s", addon.slug)
 
-        return await self.dockers[addon].stop()
+            with suppress(DockerAPIError, KeyError):
+                # Need pull a image again
+                if not addon.need_build:
+                    await addon.instance.install(addon.version, addon.image)
+                    continue
 
-    async def update(self, addon, version=None):
-        """Update addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
+                # Need local lookup
+                elif addon.need_build and not addon.is_detached:
+                    store = self.store[addon.slug]
+                    # If this add-on is available for rebuild
+                    if addon.version == store.version:
+                        await addon.instance.install(addon.version, addon.image)
+                        continue
 
-        version = version or self.get_last_version(addon)
-        is_running = self.dockers[addon].is_running()
+            _LOGGER.error("Can't repair %s", addon.slug)
+            with suppress(AddonsError):
+                await self.uninstall(addon.slug)
 
-        # update
-        if await self.dockers[addon].update(version):
-            self.set_addon_update(addon, version)
-            if is_running:
-                await self.start(addon)
-            return True
-        return False
+    async def sync_dns(self) -> None:
+        """Sync add-ons DNS names."""
+        # Update hosts
+        for addon in self.installed:
+            if not await addon.instance.is_running():
+                continue
+            self.sys_dns.add_host(
+                ipv4=addon.ip_address, names=[addon.hostname], write=False
+            )
 
-    async def restart(self, addon):
-        """Restart addon."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
-
-        return await self.dockers[addon].restart()
-
-    async def logs(self, addon):
-        """Return addons log output."""
-        if addon not in self.dockers:
-            _LOGGER.error("No docker found for addon %s", addon)
-            return False
-
-        return await self.dockers[addon].logs()
+        # Write hosts files
+        with suppress(CoreDNSError):
+            self.sys_dns.write_hosts()

hassio/addons/addon.py

@@ -0,0 +1,661 @@
+"""Init file for Hass.io add-ons."""
+from contextlib import suppress
+from copy import deepcopy
+from ipaddress import IPv4Address
+import logging
+from pathlib import Path, PurePath
+import re
+import secrets
+import shutil
+import tarfile
+from tempfile import TemporaryDirectory
+from typing import Any, Awaitable, Dict, List, Optional
+
+import voluptuous as vol
+from voluptuous.humanize import humanize_error
+
+from ..const import (
+    ATTR_ACCESS_TOKEN,
+    ATTR_AUDIO_INPUT,
+    ATTR_AUDIO_OUTPUT,
+    ATTR_AUTO_UPDATE,
+    ATTR_BOOT,
+    ATTR_IMAGE,
+    ATTR_INGRESS_ENTRY,
+    ATTR_INGRESS_PANEL,
+    ATTR_INGRESS_PORT,
+    ATTR_INGRESS_TOKEN,
+    ATTR_NETWORK,
+    ATTR_OPTIONS,
+    ATTR_PORTS,
+    ATTR_PROTECTED,
+    ATTR_SCHEMA,
+    ATTR_STATE,
+    ATTR_SYSTEM,
+    ATTR_USER,
+    ATTR_UUID,
+    ATTR_VERSION,
+    DNS_SUFFIX,
+    STATE_STARTED,
+    STATE_STOPPED,
+)
+from ..coresys import CoreSys
+from ..docker.addon import DockerAddon
+from ..docker.stats import DockerStats
+from ..exceptions import (
+    AddonsError,
+    AddonsNotSupportedError,
+    DockerAPIError,
+    HostAppArmorError,
+    JsonFileError,
+)
+from ..utils.apparmor import adjust_profile
+from ..utils.json import read_json_file, write_json_file
+from .model import AddonModel, Data
+from .utils import remove_data
+from .validate import SCHEMA_ADDON_SNAPSHOT, validate_options
+
+_LOGGER = logging.getLogger(__name__)
+
+RE_WEBUI = re.compile(
+    r"^(?:(?P<s_prefix>https?)|\[PROTO:(?P<t_proto>\w+)\])"
+    r":\/\/\[HOST\]:\[PORT:(?P<t_port>\d+)\](?P<s_suffix>.*)$"
+)
+
+
+class Addon(AddonModel):
+    """Hold data for add-on inside Hass.io."""
+
+    def __init__(self, coresys: CoreSys, slug: str):
+        """Initialize data holder."""
+        self.coresys: CoreSys = coresys
+        self.instance: DockerAddon = DockerAddon(coresys, self)
+        self.slug: str = slug
+
+    async def load(self) -> None:
+        """Async initialize of object."""
+        with suppress(DockerAPIError):
+            await self.instance.attach(tag=self.version)
+
+    @property
+    def ip_address(self) -> IPv4Address:
+        """Return IP of Add-on instance."""
+        return self.instance.ip_address
+
+    @property
+    def data(self) -> Data:
+        """Return add-on data/config."""
+        return self.sys_addons.data.system[self.slug]
+
+    @property
+    def data_store(self) -> Data:
+        """Return add-on data from store."""
+        return self.sys_store.data.addons.get(self.slug, self.data)
+
+    @property
+    def persist(self) -> Data:
+        """Return add-on data/config."""
+        return self.sys_addons.data.user[self.slug]
+
+    @property
+    def is_installed(self) -> bool:
+        """Return True if an add-on is installed."""
+        return True
+
+    @property
+    def is_detached(self) -> bool:
+        """Return True if add-on is detached."""
+        return self.slug not in self.sys_store.data.addons
+
+    @property
+    def available(self) -> bool:
+        """Return True if this add-on is available on this platform."""
+        return self._available(self.data_store)
+
+    @property
+    def version(self) -> Optional[str]:
+        """Return installed version."""
+        return self.persist[ATTR_VERSION]
+
+    @property
+    def dns(self) -> List[str]:
+        """Return list of DNS name for that add-on."""
+        return [f"{self.hostname}.{DNS_SUFFIX}"]
+
+    @property
+    def options(self) -> Dict[str, Any]:
+        """Return options with local changes."""
+        return {**self.data[ATTR_OPTIONS], **self.persist[ATTR_OPTIONS]}
+
+    @options.setter
+    def options(self, value: Optional[Dict[str, Any]]):
+        """Store user add-on options."""
+        if value is None:
+            self.persist[ATTR_OPTIONS] = {}
+        else:
+            self.persist[ATTR_OPTIONS] = deepcopy(value)
+
+    @property
+    def boot(self) -> bool:
+        """Return boot config with prio local settings."""
+        return self.persist.get(ATTR_BOOT, super().boot)
+
+    @boot.setter
+    def boot(self, value: bool):
+        """Store user boot options."""
+        self.persist[ATTR_BOOT] = value
+
+    @property
+    def auto_update(self) -> bool:
+        """Return if auto update is enable."""
+        return self.persist.get(ATTR_AUTO_UPDATE, super().auto_update)
+
+    @auto_update.setter
+    def auto_update(self, value: bool):
+        """Set auto update."""
+        self.persist[ATTR_AUTO_UPDATE] = value
+
+    @property
+    def uuid(self) -> str:
+        """Return an API token for this add-on."""
+        return self.persist[ATTR_UUID]
+
+    @property
+    def hassio_token(self) -> Optional[str]:
+        """Return access token for Hass.io API."""
+        return self.persist.get(ATTR_ACCESS_TOKEN)
+
+    @property
+    def ingress_token(self) -> Optional[str]:
+        """Return access token for Hass.io API."""
+        return self.persist.get(ATTR_INGRESS_TOKEN)
+
+    @property
+    def ingress_entry(self) -> Optional[str]:
+        """Return ingress external URL."""
+        if self.with_ingress:
+            return f"/api/hassio_ingress/{self.ingress_token}"
+        return None
+
+    @property
+    def latest_version(self) -> str:
+        """Return version of add-on."""
+        return self.data_store[ATTR_VERSION]
+
+    @property
+    def protected(self) -> bool:
+        """Return if add-on is in protected mode."""
+        return self.persist[ATTR_PROTECTED]
+
+    @protected.setter
+    def protected(self, value: bool):
+        """Set add-on in protected mode."""
+        self.persist[ATTR_PROTECTED] = value
+
+    @property
+    def ports(self) -> Optional[Dict[str, Optional[int]]]:
+        """Return ports of add-on."""
+        return self.persist.get(ATTR_NETWORK, super().ports)
+
+    @ports.setter
+    def ports(self, value: Optional[Dict[str, Optional[int]]]):
+        """Set custom ports of add-on."""
+        if value is None:
+            self.persist.pop(ATTR_NETWORK, None)
+            return
+
+        # Secure map ports to value
+        new_ports = {}
+        for container_port, host_port in value.items():
+            if container_port in self.data.get(ATTR_PORTS, {}):
+                new_ports[container_port] = host_port
+
+        self.persist[ATTR_NETWORK] = new_ports
+
+    @property
+    def ingress_url(self) -> Optional[str]:
+        """Return URL to ingress url."""
+        if not self.with_ingress:
+            return None
+
+        url = f"/api/hassio_ingress/{self.ingress_token}/"
+        if ATTR_INGRESS_ENTRY in self.data:
+            return f"{url}{self.data[ATTR_INGRESS_ENTRY]}"
+        return url
+
+    @property
+    def webui(self) -> Optional[str]:
+        """Return URL to webui or None."""
+        url = super().webui
+        if not url:
+            return None
+        webui = RE_WEBUI.match(url)
+
+        # extract arguments
+        t_port = webui.group("t_port")
+        t_proto = webui.group("t_proto")
+        s_prefix = webui.group("s_prefix") or ""
+        s_suffix = webui.group("s_suffix") or ""
+
+        # search host port for this docker port
+        if self.ports is None:
+            port = t_port
+        else:
+            port = self.ports.get(f"{t_port}/tcp", t_port)
+
+        # for interface config or port lists
+        if isinstance(port, (tuple, list)):
+            port = port[-1]
+
+        # lookup the correct protocol from config
+        if t_proto:
+            proto = "https" if self.options[t_proto] else "http"
+        else:
+            proto = s_prefix
+
+        return f"{proto}://[HOST]:{port}{s_suffix}"
+
+    @property
+    def ingress_port(self) -> Optional[int]:
+        """Return Ingress port."""
+        if not self.with_ingress:
+            return None
+
+        port = self.data[ATTR_INGRESS_PORT]
+        if port == 0:
+            return self.sys_ingress.get_dynamic_port(self.slug)
+        return port
+
+    @property
+    def ingress_panel(self) -> Optional[bool]:
+        """Return True if the add-on access support ingress."""
+        return self.persist[ATTR_INGRESS_PANEL]
+
+    @ingress_panel.setter
+    def ingress_panel(self, value: bool):
+        """Return True if the add-on access support ingress."""
+        self.persist[ATTR_INGRESS_PANEL] = value
+
+    @property
+    def audio_output(self) -> Optional[str]:
+        """Return ALSA config for output or None."""
+        if not self.with_audio:
+            return None
+        return self.persist.get(ATTR_AUDIO_OUTPUT, self.sys_host.alsa.default.output)
+
+    @audio_output.setter
+    def audio_output(self, value: Optional[str]):
+        """Set/reset audio output settings."""
+        if value is None:
+            self.persist.pop(ATTR_AUDIO_OUTPUT, None)
+        else:
+            self.persist[ATTR_AUDIO_OUTPUT] = value
+
+    @property
+    def audio_input(self) -> Optional[str]:
+        """Return ALSA config for input or None."""
+        if not self.with_audio:
+            return None
+        return self.persist.get(ATTR_AUDIO_INPUT, self.sys_host.alsa.default.input)
+
+    @audio_input.setter
+    def audio_input(self, value: Optional[str]):
+        """Set/reset audio input settings."""
+        if value is None:
+            self.persist.pop(ATTR_AUDIO_INPUT, None)
+        else:
+            self.persist[ATTR_AUDIO_INPUT] = value
+
+    @property
+    def image(self):
+        """Return image name of add-on."""
+        return self.persist.get(ATTR_IMAGE)
+
+    @property
+    def need_build(self):
+        """Return True if this  add-on need a local build."""
+        return ATTR_IMAGE not in self.data
+
+    @property
+    def path_data(self):
+        """Return add-on data path inside Supervisor."""
+        return Path(self.sys_config.path_addons_data, self.slug)
+
+    @property
+    def path_extern_data(self):
+        """Return add-on data path external for Docker."""
+        return PurePath(self.sys_config.path_extern_addons_data, self.slug)
+
+    @property
+    def path_options(self):
+        """Return path to add-on options."""
+        return Path(self.path_data, "options.json")
+
+    @property
+    def path_asound(self):
+        """Return path to asound config."""
+        return Path(self.sys_config.path_tmp, f"{self.slug}_asound")
+
+    @property
+    def path_extern_asound(self):
+        """Return path to asound config for Docker."""
+        return Path(self.sys_config.path_extern_tmp, f"{self.slug}_asound")
+
+    def save_persist(self):
+        """Save data of add-on."""
+        self.sys_addons.data.save_data()
+
+    def write_options(self):
+        """Return True if add-on options is written to data."""
+        schema = self.schema
+        options = self.options
+
+        try:
+            schema(options)
+            write_json_file(self.path_options, options)
+        except vol.Invalid as ex:
+            _LOGGER.error(
+                "Add-on %s have wrong options: %s",
+                self.slug,
+                humanize_error(options, ex),
+            )
+        except JsonFileError:
+            _LOGGER.error("Add-on %s can't write options", self.slug)
+        else:
+            _LOGGER.debug("Add-on %s write options: %s", self.slug, options)
+            return
+
+        raise AddonsError()
+
+    def remove_discovery(self):
+        """Remove all discovery message from add-on."""
+        for message in self.sys_discovery.list_messages:
+            if message.addon != self.slug:
+                continue
+            self.sys_discovery.remove(message)
+
+    async def remove_data(self):
+        """Remove add-on data."""
+        if not self.path_data.is_dir():
+            return
+
+        _LOGGER.info("Remove add-on data folder %s", self.path_data)
+        await remove_data(self.path_data)
+
+    def write_asound(self):
+        """Write asound config to file and return True on success."""
+        asound_config = self.sys_host.alsa.asound(
+            alsa_input=self.audio_input, alsa_output=self.audio_output
+        )
+
+        try:
+            with self.path_asound.open("w") as config_file:
+                config_file.write(asound_config)
+        except OSError as err:
+            _LOGGER.error("Add-on %s can't write asound: %s", self.slug, err)
+            raise AddonsError()
+
+        _LOGGER.debug("Add-on %s write asound: %s", self.slug, self.path_asound)
+
+    async def install_apparmor(self) -> None:
+        """Install or Update AppArmor profile for Add-on."""
+        exists_local = self.sys_host.apparmor.exists(self.slug)
+        exists_addon = self.path_apparmor.exists()
+
+        # Nothing to do
+        if not exists_local and not exists_addon:
+            return
+
+        # Need removed
+        if exists_local and not exists_addon:
+            await self.sys_host.apparmor.remove_profile(self.slug)
+            return
+
+        # Need install/update
+        with TemporaryDirectory(dir=self.sys_config.path_tmp) as tmp_folder:
+            profile_file = Path(tmp_folder, "apparmor.txt")
+
+            adjust_profile(self.slug, self.path_apparmor, profile_file)
+            await self.sys_host.apparmor.load_profile(self.slug, profile_file)
+
+    async def uninstall_apparmor(self) -> None:
+        """Remove AppArmor profile for Add-on."""
+        if not self.sys_host.apparmor.exists(self.slug):
+            return
+        await self.sys_host.apparmor.remove_profile(self.slug)
+
+    def test_update_schema(self) -> bool:
+        """Check if the existing configuration is valid after update."""
+        # load next schema
+        new_raw_schema = self.data_store[ATTR_SCHEMA]
+        default_options = self.data_store[ATTR_OPTIONS]
+
+        # if disabled
+        if isinstance(new_raw_schema, bool):
+            return True
+
+        # merge options
+        options = {**self.persist[ATTR_OPTIONS], **default_options}
+
+        # create voluptuous
+        new_schema = vol.Schema(vol.All(dict, validate_options(new_raw_schema)))
+
+        # validate
+        try:
+            new_schema(options)
+        except vol.Invalid:
+            _LOGGER.warning("Add-on %s new schema is not compatible", self.slug)
+            return False
+        return True
+
+    async def state(self) -> str:
+        """Return running state of add-on."""
+        if await self.instance.is_running():
+            return STATE_STARTED
+        return STATE_STOPPED
+
+    async def start(self) -> None:
+        """Set options and start add-on."""
+        if await self.instance.is_running():
+            _LOGGER.warning("%s already running!", self.slug)
+            return
+
+        # Access Token
+        self.persist[ATTR_ACCESS_TOKEN] = secrets.token_hex(56)
+        self.save_persist()
+
+        # Options
+        self.write_options()
+
+        # Sound
+        if self.with_audio:
+            self.write_asound()
+
+        try:
+            await self.instance.run()
+        except DockerAPIError:
+            raise AddonsError() from None
+
+    async def stop(self) -> None:
+        """Stop add-on."""
+        try:
+            return await self.instance.stop()
+        except DockerAPIError:
+            raise AddonsError() from None
+
+    async def restart(self) -> None:
+        """Restart add-on."""
+        with suppress(AddonsError):
+            await self.stop()
+        await self.start()
+
+    def logs(self) -> Awaitable[bytes]:
+        """Return add-ons log output.
+
+        Return a coroutine.
+        """
+        return self.instance.logs()
+
+    async def stats(self) -> DockerStats:
+        """Return stats of container."""
+        try:
+            return await self.instance.stats()
+        except DockerAPIError:
+            raise AddonsError() from None
+
+    async def write_stdin(self, data):
+        """Write data to add-on stdin.
+
+        Return a coroutine.
+        """
+        if not self.with_stdin:
+            _LOGGER.error("Add-on don't support write to stdin!")
+            raise AddonsNotSupportedError()
+
+        try:
+            return await self.instance.write_stdin(data)
+        except DockerAPIError:
+            raise AddonsError() from None
+
+    async def snapshot(self, tar_file: tarfile.TarFile) -> None:
+        """Snapshot state of an add-on."""
+        with TemporaryDirectory(dir=str(self.sys_config.path_tmp)) as temp:
+            # store local image
+            if self.need_build:
+                try:
+                    await self.instance.export_image(Path(temp, "image.tar"))
+                except DockerAPIError:
+                    raise AddonsError() from None
+
+            data = {
+                ATTR_USER: self.persist,
+                ATTR_SYSTEM: self.data,
+                ATTR_VERSION: self.version,
+                ATTR_STATE: await self.state(),
+            }
+
+            # Store local configs/state
+            try:
+                write_json_file(Path(temp, "addon.json"), data)
+            except JsonFileError:
+                _LOGGER.error("Can't save meta for %s", self.slug)
+                raise AddonsError() from None
+
+            # Store AppArmor Profile
+            if self.sys_host.apparmor.exists(self.slug):
+                profile = Path(temp, "apparmor.txt")
+                try:
+                    self.sys_host.apparmor.backup_profile(self.slug, profile)
+                except HostAppArmorError:
+                    _LOGGER.error("Can't backup AppArmor profile")
+                    raise AddonsError() from None
+
+            # write into tarfile
+            def _write_tarfile():
+                """Write tar inside loop."""
+                with tar_file as snapshot:
+                    snapshot.add(temp, arcname=".")
+                    snapshot.add(self.path_data, arcname="data")
+
+            try:
+                _LOGGER.info("Build snapshot for add-on %s", self.slug)
+                await self.sys_run_in_executor(_write_tarfile)
+            except (tarfile.TarError, OSError) as err:
+                _LOGGER.error("Can't write tarfile %s: %s", tar_file, err)
+                raise AddonsError() from None
+
+        _LOGGER.info("Finish snapshot for addon %s", self.slug)
+
+    async def restore(self, tar_file: tarfile.TarFile) -> None:
+        """Restore state of an add-on."""
+        with TemporaryDirectory(dir=str(self.sys_config.path_tmp)) as temp:
+            # extract snapshot
+            def _extract_tarfile():
+                """Extract tar snapshot."""
+                with tar_file as snapshot:
+                    snapshot.extractall(path=Path(temp))
+
+            try:
+                await self.sys_run_in_executor(_extract_tarfile)
+            except tarfile.TarError as err:
+                _LOGGER.error("Can't read tarfile %s: %s", tar_file, err)
+                raise AddonsError() from None
+
+            # Read snapshot data
+            try:
+                data = read_json_file(Path(temp, "addon.json"))
+            except JsonFileError:
+                raise AddonsError() from None
+
+            # Validate
+            try:
+                data = SCHEMA_ADDON_SNAPSHOT(data)
+            except vol.Invalid as err:
+                _LOGGER.error(
+                    "Can't validate %s, snapshot data: %s",
+                    self.slug,
+                    humanize_error(data, err),
+                )
+                raise AddonsError() from None
+
+            # If available
+            if not self._available(data[ATTR_SYSTEM]):
+                _LOGGER.error("Add-on %s is not available for this Platform", self.slug)
+                raise AddonsNotSupportedError()
+
+            # Restore local add-on informations
+            _LOGGER.info("Restore config for addon %s", self.slug)
+            restore_image = self._image(data[ATTR_SYSTEM])
+            self.sys_addons.data.restore(
+                self.slug, data[ATTR_USER], data[ATTR_SYSTEM], restore_image
+            )
+
+            # Check version / restore image
+            version = data[ATTR_VERSION]
+            if not await self.instance.exists():
+                _LOGGER.info("Restore/Install image for addon %s", self.slug)
+
+                image_file = Path(temp, "image.tar")
+                if image_file.is_file():
+                    with suppress(DockerAPIError):
+                        await self.instance.import_image(image_file)
+                else:
+                    with suppress(DockerAPIError):
+                        await self.instance.install(version, restore_image)
+                        await self.instance.cleanup()
+            elif self.instance.version != version or self.legacy:
+                _LOGGER.info("Restore/Update image for addon %s", self.slug)
+                with suppress(DockerAPIError):
+                    await self.instance.update(version, restore_image)
+            else:
+                with suppress(DockerAPIError):
+                    await self.instance.stop()
+
+            # Restore data
+            def _restore_data():
+                """Restore data."""
+                shutil.copytree(str(Path(temp, "data")), str(self.path_data))
+
+            _LOGGER.info("Restore data for addon %s", self.slug)
+            if self.path_data.is_dir():
+                await remove_data(self.path_data)
+            try:
+                await self.sys_run_in_executor(_restore_data)
+            except shutil.Error as err:
+                _LOGGER.error("Can't restore origin data: %s", err)
+                raise AddonsError() from None
+
+            # Restore AppArmor
+            profile_file = Path(temp, "apparmor.txt")
+            if profile_file.exists():
+                try:
+                    await self.sys_host.apparmor.load_profile(self.slug, profile_file)
+                except HostAppArmorError:
+                    _LOGGER.error("Can't restore AppArmor profile")
+                    raise AddonsError() from None
+
+            # Run add-on
+            if data[ATTR_STATE] == STATE_STARTED:
+                return await self.start()
+
+        _LOGGER.info("Finish restore for add-on %s", self.slug)

hassio/addons/build.py

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

hassio/addons/built-in.json

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

hassio/addons/data.py

@@ -1,361 +1,73 @@
-"""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, PurePath
+from typing import Any, Dict
 
-import voluptuous as vol
-from voluptuous.humanize import humanize_error
-
-from .util import extract_hash_from_path
-from .validate import (
-    validate_options, SCHEMA_ADDON_CONFIG, SCHEMA_REPOSITORY_CONFIG)
 from ..const import (
-    FILE_HASSIO_ADDONS, ATTR_NAME, ATTR_VERSION, ATTR_SLUG, ATTR_DESCRIPTON,
-    ATTR_STARTUP, ATTR_BOOT, ATTR_MAP, ATTR_OPTIONS, ATTR_PORTS, BOOT_AUTO,
-    DOCKER_REPO, ATTR_SCHEMA, ATTR_IMAGE, MAP_CONFIG, MAP_SSL, MAP_ADDONS,
-    MAP_BACKUP, ATTR_REPOSITORY, ATTR_URL, ATTR_ARCH)
-from ..config import Config
-from ..tools import read_json_file, write_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__)
 
-SYSTEM = 'system'
-USER = 'user'
-
-REPOSITORY_CORE = 'core'
-REPOSITORY_LOCAL = 'local'
+Config = Dict[str, Any]
 
 
-class AddonsData(Config):
-    """Hold data for addons inside HassIO."""
+class AddonsData(JsonConfig, CoreSysAttributes):
+    """Hold data for installed Add-ons inside Hass.io."""
 
-    def __init__(self, config):
+    def __init__(self, coresys: CoreSys):
         """Initialize data holder."""
-        super().__init__(FILE_HASSIO_ADDONS)
-        self.config = config
-        self._system_data = self._data.get(SYSTEM, {})
-        self._user_data = self._data.get(USER, {})
-        self._addons_cache = {}
-        self._repositories_data = {}
-        self.arch = None
-
-    def save(self):
-        """Store data to config file."""
-        self._data = {
-            USER: self._user_data,
-            SYSTEM: self._system_data,
-        }
-        super().save()
-
-    def read_data_from_repositories(self):
-        """Read data from addons repository."""
-        self._addons_cache = {}
-        self._repositories_data = {}
-
-        # read core repository
-        self._read_addons_folder(
-            self.config.path_addons_core, REPOSITORY_CORE)
-
-        # 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)
-
-    def _read_git_repository(self, path):
-        """Process a custom repository folder."""
-        slug = extract_hash_from_path(path)
-        repository_info = {ATTR_SLUG: slug}
-
-        # exists repository json
-        repository_file = Path(path, "repository.json")
-        try:
-            repository_info.update(SCHEMA_REPOSITORY_CONFIG(
-                read_json_file(repository_file)
-            ))
-
-        except OSError:
-            _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_data[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
-                self._addons_cache[addon_slug] = addon_config
-
-            except OSError:
-                _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
-
-        # if core addons are available
-        for data in self._addons_cache.values():
-            if data[ATTR_REPOSITORY] == REPOSITORY_CORE:
-                self._repositories_data[REPOSITORY_CORE] = \
-                    builtin_data[REPOSITORY_CORE]
-                break
-
-        # if local addons are available
-        for data in self._addons_cache.values():
-            if data[ATTR_REPOSITORY] == REPOSITORY_LOCAL:
-                self._repositories_data[REPOSITORY_LOCAL] = \
-                    builtin_data[REPOSITORY_LOCAL]
-                break
-
-    def merge_update_config(self):
-        """Update local config if they have update.
-
-        It need to be the same version as the local version is.
-        """
-        have_change = False
-
-        for addon, data in self._system_data.items():
-            # detached
-            if addon not in self._addons_cache:
-                continue
-
-            cache = self._addons_cache[addon]
-            if data[ATTR_VERSION] == cache[ATTR_VERSION]:
-                if data != cache:
-                    self._system_data[addon] = copy.deepcopy(cache)
-                    have_change = True
-
-        if have_change:
-            self.save()
+        super().__init__(FILE_HASSIO_ADDONS, SCHEMA_ADDONS_FILE)
+        self.coresys: CoreSys = coresys
 
     @property
-    def list_installed(self):
-        """Return a list of installed addons."""
-        return set(self._system_data.keys())
+    def user(self):
+        """Return local add-on user data."""
+        return self._data[ATTR_USER]
 
     @property
-    def data_all(self):
-        """Return a dict of all addons."""
-        return {
-            **self._system_data,
-            **self._addons_cache
-        }
+    def system(self):
+        """Return local add-on data."""
+        return self._data[ATTR_SYSTEM]
 
-    @property
-    def data_installed(self):
-        """Return a dict of installed addons."""
-        return self._system_data.copy()
-
-    def list_startup(self, start_type):
-        """Get list of installed addon with need start by type."""
-        addon_list = set()
-        for addon in self._system_data.keys():
-            if self.get_boot(addon) != BOOT_AUTO:
-                continue
-
-            try:
-                if self._system_data[addon][ATTR_STARTUP] == start_type:
-                    addon_list.add(addon)
-            except KeyError:
-                _LOGGER.warning("Orphaned addon detect %s", addon)
-                continue
-
-        return addon_list
-
-    @property
-    def list_detached(self):
-        """Return local addons they not support from repo."""
-        addon_list = set()
-        for addon in self._system_data.keys():
-            if addon not in self._addons_cache:
-                addon_list.add(addon)
-
-        return addon_list
-
-    @property
-    def list_repositories(self):
-        """Return list of addon repositories."""
-        return list(self._repositories_data.values())
-
-    def exists_addon(self, addon):
-        """Return True if a addon exists."""
-        return addon in self._addons_cache or addon in self._system_data
-
-    def is_installed(self, addon):
-        """Return True if a addon is installed."""
-        return addon in self._system_data
-
-    def version_installed(self, addon):
-        """Return installed version."""
-        return self._user_data.get(addon, {}).get(ATTR_VERSION)
-
-    def set_addon_install(self, addon, version):
+    def install(self, addon: AddonStore) -> None:
         """Set addon as installed."""
-        self._system_data[addon] = copy.deepcopy(self._addons_cache[addon])
-        self._user_data[addon] = {
+        self.system[addon.slug] = deepcopy(addon.data)
+        self.user[addon.slug] = {
             ATTR_OPTIONS: {},
-            ATTR_VERSION: version,
+            ATTR_VERSION: addon.version,
+            ATTR_IMAGE: addon.image,
         }
-        self.save()
+        self.save_data()
 
-    def set_addon_uninstall(self, addon):
-        """Set addon as uninstalled."""
-        self._system_data.pop(addon, None)
-        self._user_data.pop(addon, None)
-        self.save()
+    def 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 set_addon_update(self, addon, version):
-        """Update version of addon."""
-        self._system_data[addon] = copy.deepcopy(self._addons_cache[addon])
-        self._user_data[addon][ATTR_VERSION] = version
-        self.save()
+    def 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()
 
-    def set_options(self, addon, options):
-        """Store user addon options."""
-        self._user_data[addon][ATTR_OPTIONS] = copy.deepcopy(options)
-        self.save()
+    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)
 
-    def set_boot(self, addon, boot):
-        """Store user boot options."""
-        self._user_data[addon][ATTR_BOOT] = boot
-        self.save()
-
-    def get_options(self, addon):
-        """Return options with local changes."""
-        return {
-            **self._system_data[addon][ATTR_OPTIONS],
-            **self._user_data[addon][ATTR_OPTIONS],
-        }
-
-    def get_boot(self, addon):
-        """Return boot config with prio local settings."""
-        if ATTR_BOOT in self._user_data[addon]:
-            return self._user_data[addon][ATTR_BOOT]
-
-        return self._system_data[addon][ATTR_BOOT]
-
-    def get_name(self, addon):
-        """Return name of addon."""
-        return self._system_data[addon][ATTR_NAME]
-
-    def get_description(self, addon):
-        """Return description of addon."""
-        return self._system_data[addon][ATTR_DESCRIPTON]
-
-    def get_repository(self, addon):
-        """Return repository of addon."""
-        return self._system_data[addon][ATTR_REPOSITORY]
-
-    def get_last_version(self, addon):
-        """Return version of addon."""
-        if addon not in self._addons_cache:
-            return self.version_installed(addon)
-        return self._addons_cache[addon][ATTR_VERSION]
-
-    def get_ports(self, addon):
-        """Return ports of addon."""
-        return self._system_data[addon].get(ATTR_PORTS)
-
-    def get_url(self, addon):
-        """Return url of addon."""
-        return self._system_data[addon].get(ATTR_URL)
-
-    def get_arch(self, addon):
-        """Return list of supported arch."""
-        if addon not in self._addons_cache:
-            return self._system_data[addon][ATTR_ARCH]
-        return self._addons_cache[addon][ATTR_ARCH]
-
-    def get_image(self, addon):
-        """Return image name of addon."""
-        addon_data = self._system_data.get(
-            addon, self._addons_cache.get(addon))
-
-        if ATTR_IMAGE not in addon_data:
-            return "{}/{}-addon-{}".format(
-                DOCKER_REPO, self.arch, addon_data[ATTR_SLUG])
-
-        return addon_data[ATTR_IMAGE].format(arch=self.arch)
-
-    def map_config(self, addon):
-        """Return True if config map is needed."""
-        return MAP_CONFIG in self._system_data[addon][ATTR_MAP]
-
-    def map_ssl(self, addon):
-        """Return True if ssl map is needed."""
-        return MAP_SSL in self._system_data[addon][ATTR_MAP]
-
-    def map_addons(self, addon):
-        """Return True if addons map is needed."""
-        return MAP_ADDONS in self._system_data[addon][ATTR_MAP]
-
-    def map_backup(self, addon):
-        """Return True if backup map is needed."""
-        return MAP_BACKUP in self._system_data[addon][ATTR_MAP]
-
-    def path_data(self, addon):
-        """Return addon data path inside supervisor."""
-        return Path(self.config.path_addons_data, addon)
-
-    def path_extern_data(self, addon):
-        """Return addon data path external for docker."""
-        return str(PurePath(self.config.path_extern_addons_data, addon))
-
-    def path_addon_options(self, addon):
-        """Return path to addons options."""
-        return Path(self.path_data(addon), "options.json")
-
-    def write_addon_options(self, addon):
-        """Return True if addon options is written to data."""
-        schema = self.get_schema(addon)
-        options = self.get_options(addon)
-
-        try:
-            schema(options)
-            return write_json_file(self.path_addon_options(addon), options)
-        except vol.Invalid as ex:
-            _LOGGER.error("Addon %s have wrong options -> %s", addon,
-                          humanize_error(options, ex))
-
-        return False
-
-    def get_schema(self, addon):
-        """Create a schema for addon options."""
-        raw_schema = self._system_data[addon][ATTR_SCHEMA]
-
-        schema = vol.Schema(vol.All(dict, validate_options(raw_schema)))
-        return schema
+        self.user[slug][ATTR_IMAGE] = image
+        self.save_data()

hassio/addons/git.py

@@ -1,107 +0,0 @@
-"""Init file for HassIO addons git."""
-import asyncio
-import logging
-from pathlib import Path
-import shutil
-
-import git
-
-from .util import get_hash_from_repository
-from ..const import URL_HASSIO_ADDONS
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class AddonsRepo(object):
-    """Manage addons git repo."""
-
-    def __init__(self, config, loop, path, url):
-        """Initialize git base wrapper."""
-        self.config = config
-        self.loop = loop
-        self.repo = None
-        self.path = path
-        self.url = url
-        self._lock = asyncio.Lock(loop=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, git.Repo.clone_from, self.url, str(self.path))
-
-            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.exc.GitCommandError) as err:
-                _LOGGER.error("Can't pull %s repo: %s.", self.url, err)
-                return False
-
-            return True
-
-
-class AddonsRepoHassIO(AddonsRepo):
-    """HassIO addons repository."""
-
-    def __init__(self, config, loop):
-        """Initialize git hassio addon repository."""
-        super().__init__(
-            config, loop, config.path_addons_core, URL_HASSIO_ADDONS)
-
-
-class AddonsRepoCustom(AddonsRepo):
-    """Custom addons repository."""
-
-    def __init__(self, config, loop, url):
-        """Initialize git hassio addon repository."""
-        path = Path(config.path_addons_git, get_hash_from_repository(url))
-
-        super().__init__(config, loop, 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,514 @@
+"""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_UDEV,
+    ATTR_URL,
+    ATTR_VERSION,
+    ATTR_WEBUI,
+    SECURITY_DEFAULT,
+    SECURITY_DISABLE,
+    SECURITY_PROFILE,
+)
+from ..coresys import CoreSysAttributes
+from .validate import 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 hostname(self) -> str:
+        """Return slug/id of add-on."""
+        return self.slug.replace("_", "-")
+
+    @property
+    def dns(self) -> List[str]:
+        """Return list of DNS name for that add-on."""
+        return []
+
+    @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_udev(self) -> bool:
+        """Return True if the add-on have his own udev."""
+        return self.data[ATTR_UDEV]
+
+    @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, [])
+
+    @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 not isinstance(other, AddonModel):
+            return False
+        return self.slug == other.slug
+
+    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)
+        if machine and 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/util.py

@@ -1,26 +0,0 @@
-"""Util addons functions."""
-import hashlib
-import re
-
-RE_SLUGIFY = re.compile(r'[^a-z0-9_]+')
-RE_SHA1 = re.compile(r"[a-f0-9]{8}")
-
-
-def get_hash_from_repository(name):
-    """Generate a hash from repository."""
-    key = name.lower().encode()
-    return hashlib.sha1(key).hexdigest()[:8]
-
-
-def extract_hash_from_path(path):
-    """Extract repo id from path."""
-    repo_dir = path.parts[-1]
-
-    if not RE_SHA1.match(repo_dir):
-        return get_hash_from_repository(repo_dir)
-    return repo_dir
-
-
-def create_hash_index_list(name_list):
-    """Create a dict with hash from repositories list."""
-    return {get_hash_from_repository(repo): repo for repo in name_list}

hassio/addons/utils.py

@@ -0,0 +1,99 @@
+"""Util add-ons functions."""
+from __future__ import annotations
+
+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 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)
+
+
+async def remove_data(folder: Path) -> None:
+    """Remove folder and reset privileged."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "rm", "-rf", str(folder), stdout=asyncio.subprocess.DEVNULL
+        )
+
+        _, error_msg = await proc.communicate()
+    except OSError as err:
+        error_msg = str(err)
+    else:
+        if proc.returncode == 0:
+            return
+
+    _LOGGER.error("Can't remove Add-on Data: %s", error_msg)

hassio/addons/validate.py

@@ -1,132 +1,421 @@
-"""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_AFTER,
-    STARTUP_BEFORE, BOOT_AUTO, BOOT_MANUAL, ATTR_SCHEMA, ATTR_IMAGE, MAP_SSL,
-    MAP_CONFIG, MAP_ADDONS, MAP_BACKUP, ATTR_URL, ATTR_MAINTAINER, ATTR_ARCH,
-    ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386)
+    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_PANEL,
+    ATTR_INGRESS_PORT,
+    ATTR_INGRESS_TOKEN,
+    ATTR_KERNEL_MODULES,
+    ATTR_LEGACY,
+    ATTR_LOCATON,
+    ATTR_MACHINE,
+    ATTR_MAP,
+    ATTR_NAME,
+    ATTR_NETWORK,
+    ATTR_OPTIONS,
+    ATTR_PANEL_ADMIN,
+    ATTR_PANEL_ICON,
+    ATTR_PANEL_TITLE,
+    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_UDEV,
+    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,
+)
 
-V_STR = 'str'
-V_INT = 'int'
-V_FLOAT = 'float'
-V_BOOL = 'bool'
-V_EMAIL = 'email'
-V_URL = 'url'
+_LOGGER = logging.getLogger(__name__)
 
-ADDON_ELEMENT = vol.In([V_STR, V_INT, V_FLOAT, V_BOOL, V_EMAIL, V_URL])
 
-ARCH_ALL = [
-    ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386
+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"
+V_FLOAT = "float"
+V_BOOL = "bool"
+V_EMAIL = "email"
+V_URL = "url"
+V_PORT = "port"
+V_MATCH = "match"
+
+RE_SCHEMA_ELEMENT = re.compile(
+    r"^(?:"
+    r"|str|bool|email|url|port"
+    r"|int(?:\((?P<i_min>\d+)?,(?P<i_max>\d+)?\))?"
+    r"|float(?:\((?P<f_min>[\d\.]+)?,(?P<f_max>[\d\.]+)?\))?"
+    r"|match\((?P<match>.*)\)"
+    r")\??$"
+)
+
+RE_DOCKER_IMAGE = re.compile(r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)$")
+RE_DOCKER_IMAGE_BUILD = re.compile(
+    r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)(:[\.\-\w{}]+)?$"
+)
+
+SCHEMA_ELEMENT = vol.Match(RE_SCHEMA_ELEMENT)
+
+
+MACHINE_ALL = [
+    "intel-nuc",
+    "odroid-c2",
+    "odroid-xu",
+    "orangepi-prime",
+    "qemux86",
+    "qemux86-64",
+    "qemuarm",
+    "qemuarm-64",
+    "raspberrypi",
+    "raspberrypi2",
+    "raspberrypi3",
+    "raspberrypi3-64",
+    "raspberrypi4",
+    "raspberrypi4-64",
+    "tinker",
 ]
 
+
+def _simple_startup(value):
+    """Simple startup schema."""
+    if value == "before":
+        return STARTUP_SERVICES
+    if value == "after":
+        return STARTUP_APPLICATION
+    return value
+
+
 # pylint: disable=no-value-for-parameter
-SCHEMA_ADDON_CONFIG = vol.Schema({
-    vol.Required(ATTR_NAME): vol.Coerce(str),
-    vol.Required(ATTR_VERSION): vol.Coerce(str),
-    vol.Required(ATTR_SLUG): vol.Coerce(str),
-    vol.Required(ATTR_DESCRIPTON): vol.Coerce(str),
-    vol.Optional(ATTR_URL): vol.Url(),
-    vol.Optional(ATTR_ARCH, default=ARCH_ALL): [vol.In(ARCH_ALL)],
-    vol.Required(ATTR_STARTUP):
-        vol.In([STARTUP_BEFORE, STARTUP_AFTER, STARTUP_ONCE]),
-    vol.Required(ATTR_BOOT):
-        vol.In([BOOT_AUTO, BOOT_MANUAL]),
-    vol.Optional(ATTR_PORTS): dict,
-    vol.Optional(ATTR_MAP, default=[]): [
-        vol.In([MAP_CONFIG, MAP_SSL, MAP_ADDONS, MAP_BACKUP])
-    ],
-    vol.Required(ATTR_OPTIONS): dict,
-    vol.Required(ATTR_SCHEMA): {
-        vol.Coerce(str): vol.Any(ADDON_ELEMENT, [
-            vol.Any(ADDON_ELEMENT, {vol.Coerce(str): ADDON_ELEMENT})
-        ])
+SCHEMA_ADDON_CONFIG = vol.Schema(
+    {
+        vol.Required(ATTR_NAME): vol.Coerce(str),
+        vol.Required(ATTR_VERSION): vol.Coerce(str),
+        vol.Required(ATTR_SLUG): vol.Coerce(str),
+        vol.Required(ATTR_DESCRIPTON): vol.Coerce(str),
+        vol.Required(ATTR_ARCH): [vol.In(ARCH_ALL)],
+        vol.Optional(ATTR_MACHINE): [vol.In(MACHINE_ALL)],
+        vol.Optional(ATTR_URL): vol.Url(),
+        vol.Required(ATTR_STARTUP): vol.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})$")],
+        vol.Optional(ATTR_AUTO_UART, default=False): vol.Boolean(),
+        vol.Optional(ATTR_UDEV, default=False): vol.Boolean(),
+        vol.Optional(ATTR_TMPFS): vol.Match(r"^size=(\d)*[kmg](,uid=\d{1,4})?(,rw)?$"),
+        vol.Optional(ATTR_MAP, default=list): [vol.Match(RE_VOLUME)],
+        vol.Optional(ATTR_ENVIRONMENT): {vol.Match(r"\w*"): vol.Coerce(str)},
+        vol.Optional(ATTR_PRIVILEGED): [vol.In(PRIVILEGED_ALL)],
+        vol.Optional(ATTR_APPARMOR, default=True): vol.Boolean(),
+        vol.Optional(ATTR_FULL_ACCESS, default=False): vol.Boolean(),
+        vol.Optional(ATTR_AUDIO, default=False): vol.Boolean(),
+        vol.Optional(ATTR_GPIO, default=False): vol.Boolean(),
+        vol.Optional(ATTR_DEVICETREE, default=False): vol.Boolean(),
+        vol.Optional(ATTR_KERNEL_MODULES, default=False): vol.Boolean(),
+        vol.Optional(ATTR_HASSIO_API, default=False): vol.Boolean(),
+        vol.Optional(ATTR_HASSIO_ROLE, default=ROLE_DEFAULT): vol.In(ROLE_ALL),
+        vol.Optional(ATTR_HOMEASSISTANT_API, default=False): vol.Boolean(),
+        vol.Optional(ATTR_STDIN, default=False): vol.Boolean(),
+        vol.Optional(ATTR_LEGACY, default=False): vol.Boolean(),
+        vol.Optional(ATTR_DOCKER_API, default=False): vol.Boolean(),
+        vol.Optional(ATTR_AUTH_API, default=False): vol.Boolean(),
+        vol.Optional(ATTR_SERVICES): [vol.Match(RE_SERVICE)],
+        vol.Optional(ATTR_DISCOVERY): [valid_discovery_service],
+        vol.Required(ATTR_OPTIONS): dict,
+        vol.Required(ATTR_SCHEMA): vol.Any(
+            vol.Schema(
+                {
+                    vol.Coerce(str): vol.Any(
+                        SCHEMA_ELEMENT,
+                        [
+                            vol.Any(
+                                SCHEMA_ELEMENT,
+                                {
+                                    vol.Coerce(str): vol.Any(
+                                        SCHEMA_ELEMENT, [SCHEMA_ELEMENT]
+                                    )
+                                },
+                            )
+                        ],
+                        vol.Schema(
+                            {vol.Coerce(str): vol.Any(SCHEMA_ELEMENT, [SCHEMA_ELEMENT])}
+                        ),
+                    )
+                }
+            ),
+            False,
+        ),
+        vol.Optional(ATTR_IMAGE): vol.Match(RE_DOCKER_IMAGE),
+        vol.Optional(ATTR_TIMEOUT, default=10): vol.All(
+            vol.Coerce(int), vol.Range(min=10, max=120)
+        ),
     },
-    vol.Optional(ATTR_IMAGE): vol.Match(r"\w*/\w*"),
-}, extra=vol.ALLOW_EXTRA)
+    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.ALLOW_EXTRA)
+SCHEMA_BUILD_CONFIG = vol.Schema(
+    {
+        vol.Optional(ATTR_BUILD_FROM, default=dict): vol.Schema(
+            {vol.In(ARCH_ALL): vol.Match(RE_DOCKER_IMAGE_BUILD)}
+        ),
+        vol.Optional(ATTR_SQUASH, default=False): vol.Boolean(),
+        vol.Optional(ATTR_ARGS, default=dict): vol.Schema(
+            {vol.Coerce(str): vol.Coerce(str)}
+        ),
+    },
+    extra=vol.REMOVE_EXTRA,
+)
+
+
+# pylint: disable=no-value-for-parameter
+SCHEMA_ADDON_USER = vol.Schema(
+    {
+        vol.Required(ATTR_VERSION): vol.Coerce(str),
+        vol.Optional(ATTR_IMAGE): vol.Coerce(str),
+        vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex): UUID_MATCH,
+        vol.Optional(ATTR_ACCESS_TOKEN): TOKEN,
+        vol.Optional(ATTR_INGRESS_TOKEN, default=secrets.token_urlsafe): vol.Coerce(
+            str
+        ),
+        vol.Optional(ATTR_OPTIONS, default=dict): dict,
+        vol.Optional(ATTR_AUTO_UPDATE, default=False): vol.Boolean(),
+        vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL]),
+        vol.Optional(ATTR_NETWORK): DOCKER_PORTS,
+        vol.Optional(ATTR_AUDIO_OUTPUT): ALSA_DEVICE,
+        vol.Optional(ATTR_AUDIO_INPUT): ALSA_DEVICE,
+        vol.Optional(ATTR_PROTECTED, default=True): vol.Boolean(),
+        vol.Optional(ATTR_INGRESS_PANEL, default=False): vol.Boolean(),
+    },
+    extra=vol.REMOVE_EXTRA,
+)
+
+
+SCHEMA_ADDON_SYSTEM = SCHEMA_ADDON_CONFIG.extend(
+    {
+        vol.Required(ATTR_LOCATON): vol.Coerce(str),
+        vol.Required(ATTR_REPOSITORY): vol.Coerce(str),
+    }
+)
+
+
+SCHEMA_ADDONS_FILE = vol.Schema(
+    {
+        vol.Optional(ATTR_USER, default=dict): {vol.Coerce(str): SCHEMA_ADDON_USER},
+        vol.Optional(ATTR_SYSTEM, default=dict): {vol.Coerce(str): SCHEMA_ADDON_SYSTEM},
+    }
+)
+
+
+SCHEMA_ADDON_SNAPSHOT = vol.Schema(
+    {
+        vol.Required(ATTR_USER): SCHEMA_ADDON_USER,
+        vol.Required(ATTR_SYSTEM): SCHEMA_ADDON_SYSTEM,
+        vol.Required(ATTR_STATE): vol.In([STATE_STARTED, STATE_STOPPED]),
+        vol.Required(ATTR_VERSION): vol.Coerce(str),
+    },
+    extra=vol.REMOVE_EXTRA,
+)
 
 
 def validate_options(raw_schema):
     """Validate schema."""
+
     def validate(struct):
-        """Create schema validator for addons options."""
+        """Create schema validator for add-ons options."""
         options = {}
 
         # read options
         for key, value in struct.items():
+            # Ignore unknown options / remove from list
             if key not in raw_schema:
-                raise vol.Invalid("Unknown options {}.".format(key))
+                _LOGGER.warning("Unknown options %s", key)
+                continue
 
             typ = raw_schema[key]
             try:
                 if isinstance(typ, list):
-                    # nested value
-                    options[key] = _nested_validate(typ[0], value)
+                    # nested value list
+                    options[key] = _nested_validate_list(typ[0], value, key)
+                elif isinstance(typ, dict):
+                    # nested value dict
+                    options[key] = _nested_validate_dict(typ, value, key)
                 else:
                     # normal value
-                    options[key] = _single_validate(typ, value)
+                    options[key] = _single_validate(typ, value, key)
             except (IndexError, KeyError):
-                raise vol.Invalid(
-                    "Type error for {}.".format(key)) from None
+                raise vol.Invalid(f"Type error for {key}") from None
 
+        _check_missing_options(raw_schema, options, "root")
         return options
 
     return validate
 
 
 # pylint: disable=no-value-for-parameter
-def _single_validate(typ, value):
+# pylint: disable=inconsistent-return-statements
+def _single_validate(typ, value, key):
     """Validate a single element."""
-    try:
-        # if required argument
-        if value is None:
-            raise vol.Invalid("A required argument is not set!")
+    # if required argument
+    if value is None:
+        raise vol.Invalid(f"Missing required option '{key}'")
 
-        if typ == V_STR:
-            return str(value)
-        elif typ == V_INT:
-            return int(value)
-        elif typ == V_FLOAT:
-            return float(value)
-        elif typ == V_BOOL:
-            return vol.Boolean()(value)
-        elif typ == V_EMAIL:
-            return vol.Email()(value)
-        elif typ == V_URL:
-            return vol.Url()(value)
+    # parse extend data from type
+    match = RE_SCHEMA_ELEMENT.match(typ)
 
-        raise vol.Invalid("Fatal error for {}.".format(value))
-    except ValueError:
-        raise vol.Invalid(
-            "Type {} error for {}.".format(typ, value)) from None
+    # prepare range
+    range_args = {}
+    for group_name in ("i_min", "i_max", "f_min", "f_max"):
+        group_value = match.group(group_name)
+        if group_value:
+            range_args[group_name[2:]] = float(group_value)
+
+    if typ.startswith(V_STR):
+        return str(value)
+    elif typ.startswith(V_INT):
+        return vol.All(vol.Coerce(int), vol.Range(**range_args))(value)
+    elif typ.startswith(V_FLOAT):
+        return vol.All(vol.Coerce(float), vol.Range(**range_args))(value)
+    elif typ.startswith(V_BOOL):
+        return vol.Boolean()(value)
+    elif typ.startswith(V_EMAIL):
+        return vol.Email()(value)
+    elif typ.startswith(V_URL):
+        return vol.Url()(value)
+    elif typ.startswith(V_PORT):
+        return NETWORK_PORT(value)
+    elif typ.startswith(V_MATCH):
+        return vol.Match(match.group("match"))(str(value))
+
+    raise vol.Invalid(f"Fatal error for {key} type {typ}")
 
 
-def _nested_validate(typ, data_list):
+def _nested_validate_list(typ, data_list, key):
     """Validate nested items."""
     options = []
 
     for element in data_list:
-        # dict list
+        # Nested?
         if isinstance(typ, dict):
-            c_options = {}
-            for c_key, c_value in element.items():
-                if c_key not in typ:
-                    raise vol.Invalid(
-                        "Unknown nested options {}.".format(c_key))
-
-                c_options[c_key] = _single_validate(typ[c_key], c_value)
+            c_options = _nested_validate_dict(typ, element, key)
             options.append(c_options)
-        # normal list
         else:
-            options.append(_single_validate(typ, element))
+            options.append(_single_validate(typ, element, key))
 
     return options
+
+
+def _nested_validate_dict(typ, data_dict, key):
+    """Validate nested items."""
+    options = {}
+
+    for c_key, c_value in data_dict.items():
+        # Ignore unknown options / remove from list
+        if c_key not in typ:
+            _LOGGER.warning("Unknown options %s", c_key)
+            continue
+
+        # Nested?
+        if isinstance(typ[c_key], list):
+            options[c_key] = _nested_validate_list(typ[c_key][0], c_value, c_key)
+        else:
+            options[c_key] = _single_validate(typ[c_key], c_value, c_key)
+
+    _check_missing_options(typ, options, key)
+    return options
+
+
+def _check_missing_options(origin, exists, root):
+    """Check if all options are exists."""
+    missing = set(origin) - set(exists)
+    for miss_opt in missing:
+        if isinstance(origin[miss_opt], str) and origin[miss_opt].endswith("?"):
+            continue
+        raise vol.Invalid(f"Missing option {miss_opt} in {root}")

hassio/api/__init__.py

@@ -1,109 +1,312 @@
-"""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 .dns import APICoreDNS
+from .hardware import APIHardware
+from .hassos import APIHassOS
 from .homeassistant import APIHomeAssistant
 from .host import APIHost
-from .network import APINetwork
+from .info import APIInfo
+from .ingress import APIIngress
+from .proxy import APIProxy
+from .security import SecurityMiddleware
+from .services import APIServices
+from .snapshots import APISnapshots
 from .supervisor import APISupervisor
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class RestAPI(object):
-    """Handle rest api for hassio."""
+class RestAPI(CoreSysAttributes):
+    """Handle RESTful API for Hass.io."""
 
-    def __init__(self, config, loop):
-        """Initialize docker base wrapper."""
-        self.config = config
-        self.loop = loop
-        self.webapp = web.Application(loop=self.loop)
+    def __init__(self, coresys: CoreSys):
+        """Initialize Docker base wrapper."""
+        self.coresys: CoreSys = coresys
+        self.security: SecurityMiddleware = SecurityMiddleware(coresys)
+        self.webapp: web.Application = web.Application(
+            middlewares=[self.security.token_validation]
+        )
 
         # service stuff
-        self._handler = None
-        self.server = None
+        self._runner: web.AppRunner = web.AppRunner(self.webapp)
+        self._site: Optional[web.TCPSite] = None
 
-    def register_host(self, host_control):
-        """Register hostcontrol function."""
-        api_host = APIHost(self.config, self.loop, host_control)
+    async def load(self) -> None:
+        """Register REST API Calls."""
+        self._register_supervisor()
+        self._register_host()
+        self._register_hassos()
+        self._register_hardware()
+        self._register_homeassistant()
+        self._register_proxy()
+        self._register_panel()
+        self._register_addons()
+        self._register_ingress()
+        self._register_snapshots()
+        self._register_discovery()
+        self._register_services()
+        self._register_info()
+        self._register_auth()
+        self._register_dns()
 
-        self.webapp.router.add_get('/host/info', api_host.info)
-        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)
+    def _register_host(self) -> None:
+        """Register hostcontrol functions."""
+        api_host = APIHost()
+        api_host.coresys = self.coresys
 
-    def register_network(self, host_control):
-        """Register network function."""
-        api_net = APINetwork(self.config, self.loop, host_control)
+        self.webapp.add_routes(
+            [
+                web.get("/host/info", api_host.info),
+                web.post("/host/reboot", api_host.reboot),
+                web.post("/host/shutdown", api_host.shutdown),
+                web.post("/host/reload", api_host.reload),
+                web.post("/host/options", api_host.options),
+                web.get("/host/services", api_host.services),
+                web.post("/host/services/{service}/stop", api_host.service_stop),
+                web.post("/host/services/{service}/start", api_host.service_start),
+                web.post("/host/services/{service}/restart", api_host.service_restart),
+                web.post("/host/services/{service}/reload", api_host.service_reload),
+            ]
+        )
 
-        self.webapp.router.add_get('/network/info', api_net.info)
-        self.webapp.router.add_post('/network/options', api_net.options)
+    def _register_hassos(self) -> None:
+        """Register HassOS functions."""
+        api_hassos = APIHassOS()
+        api_hassos.coresys = self.coresys
 
-    def register_supervisor(self, supervisor, addons, host_control):
-        """Register supervisor function."""
-        api_supervisor = APISupervisor(
-            self.config, self.loop, supervisor, addons, host_control)
+        self.webapp.add_routes(
+            [
+                web.get("/hassos/info", api_hassos.info),
+                web.post("/hassos/update", api_hassos.update),
+                web.post("/hassos/update/cli", api_hassos.update_cli),
+                web.post("/hassos/config/sync", api_hassos.config_sync),
+            ]
+        )
 
-        self.webapp.router.add_get('/supervisor/ping', api_supervisor.ping)
-        self.webapp.router.add_get('/supervisor/info', api_supervisor.info)
-        self.webapp.router.add_get(
-            '/supervisor/addons', api_supervisor.available_addons)
-        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)
+    def _register_hardware(self) -> None:
+        """Register hardware functions."""
+        api_hardware = APIHardware()
+        api_hardware.coresys = self.coresys
 
-    def register_homeassistant(self, dock_homeassistant):
-        """Register homeassistant function."""
-        api_hass = APIHomeAssistant(self.config, self.loop, dock_homeassistant)
+        self.webapp.add_routes(
+            [
+                web.get("/hardware/info", api_hardware.info),
+                web.get("/hardware/audio", api_hardware.audio),
+            ]
+        )
 
-        self.webapp.router.add_get('/homeassistant/info', api_hass.info)
-        self.webapp.router.add_post('/homeassistant/update', api_hass.update)
-        self.webapp.router.add_post('/homeassistant/restart', api_hass.restart)
-        self.webapp.router.add_get('/homeassistant/logs', api_hass.logs)
+    def _register_info(self) -> None:
+        """Register info functions."""
+        api_info = APIInfo()
+        api_info.coresys = self.coresys
 
-    def register_addons(self, addons):
-        """Register homeassistant function."""
-        api_addons = APIAddons(self.config, self.loop, addons)
+        self.webapp.add_routes([web.get("/info", api_info.info)])
 
-        self.webapp.router.add_get('/addons/{addon}/info', api_addons.info)
-        self.webapp.router.add_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_get('/addons/{addon}/logs', api_addons.logs)
+    def _register_auth(self) -> None:
+        """Register auth functions."""
+        api_auth = APIAuth()
+        api_auth.coresys = self.coresys
 
-    async def start(self):
-        """Run rest api webserver."""
-        self._handler = self.webapp.make_handler(loop=self.loop)
+        self.webapp.add_routes([web.post("/auth", api_auth.auth)])
+
+    def _register_supervisor(self) -> None:
+        """Register Supervisor functions."""
+        api_supervisor = APISupervisor()
+        api_supervisor.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/supervisor/ping", api_supervisor.ping),
+                web.get("/supervisor/info", api_supervisor.info),
+                web.get("/supervisor/stats", api_supervisor.stats),
+                web.get("/supervisor/logs", api_supervisor.logs),
+                web.post("/supervisor/update", api_supervisor.update),
+                web.post("/supervisor/reload", api_supervisor.reload),
+                web.post("/supervisor/options", api_supervisor.options),
+                web.post("/supervisor/repair", api_supervisor.repair),
+            ]
+        )
+
+    def _register_homeassistant(self) -> None:
+        """Register Home Assistant functions."""
+        api_hass = APIHomeAssistant()
+        api_hass.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/homeassistant/info", api_hass.info),
+                web.get("/homeassistant/logs", api_hass.logs),
+                web.get("/homeassistant/stats", api_hass.stats),
+                web.post("/homeassistant/options", api_hass.options),
+                web.post("/homeassistant/update", api_hass.update),
+                web.post("/homeassistant/restart", api_hass.restart),
+                web.post("/homeassistant/stop", api_hass.stop),
+                web.post("/homeassistant/start", api_hass.start),
+                web.post("/homeassistant/check", api_hass.check),
+                web.post("/homeassistant/rebuild", api_hass.rebuild),
+            ]
+        )
+
+    def _register_proxy(self) -> None:
+        """Register Home Assistant API Proxy."""
+        api_proxy = APIProxy()
+        api_proxy.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/homeassistant/api/websocket", api_proxy.websocket),
+                web.get("/homeassistant/websocket", api_proxy.websocket),
+                web.get("/homeassistant/api/stream", api_proxy.stream),
+                web.post("/homeassistant/api/{path:.+}", api_proxy.api),
+                web.get("/homeassistant/api/{path:.+}", api_proxy.api),
+                web.get("/homeassistant/api/", api_proxy.api),
+            ]
+        )
+
+    def _register_addons(self) -> None:
+        """Register Add-on functions."""
+        api_addons = APIAddons()
+        api_addons.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/addons", api_addons.list),
+                web.post("/addons/reload", api_addons.reload),
+                web.get("/addons/{addon}/info", api_addons.info),
+                web.post("/addons/{addon}/install", api_addons.install),
+                web.post("/addons/{addon}/uninstall", api_addons.uninstall),
+                web.post("/addons/{addon}/start", api_addons.start),
+                web.post("/addons/{addon}/stop", api_addons.stop),
+                web.post("/addons/{addon}/restart", api_addons.restart),
+                web.post("/addons/{addon}/update", api_addons.update),
+                web.post("/addons/{addon}/options", api_addons.options),
+                web.post("/addons/{addon}/rebuild", api_addons.rebuild),
+                web.get("/addons/{addon}/logs", api_addons.logs),
+                web.get("/addons/{addon}/icon", api_addons.icon),
+                web.get("/addons/{addon}/logo", api_addons.logo),
+                web.get("/addons/{addon}/changelog", api_addons.changelog),
+                web.post("/addons/{addon}/stdin", api_addons.stdin),
+                web.post("/addons/{addon}/security", api_addons.security),
+                web.get("/addons/{addon}/stats", api_addons.stats),
+            ]
+        )
+
+    def _register_ingress(self) -> None:
+        """Register Ingress functions."""
+        api_ingress = APIIngress()
+        api_ingress.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.post("/ingress/session", api_ingress.create_session),
+                web.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.add_routes(
+            [
+                web.get("/snapshots", api_snapshots.list),
+                web.post("/snapshots/reload", api_snapshots.reload),
+                web.post("/snapshots/new/full", api_snapshots.snapshot_full),
+                web.post("/snapshots/new/partial", api_snapshots.snapshot_partial),
+                web.post("/snapshots/new/upload", api_snapshots.upload),
+                web.get("/snapshots/{snapshot}/info", api_snapshots.info),
+                web.post("/snapshots/{snapshot}/remove", api_snapshots.remove),
+                web.post(
+                    "/snapshots/{snapshot}/restore/full", api_snapshots.restore_full
+                ),
+                web.post(
+                    "/snapshots/{snapshot}/restore/partial",
+                    api_snapshots.restore_partial,
+                ),
+                web.get("/snapshots/{snapshot}/download", api_snapshots.download),
+            ]
+        )
+
+    def _register_services(self) -> None:
+        """Register services functions."""
+        api_services = APIServices()
+        api_services.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/services", api_services.list),
+                web.get("/services/{service}", api_services.get_service),
+                web.post("/services/{service}", api_services.set_service),
+                web.delete("/services/{service}", api_services.del_service),
+            ]
+        )
+
+    def _register_discovery(self) -> None:
+        """Register discovery functions."""
+        api_discovery = APIDiscovery()
+        api_discovery.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/discovery", api_discovery.list),
+                web.get("/discovery/{uuid}", api_discovery.get_discovery),
+                web.delete("/discovery/{uuid}", api_discovery.del_discovery),
+                web.post("/discovery", api_discovery.set_discovery),
+            ]
+        )
+
+    def _register_dns(self) -> None:
+        """Register DNS functions."""
+        api_dns = APICoreDNS()
+        api_dns.coresys = self.coresys
+
+        self.webapp.add_routes(
+            [
+                web.get("/dns/info", api_dns.info),
+                web.get("/dns/stats", api_dns.stats),
+                web.get("/dns/logs", api_dns.logs),
+                web.post("/dns/update", api_dns.update),
+                web.post("/dns/options", api_dns.options),
+            ]
+        )
+
+    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)])
+
+    async def start(self) -> None:
+        """Run RESTful API webserver."""
+        await self._runner.setup()
+        self._site = web.TCPSite(
+            self._runner, host="0.0.0.0", port=80, shutdown_timeout=5
+        )
 
         try:
-            self.server = await self.loop.create_server(
-                self._handler, "0.0.0.0", "80")
+            await self._site.start()
         except OSError as err:
-            _LOGGER.fatal(
-                "Failed to create HTTP server at 0.0.0.0:80 -> %s", err)
+            _LOGGER.fatal("Failed to create HTTP server at 0.0.0.0:80 -> %s", err)
+        else:
+            _LOGGER.info("Start API on %s", self.sys_docker.network.supervisor)
 
-    async def stop(self):
-        """Stop rest api webserver."""
-        if self.server:
-            self.server.close()
-            await self.server.wait_closed()
-        await self.webapp.shutdown()
+    async def stop(self) -> None:
+        """Stop RESTful API webserver."""
+        if not self._site:
+            return
 
-        if self._handler:
-            await self._handler.finish_connections(60)
-        await self.webapp.cleanup()
+        # Shutdown running API
+        await self._site.stop()
+        await self._runner.cleanup()
+
+        _LOGGER.info("Stop API on %s", self.sys_docker.network.supervisor)

hassio/api/addons.py

@@ -1,161 +1,438 @@
-"""Init file for HassIO homeassistant rest api."""
+"""Init file for Hass.io Home Assistant RESTful API."""
 import asyncio
 import logging
+from typing import Any, Awaitable, Dict, List
 
+from aiohttp import web
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
-from .util import api_process, api_process_raw, api_validate
+from ..addons import AnyAddon
+from ..docker.stats import DockerStats
+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,
-    STATE_STOPPED, STATE_STARTED, BOOT_AUTO, BOOT_MANUAL)
+    ATTR_ADDONS,
+    ATTR_APPARMOR,
+    ATTR_ARCH,
+    ATTR_AUDIO,
+    ATTR_AUDIO_INPUT,
+    ATTR_AUDIO_OUTPUT,
+    ATTR_AUTH_API,
+    ATTR_AUTO_UPDATE,
+    ATTR_AVAILABLE,
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_BOOT,
+    ATTR_BUILD,
+    ATTR_CHANGELOG,
+    ATTR_CPU_PERCENT,
+    ATTR_DESCRIPTON,
+    ATTR_DETACHED,
+    ATTR_DEVICES,
+    ATTR_DEVICETREE,
+    ATTR_DISCOVERY,
+    ATTR_DNS,
+    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_HOSTNAME,
+    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_PERCENT,
+    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_UDEV,
+    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 ..exceptions import APIError
+from ..validate import ALSA_DEVICE, DOCKER_PORTS
+from .utils import api_process, api_process_raw, api_validate
 
 _LOGGER = logging.getLogger(__name__)
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
-})
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
 
-SCHEMA_OPTIONS = vol.Schema({
-    vol.Optional(ATTR_BOOT): vol.In([BOOT_AUTO, BOOT_MANUAL])
-})
+# pylint: disable=no-value-for-parameter
+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(object):
-    """Handle rest api for addons functions."""
+class APIAddons(CoreSysAttributes):
+    """Handle RESTful API for add-on functions."""
 
-    def __init__(self, config, loop, addons):
-        """Initialize homeassistant rest api part."""
-        self.config = config
-        self.loop = loop
-        self.addons = addons
+    def _extract_addon(
+        self, request: web.Request, check_installed: bool = True
+    ) -> AnyAddon:
+        """Return addon, throw an exception it it doesn't exist."""
+        addon_slug: str = request.match_info.get("addon")
 
-    def _extract_addon(self, request, check_installed=True):
-        """Return addon and if not exists trow a exception."""
-        addon = request.match_info.get('addon')
+        # Lookup itself
+        if addon_slug == "self":
+            return request.get(REQUEST_FROM)
 
-        # check data
-        if not self.addons.exists_addon(addon):
-            raise RuntimeError("Addon not exists")
-        if check_installed and not self.addons.is_installed(addon):
-            raise RuntimeError("Addon is not installed")
+        addon = self.sys_addons.get(addon_slug)
+        if not addon:
+            raise APIError("Addon does not exist")
+
+        if check_installed and not addon.is_installed:
+            raise APIError("Addon is not installed")
 
         return addon
 
     @api_process
-    async def info(self, request):
-        """Return addon information."""
-        addon = self._extract_addon(request)
+    async def list(self, request: web.Request) -> Dict[str, Any]:
+        """Return all add-ons or repositories."""
+        data_addons = []
+        for addon in self.sys_addons.all:
+            data_addons.append(
+                {
+                    ATTR_NAME: addon.name,
+                    ATTR_SLUG: addon.slug,
+                    ATTR_DESCRIPTON: addon.description,
+                    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,
+                    ATTR_URL: addon.url,
+                    ATTR_ICON: addon.with_icon,
+                    ATTR_LOGO: addon.with_logo,
+                }
+            )
+
+        data_repositories = []
+        for repository in self.sys_store.all:
+            data_repositories.append(
+                {
+                    ATTR_SLUG: repository.slug,
+                    ATTR_NAME: repository.name,
+                    ATTR_SOURCE: repository.source,
+                    ATTR_URL: repository.url,
+                    ATTR_MAINTAINER: repository.maintainer,
+                }
+            )
+
+        return {ATTR_ADDONS: data_addons, ATTR_REPOSITORIES: data_repositories}
+
+    @api_process
+    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: web.Request) -> Dict[str, Any]:
+        """Return add-on information."""
+        addon: AnyAddon = self._extract_addon(request, check_installed=False)
+
+        data = {
+            ATTR_NAME: addon.name,
+            ATTR_SLUG: addon.slug,
+            ATTR_HOSTNAME: addon.hostname,
+            ATTR_DNS: addon.dns,
+            ATTR_DESCRIPTON: addon.description,
+            ATTR_LONG_DESCRIPTION: addon.long_description,
+            ATTR_AUTO_UPDATE: None,
+            ATTR_REPOSITORY: addon.repository,
+            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_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_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_UDEV: addon.with_udev,
+            ATTR_DOCKER_API: addon.access_docker_api,
+            ATTR_AUDIO: addon.with_audio,
+            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: web.Request) -> None:
+        """Store user options for add-on."""
+        addon: AnyAddon = self._extract_addon(request)
+
+        addon_schema = SCHEMA_OPTIONS.extend(
+            {vol.Optional(ATTR_OPTIONS): vol.Any(None, addon.schema)}
+        )
+        body: Dict[str, Any] = await api_validate(addon_schema, request)
+
+        if ATTR_OPTIONS in body:
+            addon.options = body[ATTR_OPTIONS]
+        if ATTR_BOOT in body:
+            addon.boot = body[ATTR_BOOT]
+        if ATTR_AUTO_UPDATE in body:
+            addon.auto_update = body[ATTR_AUTO_UPDATE]
+        if ATTR_NETWORK in body:
+            addon.ports = body[ATTR_NETWORK]
+        if ATTR_AUDIO_INPUT in body:
+            addon.audio_input = body[ATTR_AUDIO_INPUT]
+        if ATTR_AUDIO_OUTPUT in body:
+            addon.audio_output = body[ATTR_AUDIO_OUTPUT]
+        if ATTR_INGRESS_PANEL in body:
+            addon.ingress_panel = body[ATTR_INGRESS_PANEL]
+            await self.sys_ingress.update_hass_panel(addon)
+
+        addon.save_persist()
+
+    @api_process
+    async def security(self, request: web.Request) -> None:
+        """Store security options for add-on."""
+        addon: AnyAddon = self._extract_addon(request)
+        body: Dict[str, Any] = 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_persist()
+
+    @api_process
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
+        """Return resource information."""
+        addon: AnyAddon = self._extract_addon(request)
+        stats: DockerStats = await addon.stats()
 
         return {
-            ATTR_NAME: self.addons.get_name(addon),
-            ATTR_DESCRIPTON: self.addons.get_description(addon),
-            ATTR_VERSION: self.addons.version_installed(addon),
-            ATTR_REPOSITORY: self.addons.get_repository(addon),
-            ATTR_LAST_VERSION: self.addons.get_last_version(addon),
-            ATTR_STATE: await self.addons.state(addon),
-            ATTR_BOOT: self.addons.get_boot(addon),
-            ATTR_OPTIONS: self.addons.get_options(addon),
-            ATTR_URL: self.addons.get_url(addon),
-            ATTR_DETACHED: addon in self.addons.list_detached,
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_MEMORY_PERCENT: stats.memory_percent,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
         }
 
     @api_process
-    async def options(self, request):
-        """Store user options for addon."""
-        addon = self._extract_addon(request)
-        options_schema = self.addons.get_schema(addon)
-
-        addon_schema = SCHEMA_OPTIONS.extend({
-            vol.Optional(ATTR_OPTIONS): options_schema,
-        })
-
-        body = await api_validate(addon_schema, request)
-
-        if ATTR_OPTIONS in body:
-            self.addons.set_options(addon, body[ATTR_OPTIONS])
-        if ATTR_BOOT in body:
-            self.addons.set_boot(addon, body[ATTR_BOOT])
-
-        return True
+    def install(self, request: web.Request) -> Awaitable[None]:
+        """Install add-on."""
+        addon: AnyAddon = self._extract_addon(request, check_installed=False)
+        return asyncio.shield(addon.install())
 
     @api_process
-    async def install(self, request):
-        """Install addon."""
-        body = await api_validate(SCHEMA_VERSION, request)
-        addon = self._extract_addon(request, check_installed=False)
-        version = body.get(
-            ATTR_VERSION, self.addons.get_last_version(addon))
-
-        # check if arch supported
-        if self.addons.arch not in self.addons.get_arch(addon):
-            raise RuntimeError(
-                "Addon is not supported on {}".format(self.addons.arch))
-
-        return await asyncio.shield(
-            self.addons.install(addon, version), loop=self.loop)
+    def uninstall(self, request: web.Request) -> Awaitable[None]:
+        """Uninstall add-on."""
+        addon: AnyAddon = self._extract_addon(request)
+        return asyncio.shield(addon.uninstall())
 
     @api_process
-    async def uninstall(self, request):
-        """Uninstall addon."""
-        addon = self._extract_addon(request)
+    def start(self, request: web.Request) -> Awaitable[None]:
+        """Start add-on."""
+        addon: AnyAddon = self._extract_addon(request)
 
-        return await asyncio.shield(
-            self.addons.uninstall(addon), loop=self.loop)
-
-    @api_process
-    async def start(self, request):
-        """Start addon."""
-        addon = self._extract_addon(request)
-
-        if await self.addons.state(addon) == STATE_STARTED:
-            raise RuntimeError("Addon is already running")
-
-        # validate options
+        # check options
+        options = addon.options
         try:
-            schema = self.addons.get_schema(addon)
-            options = self.addons.get_options(addon)
-            schema(options)
+            addon.schema(options)
         except vol.Invalid as ex:
-            raise RuntimeError(humanize_error(options, ex)) from None
+            raise APIError(humanize_error(options, ex)) from None
 
-        return await asyncio.shield(
-            self.addons.start(addon), loop=self.loop)
+        return asyncio.shield(addon.start())
 
     @api_process
-    async def stop(self, request):
-        """Stop addon."""
-        addon = self._extract_addon(request)
-
-        if await self.addons.state(addon) == STATE_STOPPED:
-            raise RuntimeError("Addon is already stoped")
-
-        return await asyncio.shield(
-            self.addons.stop(addon), loop=self.loop)
+    def stop(self, request: web.Request) -> Awaitable[None]:
+        """Stop add-on."""
+        addon: AnyAddon = self._extract_addon(request)
+        return asyncio.shield(addon.stop())
 
     @api_process
-    async def update(self, request):
-        """Update addon."""
-        body = await api_validate(SCHEMA_VERSION, request)
-        addon = self._extract_addon(request)
-        version = body.get(
-            ATTR_VERSION, self.addons.get_last_version(addon))
+    def update(self, request: web.Request) -> Awaitable[None]:
+        """Update add-on."""
+        addon: AnyAddon = self._extract_addon(request)
 
-        if version == self.addons.version_installed(addon):
-            raise RuntimeError("Version is already in use")
+        if addon.latest_version == addon.version:
+            raise APIError("No update available!")
 
-        return await asyncio.shield(
-            self.addons.update(addon, version), loop=self.loop)
+        return asyncio.shield(addon.update())
 
     @api_process
-    async def restart(self, request):
-        """Restart addon."""
-        addon = self._extract_addon(request)
-        return await asyncio.shield(self.addons.restart(addon), loop=self.loop)
+    def restart(self, request: web.Request) -> Awaitable[None]:
+        """Restart add-on."""
+        addon: AnyAddon = self._extract_addon(request)
+        return asyncio.shield(addon.restart())
 
-    @api_process_raw
-    def logs(self, request):
-        """Return logs from addon."""
-        addon = self._extract_addon(request)
-        return self.addons.logs(addon)
+    @api_process
+    def rebuild(self, request: web.Request) -> Awaitable[None]:
+        """Rebuild local build add-on."""
+        addon: AnyAddon = self._extract_addon(request)
+        if not addon.need_build:
+            raise APIError("Only local build addons are supported")
+
+        return asyncio.shield(addon.rebuild())
+
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return logs from add-on."""
+        addon: AnyAddon = self._extract_addon(request)
+        return addon.logs()
+
+    @api_process_raw(CONTENT_TYPE_PNG)
+    async def icon(self, request: web.Request) -> bytes:
+        """Return icon from add-on."""
+        addon: AnyAddon = self._extract_addon(request, check_installed=False)
+        if not addon.with_icon:
+            raise APIError("No icon found!")
+
+        with addon.path_icon.open("rb") as png:
+            return png.read()
+
+    @api_process_raw(CONTENT_TYPE_PNG)
+    async def logo(self, request: web.Request) -> bytes:
+        """Return logo from add-on."""
+        addon: AnyAddon = self._extract_addon(request, check_installed=False)
+        if not addon.with_logo:
+            raise APIError("No logo found!")
+
+        with addon.path_logo.open("rb") as png:
+            return png.read()
+
+    @api_process_raw(CONTENT_TYPE_TEXT)
+    async def changelog(self, request: web.Request) -> str:
+        """Return changelog from add-on."""
+        addon: AnyAddon = self._extract_addon(request, check_installed=False)
+        if not addon.with_changelog:
+            raise APIError("No changelog found!")
+
+        with addon.path_changelog.open("r") as changelog:
+            return changelog.read()
+
+    @api_process
+    async def stdin(self, request: web.Request) -> None:
+        """Write to stdin of add-on."""
+        addon: AnyAddon = self._extract_addon(request)
+        if not addon.with_stdin:
+            raise APIError("STDIN not supported by add-on")
+
+        data = await request.read()
+        await asyncio.shield(addon.write_stdin(data))
+
+
+def _pretty_devices(addon: 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

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

hassio/api/dns.py

@@ -0,0 +1,89 @@
+"""Init file for Hass.io DNS RESTful API."""
+import asyncio
+import logging
+from typing import Any, Awaitable, Dict
+
+from aiohttp import web
+import voluptuous as vol
+
+from ..const import (
+    ATTR_BLK_READ,
+    ATTR_BLK_WRITE,
+    ATTR_CPU_PERCENT,
+    ATTR_HOST,
+    ATTR_LATEST_VERSION,
+    ATTR_MEMORY_LIMIT,
+    ATTR_MEMORY_USAGE,
+    ATTR_MEMORY_PERCENT,
+    ATTR_NETWORK_RX,
+    ATTR_NETWORK_TX,
+    ATTR_SERVERS,
+    ATTR_VERSION,
+    CONTENT_TYPE_BINARY,
+)
+from ..coresys import CoreSysAttributes
+from ..exceptions import APIError
+from ..validate import DNS_SERVER_LIST
+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_SERVERS): DNS_SERVER_LIST})
+
+SCHEMA_VERSION = vol.Schema({vol.Optional(ATTR_VERSION): vol.Coerce(str)})
+
+
+class APICoreDNS(CoreSysAttributes):
+    """Handle RESTful API for DNS functions."""
+
+    @api_process
+    async def info(self, request: web.Request) -> Dict[str, Any]:
+        """Return DNS information."""
+        return {
+            ATTR_VERSION: self.sys_dns.version,
+            ATTR_LATEST_VERSION: self.sys_dns.latest_version,
+            ATTR_HOST: str(self.sys_docker.network.dns),
+            ATTR_SERVERS: self.sys_dns.servers,
+        }
+
+    @api_process
+    async def options(self, request: web.Request) -> None:
+        """Set DNS options."""
+        body = await api_validate(SCHEMA_OPTIONS, request)
+
+        if ATTR_SERVERS in body:
+            self.sys_dns.servers = body[ATTR_SERVERS]
+
+        self.sys_dns.save_data()
+
+    @api_process
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
+        """Return resource information."""
+        stats = await self.sys_dns.stats()
+
+        return {
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_MEMORY_PERCENT: stats.memory_percent,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
+        }
+
+    @api_process
+    async def update(self, request: web.Request) -> None:
+        """Update DNS plugin."""
+        body = await api_validate(SCHEMA_VERSION, request)
+        version = body.get(ATTR_VERSION, self.sys_dns.latest_version)
+
+        if version == self.sys_dns.version:
+            raise APIError("Version {} is already in use".format(version))
+        await asyncio.shield(self.sys_dns.update(version))
+
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return DNS Docker logs."""
+        return self.sys_dns.logs()

hassio/api/hardware.py

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

hassio/api/host.py

@@ -1,60 +1,109 @@
-"""Init file for HassIO host rest api."""
+"""Init file for Hass.io host RESTful API."""
 import asyncio
 import logging
 
 import voluptuous as vol
 
-from .util import api_process_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_HOSTNAME,
+    ATTR_FEATURES,
+    ATTR_KERNEL,
+    ATTR_OPERATING_SYSTEM,
+    ATTR_CHASSIS,
+    ATTR_DEPLOYMENT,
+    ATTR_STATE,
+    ATTR_NAME,
+    ATTR_DESCRIPTON,
+    ATTR_SERVICES,
+    ATTR_CPE,
+)
+from ..coresys import CoreSysAttributes
 
 _LOGGER = logging.getLogger(__name__)
 
-SCHEMA_VERSION = vol.Schema({
-    vol.Optional(ATTR_VERSION): vol.Coerce(str),
-})
+SERVICE = "service"
+
+SCHEMA_OPTIONS = vol.Schema({vol.Optional(ATTR_HOSTNAME): vol.Coerce(str)})
 
 
-class APIHost(object):
-    """Handle rest api for host functions."""
-
-    def __init__(self, config, loop, host_control):
-        """Initialize host rest api part."""
-        self.config = config
-        self.loop = loop
-        self.host_control = host_control
+class APIHost(CoreSysAttributes):
+    """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_hostcontrol
+    @api_process
+    async def options(self, request):
+        """Edit host settings."""
+        body = await api_validate(SCHEMA_OPTIONS, request)
+
+        # hostname
+        if ATTR_HOSTNAME in body:
+            await asyncio.shield(
+                self.sys_host.control.set_hostname(body[ATTR_HOSTNAME])
+            )
+
+    @api_process
     def reboot(self, request):
         """Reboot host."""
-        return self.host_control.reboot()
+        return asyncio.shield(self.sys_host.control.reboot())
 
-    @api_process_hostcontrol
+    @api_process
     def shutdown(self, request):
         """Poweroff host."""
-        return self.host_control.shutdown()
+        return asyncio.shield(self.sys_host.control.shutdown())
 
-    @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)
+    @api_process
+    def reload(self, request):
+        """Reload host data."""
+        return asyncio.shield(self.sys_host.reload())
 
-        if version == self.host_control.version:
-            raise RuntimeError("Version is already in use")
+    @api_process
+    async def services(self, request):
+        """Return list of available services."""
+        services = []
+        for unit in self.sys_host.services:
+            services.append(
+                {
+                    ATTR_NAME: unit.name,
+                    ATTR_DESCRIPTON: unit.description,
+                    ATTR_STATE: unit.state,
+                }
+            )
 
-        return await asyncio.shield(
-            self.host_control.update(version=version), loop=self.loop)
+        return {ATTR_SERVICES: services}
+
+    @api_process
+    def service_start(self, request):
+        """Start a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.start(unit))
+
+    @api_process
+    def service_stop(self, request):
+        """Stop a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.stop(unit))
+
+    @api_process
+    def service_reload(self, request):
+        """Reload a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.reload(unit))
+
+    @api_process
+    def service_restart(self, request):
+        """Restart a service."""
+        unit = request.match_info.get(SERVICE)
+        return asyncio.shield(self.sys_host.services.restart(unit))

hassio/api/info.py

@@ -0,0 +1,42 @@
+"""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,
+    ATTR_TIMEZONE,
+)
+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,
+            ATTR_TIMEZONE: self.sys_timezone,
+        }

hassio/api/ingress.py

@@ -0,0 +1,263 @@
+"""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,
+            allow_redirects=False,
+            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,26 +0,0 @@
-"""Init file for HassIO network rest api."""
-import logging
-
-from .util import api_process_hostcontrol
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class APINetwork(object):
-    """Handle rest api for network functions."""
-
-    def __init__(self, config, loop, host_control):
-        """Initialize network rest api part."""
-        self.config = config
-        self.loop = loop
-        self.host_control = host_control
-
-    @api_process_hostcontrol
-    def info(self, request):
-        """Show network settings."""
-        pass
-
-    @api_process_hostcontrol
-    def options(self, request):
-        """Edit network settings."""
-        pass

hassio/api/panel/chunk.598ae99dfd641ab3a30c.js.LICENSE

@@ -0,0 +1,20 @@
+/**
+@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.5dd33a3a20657ed46a19.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///./src/ingress-view/hassio-ingress-view.ts"],"names":["customElement","HassioIngressView","property","this","_addon","html","_templateObject2","name","ingress_url","_templateObject","changedProps","_get","_getPrototypeOf","prototype","call","has","addon","route","path","substr","oldRoute","get","oldAddon","undefined","_fetchData","_callee","addonSlug","_ref","_ref2","regeneratorRuntime","wrap","_context","prev","next","Promise","all","fetchHassioAddonInfo","hass","catch","Error","createHassioSession","sent","_slicedToArray","ingress","t0","console","error","alert","message","history","back","stop","css","_templateObject3","LitElement"],"mappings":"4gSAmBCA,YAAc,0CACTC,smBACHC,kEACAA,mEACAA,4EAED,WACE,OAAKC,KAAKC,OAMHC,YAAPC,IAC0BH,KAAKC,OAAOG,KACpBJ,KAAKC,OAAOI,aAPrBH,YAAPI,0CAYJ,SAAkBC,GAGhB,GAFAC,EAAAC,EApBEX,EAoBFY,WAAA,eAAAV,MAAAW,KAAAX,KAAmBO,GAEdA,EAAaK,IAAI,SAAtB,CAIA,IAAMC,EAAQb,KAAKc,MAAMC,KAAKC,OAAO,GAE/BC,EAAWV,EAAaW,IAAI,SAC5BC,EAAWF,EAAWA,EAASF,KAAKC,OAAO,QAAKI,EAElDP,GAASA,IAAUM,GACrBnB,KAAKqB,WAAWR,0FAIpB,SAAAS,EAAyBC,GAAzB,IAAAC,EAAAC,EAAAZ,EAAA,OAAAa,mBAAAC,KAAA,SAAAC,GAAA,cAAAA,EAAAC,KAAAD,EAAAE,MAAA,cAAAF,EAAAC,KAAA,EAAAD,EAAAE,KAAA,EAE0BC,QAAQC,IAAI,CAChCC,YAAqBjC,KAAKkC,KAAMX,GAAWY,MAAM,WAC/C,MAAM,IAAIC,MAAM,iCAElBC,YAAoBrC,KAAKkC,MAAMC,MAAM,WACnC,MAAM,IAAIC,MAAM,2CAPxB,UAAAZ,EAAAI,EAAAU,KAAAb,EAAAc,EAAAf,EAAA,IAEWX,EAFXY,EAAA,IAWee,QAXf,CAAAZ,EAAAE,KAAA,cAYY,IAAIM,MAAM,wCAZtB,OAeIpC,KAAKC,OAASY,EAflBe,EAAAE,KAAA,iBAAAF,EAAAC,KAAA,GAAAD,EAAAa,GAAAb,EAAA,SAkBIc,QAAQC,MAARf,EAAAa,IACAG,MAAMhB,EAAAa,GAAII,SAAW,mCACrBC,QAAQC,OApBZ,yBAAAnB,EAAAoB,SAAA1B,EAAAtB,KAAA,yRAwBA,WACE,OAAOiD,YAAPC,UA7D4BC","file":"chunk.5dd33a3a20657ed46a19.js","sourcesContent":["import {\n  LitElement,\n  customElement,\n  property,\n  TemplateResult,\n  html,\n  PropertyValues,\n  CSSResult,\n  css,\n} from \"lit-element\";\nimport { HomeAssistant, Route } from \"../../../src/types\";\nimport {\n  createHassioSession,\n  HassioAddonDetails,\n  fetchHassioAddonInfo,\n} from \"../../../src/data/hassio\";\nimport \"../../../src/layouts/hass-loading-screen\";\nimport \"../../../src/layouts/hass-subpage\";\n\n@customElement(\"hassio-ingress-view\")\nclass HassioIngressView extends LitElement {\n  @property() public hass!: HomeAssistant;\n  @property() public route!: Route;\n  @property() private _addon?: HassioAddonDetails;\n\n  protected render(): TemplateResult | void {\n    if (!this._addon) {\n      return html`\n        <hass-loading-screen></hass-loading-screen>\n      `;\n    }\n\n    return html`\n      <hass-subpage .header=${this._addon.name} hassio>\n        <iframe src=${this._addon.ingress_url}></iframe>\n      </hass-subpage>\n    `;\n  }\n\n  protected updated(changedProps: PropertyValues) {\n    super.firstUpdated(changedProps);\n\n    if (!changedProps.has(\"route\")) {\n      return;\n    }\n\n    const addon = this.route.path.substr(1);\n\n    const oldRoute = changedProps.get(\"route\") as this[\"route\"] | undefined;\n    const oldAddon = oldRoute ? oldRoute.path.substr(1) : undefined;\n\n    if (addon && addon !== oldAddon) {\n      this._fetchData(addon);\n    }\n  }\n\n  private async _fetchData(addonSlug: string) {\n    try {\n      const [addon] = await Promise.all([\n        fetchHassioAddonInfo(this.hass, addonSlug).catch(() => {\n          throw new Error(\"Failed to fetch add-on info\");\n        }),\n        createHassioSession(this.hass).catch(() => {\n          throw new Error(\"Failed to create an ingress session\");\n        }),\n      ]);\n\n      if (!addon.ingress) {\n        throw new Error(\"This add-on does not support ingress\");\n      }\n\n      this._addon = addon;\n    } catch (err) {\n      // tslint:disable-next-line\n      console.error(err);\n      alert(err.message || \"Unknown error starting ingress.\");\n      history.back();\n    }\n  }\n\n  static get styles(): CSSResult {\n    return css`\n      iframe {\n        display: block;\n        width: 100%;\n        height: 100%;\n        border: 0;\n      }\n      paper-icon-button {\n        color: var(--text-primary-color);\n      }\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    \"hassio-ingress-view\": HassioIngressView;\n  }\n}\n"],"sourceRoot":""}

hassio/api/panel/chunk.6685a7f98b13655ab808.js.LICENSE

@@ -0,0 +1,189 @@
+/**
+ * @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 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) 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 (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
+*/
+
+/*!
+ * Fuse.js v3.4.4 - Lightweight fuzzy-search (http://fusejs.io)
+ * 
+ * Copyright (c) 2012-2017 Kirollos Risk (http://kiro.me)
+ * All Rights Reserved. Apache Software License 2.0
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */

hassio/api/panel/chunk.7f411ffa9df152cb8f05.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.7f8cce5798f837214ef8.js

@@ -0,0 +1,2 @@
+(window.webpackJsonp=window.webpackJsonp||[]).push([[9],{101: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(124),i=t.n(e),o=t(126),u=t.n(o),a=i.a,c=u.a}}]);
+//# sourceMappingURL=chunk.7f8cce5798f837214ef8.js.map

hassio/api/panel/chunk.7f8cce5798f837214ef8.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["webpack:///../src/resources/load_markdown.js"],"names":["__webpack_require__","r","__webpack_exports__","d","marked","filterXSS","marked__WEBPACK_IMPORTED_MODULE_0__","marked__WEBPACK_IMPORTED_MODULE_0___default","n","xss__WEBPACK_IMPORTED_MODULE_1__","xss__WEBPACK_IMPORTED_MODULE_1___default","marked_","filterXSS_"],"mappings":"0FAAAA,EAAAC,EAAAC,GAAAF,EAAAG,EAAAD,EAAA,2BAAAE,IAAAJ,EAAAG,EAAAD,EAAA,8BAAAG,IAAA,IAAAC,EAAAN,EAAA,KAAAO,EAAAP,EAAAQ,EAAAF,GAAAG,EAAAT,EAAA,KAAAU,EAAAV,EAAAQ,EAAAC,GAGaL,EAASO,IACTN,EAAYO","file":"chunk.7f8cce5798f837214ef8.js","sourcesContent":["import marked_ from \"marked\";\nimport filterXSS_ from \"xss\";\n\nexport const marked = marked_;\nexport const filterXSS = filterXSS_;\n"],"sourceRoot":""}

hassio/api/panel/chunk.9d7374dae6137783dda4.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.af7784dbf07df8e24819.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.b15efbd4fb2c8cac0ad4.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/entrypoint.js

@@ -0,0 +1,2 @@
+!function(e){function n(n){for(var t,o,a=n[0],i=n[1],f=0,c=[];f<a.length;f++)o=a[f],r[o]&&c.push(r[o][0]),r[o]=0;for(t in i)Object.prototype.hasOwnProperty.call(i,t)&&(e[t]=i[t]);for(u&&u(n);c.length;)c.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,f=document.createElement("script");f.charset="utf-8",f.timeout=120,o.nc&&f.setAttribute("nonce",o.nc),f.src=function(e){return o.p+"chunk."+{0:"7f411ffa9df152cb8f05",1:"598ae99dfd641ab3a30c",2:"af7784dbf07df8e24819",3:"b15efbd4fb2c8cac0ad4",5:"87d3a6d0178fb26762cf",6:"6f4702eafe52425373ed",7:"5dd33a3a20657ed46a19",8:"7c785f796f428abae18d",9:"7f8cce5798f837214ef8",10:"04bcaa18b59728e10be9",11:"9d7374dae6137783dda4",12:"6685a7f98b13655ab808",13:"f1156b978f6f3143a651"}[e]+".js"}(e),i=function(n){f.onerror=f.onload=null,clearTimeout(u);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 u=setTimeout(function(){i({type:"timeout",target:f})},12e4);f.onerror=f.onload=i,document.head.appendChild(f)}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 f=0;f<a.length;f++)n(a[f]);var u=i;o(o.s=0)}([function(e,n,t){window.loadES5Adapter().then(function(){Promise.all([t.e(1),t.e(6)]).then(t.bind(null,2)),Promise.all([t.e(1),t.e(12),t.e(8)]).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)}]);
+//# sourceMappingURL=entrypoint.js.map

hassio/api/panel/index.html

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

hassio/api/proxy.py

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

hassio/api/security.py

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

hassio/api/services.py

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

hassio/api/snapshots.py

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

hassio/api/supervisor.py

@@ -1,168 +1,174 @@
-"""Init file for HassIO supervisor rest api."""
+"""Init file for Hass.io Supervisor RESTful API."""
 import asyncio
 import logging
+from typing import Any, Awaitable, Dict
 
+from aiohttp import web
 import voluptuous as vol
 
-from .util import api_process, api_process_raw, api_validate
-from ..addons.util import create_hash_index_list
 from ..const import (
-    ATTR_ADDONS, ATTR_VERSION, ATTR_LAST_VERSION, ATTR_BETA_CHANNEL,
-    HASSIO_VERSION, ATTR_ADDONS_REPOSITORIES, ATTR_REPOSITORIES,
-    ATTR_REPOSITORY, ATTR_DESCRIPTON, ATTR_NAME, ATTR_SLUG, ATTR_INSTALLED,
-    ATTR_DETACHED, ATTR_SOURCE, ATTR_MAINTAINER, ATTR_URL, ATTR_ARCH)
+    ATTR_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_MEMORY_PERCENT,
+    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 ..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): [vol.Url()],
-})
+# 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(object):
-    """Handle rest api for supervisor functions."""
-
-    def __init__(self, config, loop, supervisor, addons, host_control):
-        """Initialize supervisor rest api part."""
-        self.config = config
-        self.loop = loop
-        self.supervisor = supervisor
-        self.addons = addons
-        self.host_control = host_control
-
-    def _addons_list(self, only_installed=False):
-        """Return a list of addons."""
-        detached = self.addons.list_detached
-
-        if only_installed:
-            addons = self.addons.data_installed
-        else:
-            addons = self.addons.data_all
-
-        data = []
-        for addon, values in addons.items():
-            i_version = self.addons.version_installed(addon)
-
-            data.append({
-                ATTR_NAME: values[ATTR_NAME],
-                ATTR_SLUG: addon,
-                ATTR_DESCRIPTON: values[ATTR_DESCRIPTON],
-                ATTR_VERSION: values[ATTR_VERSION],
-                ATTR_INSTALLED: i_version,
-                ATTR_ARCH: values[ATTR_ARCH],
-                ATTR_DETACHED: addon in detached,
-                ATTR_REPOSITORY: values[ATTR_REPOSITORY],
-            })
-
-        return data
-
-    def _repositories_list(self):
-        """Return a list of addons repositories."""
-        data = []
-        list_id = create_hash_index_list(self.config.addons_repositories)
-
-        for repository in self.addons.list_repositories:
-            data.append({
-                ATTR_SLUG: repository[ATTR_SLUG],
-                ATTR_NAME: repository[ATTR_NAME],
-                ATTR_SOURCE: list_id.get(repository[ATTR_SLUG]),
-                ATTR_URL: repository.get(ATTR_URL),
-                ATTR_MAINTAINER: repository.get(ATTR_MAINTAINER),
-            })
-
-        return data
+class APISupervisor(CoreSysAttributes):
+    """Handle RESTful API for Supervisor functions."""
 
     @api_process
     async def ping(self, request):
-        """Return ok for signal that the api is ready."""
+        """Return ok for signal that the API is ready."""
         return True
 
     @api_process
-    async def info(self, request):
+    async def info(self, request: web.Request) -> Dict[str, Any]:
         """Return host information."""
+        list_addons = []
+        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.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.config.last_hassio,
-            ATTR_BETA_CHANNEL: self.config.upstream_beta,
-            ATTR_ARCH: self.addons.arch,
-            ATTR_ADDONS: self._addons_list(only_installed=True),
-            ATTR_ADDONS_REPOSITORIES: self.config.addons_repositories,
+            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.sys_config.addons_repositories,
         }
 
     @api_process
-    async def available_addons(self, request):
-        """Return information for all available addons."""
-        return {
-            ATTR_ADDONS: self._addons_list(),
-            ATTR_REPOSITORIES: self._repositories_list(),
-        }
-
-    @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.config.upstream_beta = body[ATTR_BETA_CHANNEL]
+        if ATTR_CHANNEL in body:
+            self.sys_updater.channel = body[ATTR_CHANNEL]
+
+        if ATTR_TIMEZONE in body:
+            self.sys_config.timezone = body[ATTR_TIMEZONE]
+
+        if ATTR_WAIT_BOOT in body:
+            self.sys_config.wait_boot = body[ATTR_WAIT_BOOT]
+
+        if ATTR_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])
-            old = set(self.config.addons_repositories)
+            await asyncio.shield(self.sys_store.update_repositories(new))
 
-            # add new repositories
-            tasks = [self.addons.add_git_repository(url) for url in
-                     set(new - old)]
-            if tasks:
-                await asyncio.shield(
-                    asyncio.wait(tasks, loop=self.loop), loop=self.loop)
-
-            # remove old repositories
-            for url in set(old - new):
-                self.addons.drop_git_repository(url)
-
-            # read repository
-            self.addons.read_data_from_repositories()
-
-        return True
+        self.sys_updater.save_data()
+        self.sys_config.save_data()
 
     @api_process
-    async def update(self, request):
-        """Update supervisor OS."""
+    async def stats(self, request: web.Request) -> Dict[str, Any]:
+        """Return resource information."""
+        stats = await self.sys_supervisor.stats()
+
+        return {
+            ATTR_CPU_PERCENT: stats.cpu_percent,
+            ATTR_MEMORY_USAGE: stats.memory_usage,
+            ATTR_MEMORY_LIMIT: stats.memory_limit,
+            ATTR_MEMORY_PERCENT: stats.memory_percent,
+            ATTR_NETWORK_RX: stats.network_rx,
+            ATTR_NETWORK_TX: stats.network_tx,
+            ATTR_BLK_READ: stats.blk_read,
+            ATTR_BLK_WRITE: stats.blk_write,
+        }
+
+    @api_process
+    async def update(self, request: web.Request) -> None:
+        """Update Supervisor OS."""
         body = await api_validate(SCHEMA_VERSION, request)
-        version = body.get(ATTR_VERSION, self.config.last_hassio)
+        version = body.get(ATTR_VERSION, self.sys_updater.version_hassio)
 
-        if version == self.supervisor.version:
-            raise RuntimeError("Version is already in use")
-
-        return await asyncio.shield(
-            self.supervisor.update(version), loop=self.loop)
+        if version == self.sys_supervisor.version:
+            raise APIError("Version {} is already in use".format(version))
+        await asyncio.shield(self.sys_supervisor.update(version))
 
     @api_process
-    async def reload(self, request):
-        """Reload addons, config ect."""
-        tasks = [
-            self.addons.reload(), self.config.fetch_update_infos(),
-            self.host_control.load()
-        ]
-        results, _ = await asyncio.shield(
-            asyncio.wait(tasks, loop=self.loop), loop=self.loop)
+    def reload(self, request: web.Request) -> Awaitable[None]:
+        """Reload add-ons, configuration, etc."""
+        return asyncio.shield(self.sys_updater.reload())
 
-        for result in results:
-            if result.exception() is not None:
-                raise RuntimeError("Some reload task fails!")
+    @api_process
+    def repair(self, request: web.Request) -> Awaitable[None]:
+        """Try to repair the local setup / overlayfs."""
+        return asyncio.shield(self.sys_core.repair())
 
-        return True
-
-    @api_process_raw
-    def logs(self, request):
-        """Return supervisor docker logs.
-
-        Return a coroutine.
-        """
-        return self.supervisor.logs()
+    @api_process_raw(CONTENT_TYPE_BINARY)
+    def logs(self, request: web.Request) -> Awaitable[bytes]:
+        """Return supervisor Docker logs."""
+        return self.sys_supervisor.logs()

hassio/api/util.py

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

hassio/api/utils.py

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

hassio/arch.py

@@ -0,0 +1,91 @@
+"""Handle Arch for underlay maschine/platforms."""
+import logging
+from pathlib import Path
+import platform
+from typing import List
+
+from .coresys import CoreSys, CoreSysAttributes
+from .exceptions import HassioArchNotFound, JsonFileError
+from .utils.json import read_json_file
+
+_LOGGER = logging.getLogger(__name__)
+
+ARCH_JSON: Path = Path(__file__).parent.joinpath("data/arch.json")
+
+MAP_CPU = {
+    "armv7": "armv7",
+    "armv6": "armhf",
+    "armv8": "aarch64",
+    "aarch64": "aarch64",
+    "i686": "i386",
+    "x86_64": "amd64",
+}
+
+
+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(ARCH_JSON)
+        except JsonFileError:
+            _LOGGER.warning("Can't read arch json")
+            return
+
+        native_support = self.detect_cpu()
+
+        # 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 = native_support
+            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]
+
+        # Make sure native support is in supported list
+        if native_support not in self._supported_arch:
+            self._supported_arch.append(native_support)
+
+    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()
+
+    def detect_cpu(self) -> str:
+        """Return the arch type of local CPU."""
+        cpu = platform.machine()
+        for check, value in MAP_CPU.items():
+            if cpu.startswith(check):
+                return value
+        return self.sys_supervisor.arch